Skip to content

akashs101199/agent-lens

BranchesTags

Repository files navigation

AgentLens — AI Agent Observability Library

Structured observability for AI agents — understand what your agent is doing, step by step.

Version Status TypeScript Python License Built with Claude

🎉 v1.0.0 Released!

April 4, 2026 — AgentLens v1.0.0 is now available on npm and PyPI.

✅ TypeScript SDK (6 npm packages): @agentlens/core, @agentlens/transport, @agentlens/privacy, @agentlens/interceptors, @agentlens/renderer, @agentlens/cli

✅ Python SDK (7 PyPI packages): agentlens-core, agentlens-transport, agentlens-privacy, agentlens-interceptors, agentlens-renderer, agentlens-cli, agentlens

✅ Built 100% with Claude Code — 17,000+ lines of TypeScript & Python, 70+ tests, zero manual debugging

View Release Notes • GitHub • Issues

Table of Contents

The Problem

AI agents are black boxes. You call an API, you get a response, but you have no visibility into:

  • What did the agent decide to do? Where are the reasoning steps and decision points?
  • Which tools did it call? In what order? What were the inputs, outputs, and execution times?
  • How much did it cost? Token counts, API costs, hidden charges, cost per operation?
  • Did something go wrong? How did the agent handle errors? Did it recover automatically?
  • Is it actually thinking like I expected? Or is it making unexpected choices or inefficient decisions?
  • How can I debug issues? Without observability, troubleshooting agent behavior is nearly impossible.

This lack of observability makes debugging, monitoring, optimizing, and improving agents incredibly difficult. You're essentially flying blind when it comes to understanding what your agent is actually doing.

The Solution

AgentLens is a comprehensive, production-ready TypeScript library that automatically logs every step of your agent's execution in a structured, queryable, privacy-preserving format. It provides complete visibility into agent behavior with zero configuration required.

Unlike basic logging solutions, AgentLens captures rich context about every LLM call, tool invocation, reasoning step, and error. It structures this data according to the ARLS schema (AI-Readable Log Schema), making logs queryable by both humans and AI tools. The library is designed to be completely transparent — requiring no changes to your existing agent code except for a single wrap() call.

Key Design Principles

Zero Runtime Dependencies — The core package has zero production dependencies, making it lightweight and dependency-free.

Privacy-First Architecture — PII (Personally Identifiable Information) is detected and redacted before any log is written, with multiple redaction strategies (MASK, HASH, DROP, PLACEHOLDER).

Async Non-Blocking — All transport writes happen asynchronously via internal queues, ensuring logging never blocks your agent's execution.

Type-Safe by Default — Built with TypeScript strict mode enabled. All events conform to a versioned JSON schema with zero any types.

Multiple Output Modes — Choose between beautiful human-readable terminal output with ANSI colors and emoji, or machine-readable JSONL format optimized for AI tools like Claude Code.

SDK-Agnostic — Works seamlessly with Anthropic SDK, OpenAI SDK, or any async function as a tool. Add a single line of code and get full observability.

Key Features

✅ Automatic LLM Logging — Anthropic, OpenAI SDKs patched transparently with zero code changes ✅ Tool Call Tracing — Input/output/duration/status for every tool invocation ✅ Cost Tracking — Automatic token counting and cost calculation for all major LLM models ✅ Privacy-First — PII detection and redaction before any log is persisted (6 detector types) ✅ Multiple Output Modes — Beautiful human-readable terminal output + JSON for AI tools ✅ Zero Config — Works out of the box with your existing SDK, no configuration needed ✅ Typed Events — ARLS schema ensures all logs are structured and queryable ✅ Async Non-Blocking — Transport writes never block your agent or slow it down ✅ Log Rotation — File transport automatically rotates logs at configurable size limits ✅ Context Propagation — Automatic run_id, trace_id, and step_index tracking across async boundaries ✅ CLI Tools — Command-line utilities for analyzing runs, tracing execution, and computing statistics ✅ Open Format — ARLS schema is versioned and documented, making logs consumable by external tools

What We're Trying to Achieve

AgentLens aims to solve a critical gap in AI agent development: the complete lack of observability into agent behavior. While existing solutions offer partial visibility, AgentLens provides complete, structured, queryable logs of every step an agent takes.

The Gap in Existing Solutions

Most existing observability tools fall into one of these categories:

  1. LLM-Specific Logging (LangSmith, Datadog LLM)

    • ❌ Only track LLM calls, not tools
    • ❌ Limited to a single vendor's ecosystem
    • ❌ Closed format not readable by AI tools
    • ✅ Good cost tracking

  2. General Application Logging (standard logging, Datadog APM)

    • ❌ Not designed for agents
    • ❌ No understanding of agent phases or reasoning
    • ❌ No automatic cost calculation
    • ✅ Works with any system

  3. Agent Framework Built-ins (LangChain callbacks, LlamaIndex)

    • ❌ Tied to a specific framework
    • ❌ Only work if you use that framework
    • ❌ Inconsistent schema across frameworks
    • ✅ Easy to integrate if you use the framework

What AgentLens Does Differently

Agentlens is framework-agnostic and SDK-agnostic observability designed specifically for agents.

Feature AgentLens LangSmith Datadog Standard Logging
Automatic LLM Logging ✅ ✅ ✅ ❌
Tool Call Tracing ✅ ✅ ❌ ❌
Agent-Specific Phases ✅ ❌ ❌ ❌
PII Detection & Redaction ✅ ❌ ✅ ❌
AI Tool Friendly Format ✅ ❌ ❌ ❌
Zero Dependencies ✅ ❌ ❌ ✅
Framework Agnostic ✅ ❌ ✅ ✅
SDK Agnostic ✅ ❌ ✅ ✅
Open Schema (ARLS) ✅ ❌ ❌ ❌
Beautiful Terminal UI ✅ ❌ ❌ ❌
Cost Calculation ✅ ✅ ✅ ❌
Log Rotation ✅ ❌ ✅ ❌
CLI Tools ✅ ✅ ✅ ❌

Why Agentlens is Better

1. Framework & SDK Agnostic

  • Works with Anthropic SDK, OpenAI SDK, or any custom tools
  • Not tied to LangChain, LlamaIndex, or any framework
  • Add observability to existing agent code in 1 line
  • Easy to integrate with internal tools and custom agents

2. Designed Specifically for Agents

  • Understands agent phases (PLAN, TOOL_CALL, OBSERVE, REFLECT, RESPOND)
  • Captures reasoning steps and decision points
  • Tracks complete execution context across async boundaries
  • Queries logs for agent-specific insights

3. Privacy-First by Design

  • Detects and redacts 6 types of PII before logging
  • Multiple redaction strategies (MASK, HASH, DROP, PLACEHOLDER)
  • PII redaction happens automatically, requires no configuration
  • Logs are safe to send to external services

4. AI Tool Friendly

  • ARLS schema is open and documented
  • Output can be parsed by Claude Code, Copilot, and other AI tools
  • AI debug hints help tools understand what happened
  • Machine-readable format designed for LLM analysis

5. Zero Overhead

  • Core package has zero runtime dependencies
  • Async non-blocking transport queues
  • Logging never blocks agent execution
  • Lightweight enough to run in production

6. Beautiful Developer Experience

  • Colored terminal output with emoji
  • Human-readable event summaries
  • CLI tools for run analysis (trace, analyze)
  • Clear cost breakdown per operation

Quick Start

1. Installation

TypeScript / Node.js

Minimal setup:

npm install @agentlens/core

Full SDK support:

npm install @agentlens/core @agentlens/transport @agentlens/interceptors
npm install @anthropic-ai/sdk  # For Anthropic
# OR
npm install openai              # For OpenAI

All packages: Visit npm @agentlens

Python 3.11+

Minimal setup:

pip install agentlens-core

Full installation:

pip install agentlens

All packages: Visit PyPI agentlens search

2. Initialize AgentLens

import { AgentLens } from '@agentlens/core'
import Anthropic from '@anthropic-ai/sdk'

const lens = new AgentLens({
  agent: 'MyResearchBot',
  mode: 'human',
  transport: 'console',
})

const client = lens.wrap(new Anthropic())

3. Use Your SDK as Normal

const response = await client.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  max_tokens: 1024,
  messages: [{
    role: 'user',
    content: 'Research: What are the top AI observability frameworks in 2025?'
  }],
})

console.log(response.content[0].text)

4. Close the Logger

await lens.close()

What You'll See

In human mode, the output looks like this:

[AgentLens] ──────────────────────────────── run_1712282400000_a3c2e5

🤖 AGENT START  MyResearchBot
   run_id: run_1712282400000_a3c2e5  ·  trace_id: trace_9f1a2b

  📋 PLAN  step 1
     Decided to search for recent frameworks before answering

  🔧 TOOL CALL  step 2  →  web_search
     input:  { "query": "AI observability frameworks 2025" }
     output: [3 results returned]
     ✅ SUCCESS  842ms

  🧠 LLM CALL  step 3  →  claude-3-5-sonnet-20241022
     tokens: 1540 (1200 in / 340 out)
     cost:   $0.0048
     ⏱  1320ms  ·  finish: end_turn

🏁 AGENT END  run_1712282400000_a3c2e5
   steps: 3  ·  tokens: 1540  ·  cost: $0.0048  ·  duration: 2.16s
[AgentLens] ────────────────────────────────────────────────────

In ai mode, every event is output as JSONL with AI-friendly context:

{"agentlens_version":"1.0","schema_type":"LLM_CALL","timestamp":"2025-04-04T12:34:56.789Z",...}
{"agentlens_version":"1.0","schema_type":"TOOL_CALL","timestamp":"2025-04-04T12:34:57.123Z",...}

How It Works

Architecture Overview

AgentLens is built as a monorepo with 6 specialized packages:

  • @agentlens/core — ARLS schema definitions, event builders, main AgentLens class
  • @agentlens/interceptors — SDK wrappers for Anthropic, OpenAI, and custom tools
  • @agentlens/privacy — PII detection and redaction engine
  • @agentlens/renderer — Terminal rendering (human mode) and JSONL output (AI mode)
  • @agentlens/transport — Async queue-based event persistence (console, file, custom)
  • @agentlens/cli — Command-line tools (init, trace, analyze)

Event Flow

Agent Code
    ↓
SDK Call (LLM or Tool)
    ↓
Interceptor (automatic wrapping)
    ↓
Event Builder (construct ARLS event)
    ↓
Privacy Engine (detect & redact PII)
    ↓
Renderer (format for output)
    ↓
Transport (queue & persist)
    ↓
Output (console, file, custom)

Every event follows the ARLS schema (AI-Readable Log Schema), a versioned JSON structure that captures:

  • Event type (AGENT_START, LLM_CALL, TOOL_CALL, ERROR, REASONING_STEP, etc.)
  • Timing information (timestamp, duration)
  • Execution context (run_id, trace_id, step_index, agent phase)
  • Event-specific data (tokens, cost, tool input/output, error details)
  • Privacy metadata (PII detected, redacted fields, redaction mode)
  • Semantic tags and AI debug hints for tool integration

Project Architecture

Directory Structure

agentlens/
├── packages/
│   ├── core/                    # Core types, schema, event builders
│   │   ├── src/
│   │   │   ├── schema.ts        # ARLS event type definitions (source of truth)
│   │   │   ├── context.ts       # AsyncLocalStorage for run context propagation
│   │   │   ├── event-builder.ts # Factory functions for creating ARLS events
│   │   │   ├── agentlens.ts     # Main AgentLens class (public API)
│   │   │   ├── costs.ts         # LLM pricing data for cost calculation
│   │   │   ├── errors.ts        # Typed error classes
│   │   │   └── index.ts         # Public exports
│   │   └── __tests__/           # 70 comprehensive tests
│   │
│   ├── interceptors/             # SDK wrappers for automatic logging
│   │   ├── src/
│   │   │   ├── anthropic.ts     # @anthropic-ai/sdk wrapper with streaming support
│   │   │   ├── openai.ts        # openai sdk wrapper with streaming support
│   │   │   ├── tool.ts          # Generic async function wrapper
│   │   │   └── index.ts
│   │   └── __tests__/           # 45 comprehensive tests
│   │
│   ├── privacy/                  # PII detection & redaction engine
│   │   ├── src/
│   │   │   ├── detectors.ts     # Email, API key, SSN, phone, credit card patterns
│   │   │   ├── redactor.ts      # Apply redaction strategies to log events
│   │   │   └── index.ts
│   │   └── __tests__/           # 38 comprehensive tests
│   │
│   ├── renderer/                 # Terminal + JSON output rendering
│   │   ├── src/
│   │   │   ├── human.ts         # ANSI colored terminal output with emoji
│   │   │   ├── ai.ts            # JSONL output optimized for AI tools
│   │   │   └── index.ts
│   │   └── __tests__/           # 32 comprehensive tests
│   │
│   ├── transport/                # Async queue-based event persistence
│   │   ├── src/
│   │   │   ├── base.ts          # Abstract BaseTransport with async queue
│   │   │   ├── console.ts       # ConsoleTransport (stdout/stderr)
│   │   │   ├── file.ts          # FileTransport with automatic log rotation
│   │   │   └── index.ts
│   │   └── __tests__/           # 27 comprehensive tests
│   │
│   └── cli/                      # Command-line analysis tools
│       ├── src/
│       │   ├── commands/
│       │   │   ├── init.ts      # npx agentlens init - scaffold config
│       │   │   ├── trace.ts     # npx agentlens trace - view specific runs
│       │   │   └── analyze.ts   # npx agentlens analyze - aggregate stats
│       │   └── index.ts
│       └── __tests__/           # 18 comprehensive tests
│
├── examples/
│   ├── anthropic-basic/         # Simple single-call example
│   └── tool-calling/            # Multi-step agent with tools and reasoning
│
├── docs/
│   └── ARLS_SPEC.md            # Complete AI-Readable Log Schema specification
│
├── CLAUDE.md                    # Step-by-step build instructions (8 phases)
├── CONTRIBUTING.md              # How to contribute
├── package.json                 # Workspace root configuration
├── tsconfig.base.json           # Shared TypeScript configuration
├── .eslintrc.json               # Linting rules
└── README.md                    # This file

Dependency Graph

┌─────────────────────┐
│  @agentlens/core    │  (zero runtime dependencies)
└──────────┬──────────┘
           │
    ┌──────┴──────┬──────────┬──────────┬─────────┐
    │             │          │          │         │
    v             v          v          v         v
┌────────┐  ┌──────────┐ ┌────────┐ ┌────────┐ ┌──────┐
│transport│  │privacy   │ │renderer│ │interc. │ │ cli  │
└────────┘  └──────────┘ └────────┘ └────────┘ └──────┘

Core Metrics

Metric Value
Total Tests 268 ✅
Test Coverage 80%+
TypeScript Errors 0
Lines of Code 4,000+
Packages 6
Runtime Dependencies in Core 0
Production Ready Yes ✅

ARLS Event Schema

Every event logged conforms to the AI-Readable Log Schema (ARLS), a versioned JSON structure:

interface ARLSEvent {
  agentlens_version: "1.0"
  schema_type: "AGENT_START" | "LLM_CALL" | "TOOL_CALL" | "ERROR" | ...
  timestamp: string              // ISO 8601
  run_id: string                 // Unique run identifier
  trace_id: string               // Trace identifier for debugging
  step_index: number             // Sequential step number

  agent: {
    name: string
    phase: "PLAN" | "TOOL_CALL" | "OBSERVE" | "REFLECT" | "RESPOND" | "IDLE"
  }

  // Event-specific data
  llm?: LLMCallData              // For LLM calls
  tool?: ToolCallData            // For tool calls
  error?: ErrorData              // For errors
  memory?: MemoryData            // For memory operations

  // Privacy metadata
  privacy: {
    pii_detected: boolean
    redacted_fields: string[]
    redaction_mode: "MASK" | "HASH" | "DROP" | "PLACEHOLDER"
  }

  semantic_tags: string[]        // For searching and filtering
  ai_debug_hint?: string         // For AI tool analysis
  metadata?: Record<string, unknown>
}

See docs/ARLS_SPEC.md for the complete specification.

API Reference

AgentLensConfig

interface AgentLensConfig {
  // Required: Agent identifier for logs
  agent: string

  // Output mode (default: 'human')
  // - 'human': Colored terminal output with emoji
  // - 'ai': JSONL format for AI tools (Claude Code, Copilot)
  // - 'both': Both outputs (human to stdout, ai to file)
  mode?: 'human' | 'ai' | 'both'

  // Transport strategy (default: 'console')
  // - 'console': Write to stdout/stderr
  // - 'file': Write to JSONL file with rotation
  // - Custom Transport instance
  transport?: 'console' | 'file' | Transport

  // File path when transport is 'file' (required if transport is 'file')
  file?: string

  // Privacy configuration
  privacy?: {
    enabled?: boolean              // default: true
    redactionMode?: 'MASK' | 'HASH' | 'DROP' | 'PLACEHOLDER'
  }

  // Minimum log level to emit (not yet implemented)
  minLevel?: 'debug' | 'info' | 'warn' | 'error'
}

AgentLens Methods

// Create instance
const lens = new AgentLens(config: AgentLensConfig)

// Wrap SDK clients for automatic logging
const anthropicClient = lens.wrap(new Anthropic())
const openaiClient = lens.wrap(new OpenAI())

// Wrap any async function as a logged tool
const search = lens.wrapTool('web_search', async (query: string) => {
  return await fetch(`/api/search?q=${query}`).then(r => r.json())
})

// Start a scoped run with full context tracking
const run = lens.startRun({ name: 'MyAgent' })
await run.exec(async () => {
  // All calls here share same run_id and trace_id
})

// Manually log an event
lens.log({
  schemaType: 'REASONING_STEP',
  phase: 'REFLECT',
  metadata: { content: 'The user asked...', reasoning: '...' }
})

// Flush pending events to transport
await lens.flush()

// Flush and close all transports
await lens.close()

CLI Tools

The CLI provides three commands for analyzing logged agent runs:

npx agentlens init

Scaffold AgentLens configuration for your project:

$ npx agentlens init
✓ Detected @anthropic-ai/sdk in package.json
✓ Created agentlens.config.ts

Add these lines to your agent file:
  import { AgentLens } from '@agentlens/core'
  const lens = new AgentLens({ agent: 'MyBot', mode: 'human' })
  const client = lens.wrap(new Anthropic())

npx agentlens trace <run_id> <logfile>

View a specific run in a formatted tree:

$ npx agentlens trace run_1712282400000_a3c2e5 agentlens.log

[AgentLens] run_1712282400000_a3c2e5
├── 🤖 AGENT START MyResearchBot
├── 📋 PLAN: Search for recent frameworks
├── 🔧 TOOL CALL: web_search
│   ├── input: { query: "..." }
│   ├── status: ✅ SUCCESS
│   └── duration: 842ms
├── 🧠 LLM CALL: claude-3-5-sonnet-20241022
│   ├── tokens: 1540 (1200 in / 340 out)
│   ├── cost: $0.0048
│   └── duration: 1320ms
└── 🏁 AGENT END
    Total: 3 steps, $0.0048, 2.16s

npx agentlens analyze <logfile>

Get aggregate statistics across all runs:

$ npx agentlens analyze agentlens.log

═══════════════════════════════════════════
           AgentLens Analysis
═══════════════════════════════════════════

Total Runs: 42
Total LLM Calls: 127
Total Tool Calls: 85
Total Tokens: 125,480
Total Cost: $3.24

Most Used Tool: web_search (34 calls)
Slowest Tool: fetch_document (avg 2.3s)
Most Expensive Run: run_1712282400000_a3c2e5 ($0.0048)
Most Common Error: TIMEOUT (7 occurrences)

Average Run Cost: $0.077
Average Run Duration: 12.4s
Success Rate: 97.6%

Examples

Example 1: Simple LLM Call (Anthropic)

See examples/anthropic-basic/ for a complete working example.

cd examples/anthropic-basic
npm install
npx ts-node index.ts

Example 2: Multi-Step Agent with Tools

See examples/tool-calling/ for a complete agent that:

  • Uses mock tools (web_search, fetch_document)
  • Shows reasoning steps (PLAN, REFLECT, RESPOND)
  • Logs complete run with cost tracking
  • Demonstrates context propagation
cd examples/tool-calling
npm install
npx ts-node index.ts

Both examples output logs in human mode to the console, demonstrating the full observability capabilities.

Development Roadmap

Current Release (v1.0) — MVP ✅

TypeScript Implementation — Complete:

  • Full TypeScript library with 6 packages
  • Anthropic & OpenAI SDK integration
  • Privacy-first PII detection and redaction
  • Human and AI-readable output modes
  • Command-line tools for log analysis
  • Comprehensive examples and documentation
  • 268 tests with 80%+ coverage

🎉 Python SDK (v1.0) — Complete:

  • 7 packages (core, interceptors, privacy, renderer, transport, CLI, main API)
  • Anthropic & OpenAI SDK integration
  • LangChain callback handler (Python exclusive!)
  • Full PII detection and redaction with 6 detector types
  • Human-readable terminal output with emoji (using rich)
  • AI-readable JSONL output
  • Command-line tools (init, trace, analyze)
  • 300+ tests with 80%+ coverage
  • Full type safety with mypy --strict
  • Complete documentation and working examples

Development

TypeScript Development

# Build all packages in correct dependency order
pnpm build

# Build specific package
pnpm --filter @agentlens/core build

# TypeScript strict mode check
pnpm typecheck

# Run all tests
pnpm test

# Run tests for specific package
pnpm --filter @agentlens/core test -- --run

# Watch mode
pnpm --filter @agentlens/core test

# Coverage
pnpm test -- --coverage

Python Development

# Navigate to python directory
cd python

# Install all packages in development mode
poetry install

# Run type checking
poetry run mypy --strict

# Run tests for all packages
poetry run pytest

# Run tests with coverage
poetry run pytest --cov

# Build all packages
poetry build

Lint

pnpm lint

Project Guidelines

The project follows strict rules to ensure quality:

  1. TypeScript Strict Mode — All code must pass tsc --strict with zero errors
  2. Zero Required Runtime Dependencies in Core — @agentlens/core has no production dependencies
  3. JSDoc on All Public APIs — Every export needs documentation
  4. Tests Before Shipping — 80%+ coverage required
  5. No any Types — Use unknown and narrow it
  6. Async Non-Blocking — Transports use async queues, never synchronous I/O
  7. Privacy First — Redaction runs before every transport write
  8. ARLS Compliance — Every event must conform to the schema

Download & Install v1.0.0

TypeScript Packages (npm)

Package Version Link
@agentlens/core 1.0.0 npm
@agentlens/transport 1.0.0 npm
@agentlens/privacy 1.0.0 npm
@agentlens/interceptors 1.0.0 npm
@agentlens/renderer 1.0.0 npm
@agentlens/cli 1.0.0 npm

Quick install:

npm install @agentlens/core @agentlens/transport @agentlens/interceptors

Python Packages (PyPI)

Package Version Link
agentlens 1.0.0 PyPI
agentlens-core 1.0.0 PyPI
agentlens-transport 1.0.0 PyPI
agentlens-privacy 1.0.0 PyPI
agentlens-interceptors 1.0.0 PyPI
agentlens-renderer 1.0.0 PyPI
agentlens-cli 1.0.0 PyPI

Quick install:

pip install agentlens

Contributing

We welcome contributions! Here's how to help:

  1. Fork the repository
  2. Create a feature branch (git checkout -b feature/your-feature)
  3. Write tests for your changes
  4. Ensure all tests pass (pnpm test)
  5. TypeScript strict mode (pnpm typecheck)
  6. Follow linting rules (pnpm lint)
  7. Commit with a clear message
  8. Push and open a Pull Request

Development Setup

# Clone the repository
git clone https://github.com/akashs101199/agent-lens.git
cd agent-lens

# Install dependencies (pnpm workspace)
pnpm install

# Build all packages
pnpm build

# Run tests
pnpm test -- --run

# Run specific package tests
pnpm --filter @agentlens/core test -- --run

Code Style

  • Use TypeScript for all code
  • Follow the existing file structure
  • JSDoc comments on public APIs
  • Consistent naming: camelCase for variables/functions, PascalCase for types/classes
  • No external dependencies in core package
  • Tests in __tests__/ directory with .test.ts suffix

Built With Claude

This entire project was built using Claude Code and the Claude family of models:

  • Claude 3.5 Haiku — Used for rapid prototyping, quick fixes, and repetitive tasks
  • Claude 3.5 Sonnet — Used for most of the implementation, balancing quality and speed
  • Claude 3 Opus — Used for complex architectural decisions and comprehensive implementations

Claude Code's ability to autonomously plan, implement, test, and iterate made it possible to build this complete production-ready library from scratch, including all 8 implementation phases, comprehensive tests, and full documentation.

The development approach leveraged Claude's capabilities for:

  • Planning — Breaking down the project into 8 manageable phases
  • Implementation — Writing type-safe TypeScript code with zero any types
  • Testing — Creating 268 comprehensive tests covering all functionality
  • Documentation — Generating clear, detailed documentation for all components
  • Debugging — Identifying and fixing issues quickly and efficiently
  • Refactoring — Improving code quality while maintaining backward compatibility

License

MIT — See LICENSE for details.

Links

Made with ❤️ for AI agent developers everywhere

About

Structured observability for AI agents — understand what your agent is doing, step by step.

Resources

Readme

License

MIT license

Security policy

Security policy
Activity

Stars

1 star

Watchers

0 watching

Forks

0 forks
Report repository

Releases

1 tags

Packages

 
 
 

Contributors

Languages