Introducing AgentLens — See What Your AI Agents Actually Do

The Problem

You've deployed an AI agent. It handles customer queries, processes documents, writes code. Most of the time it works. But when it doesn't, you're left staring at unstructured logs trying to reconstruct what happened.

Which tools did it call? What reasoning led it to choose path A over path B? How many tokens did that one expensive run actually burn? Standard observability tools weren't built to answer these questions. Datadog tracks HTTP requests. Sentry catches exceptions. Neither understands the concept of an agent making decisions across multiple LLM calls, tool invocations, and branching logic.

The result: you're flying blind. You can't debug agent failures efficiently, you can't optimize costs, and you can't explain to stakeholders why the agent did what it did.

What AgentLens Does

AgentLens is an open-source observability platform purpose-built for AI agents. It captures the full execution trace of your agent runs and presents them as structured, navigable visualizations.

This isn't API call logging with a coat of paint. AgentLens understands agent semantics: decision trees, tool execution chains, reasoning steps, and the relationships between them. You see the full picture of what your agent did and why.

Key Features

Decision Tracking

Every tool call, every reasoning step, visualized as a decision tree. When your agent decides to call a search API instead of querying a database, you see that branch point. When it retries a failed operation with different parameters, you see the full retry chain. No more guessing.

Execution Timeline

A horizontal timeline showing exactly when your agent was thinking (waiting for LLM responses), waiting (on external APIs), or executing (running tool code). This is where you find the bottlenecks. If 80% of your agent's wall-clock time is spent waiting on a single tool call, you know exactly where to optimize.

Token & Cost Analytics

Know exactly what each agent run costs, broken down by model and individual call. AgentLens tracks input tokens, output tokens, and maps them to your provider's pricing. No more end-of-month surprises on your OpenAI bill.

Multi-Framework Support

AgentLens works wherever your agents run. The platform ships with:

• → Python SDK — instrument any Python agent with a few lines of code
• → TypeScript SDK — full support for Node.js and Deno runtimes
• → OpenCode plugin — drop-in integration for OpenCode-based workflows

Compatible with OpenAI, Anthropic, and LangChain out of the box. The trace format is framework-agnostic, so adding support for new providers is straightforward.

Real-Time Streaming

Watch traces arrive live via Server-Sent Events. As your agent executes, spans appear in the dashboard in real time. No batching, no polling, no waiting for the run to finish before you can see what's happening. This matters when you're debugging a long-running agent that's stuck or behaving unexpectedly.

New in v0.2.0

The latest release adds the infrastructure needed to run AgentLens as a hosted service, not just a self-hosted tool.

• → User accounts — email and password authentication with secure session management
• → API key management — generate and revoke keys directly from the dashboard
• → Three subscription tiers — Free (20 sessions/day), Starter ($5/mo, 1K sessions), Pro ($20/mo, 100K sessions)
• → Stripe-powered billing — self-service portal for upgrades, downgrades, and invoice history

The free tier is generous enough for individual developers and small projects. If you're running agents in production at scale, the Pro tier gives you room to grow without worrying about session limits.

Getting Started

Instrumenting your agent takes less than five minutes. Install the SDK, initialize it with your API key, and wrap your agent code in a trace context:

from agentlens import init, trace

init(api_key="al_your_key_here", endpoint="https://agentlens.vectry.tech")

with trace("my-agent"):
    # Your agent code here
    pass

That's it. Every LLM call, tool invocation, and decision point inside the trace block is automatically captured and sent to your AgentLens dashboard. The SDK is lightweight and adds negligible overhead to your agent's execution time.

For TypeScript, the pattern is similar:

import { init, trace } from "@agentlens/sdk";

init({ apiKey: "al_your_key_here", endpoint: "https://agentlens.vectry.tech" });

await trace("my-agent", async () => {
  // Your agent code here
});

Sign up for a free account at agentlens.vectry.tech/register, grab your API key from the dashboard, and you're ready to go.

Under the Hood

AgentLens is built as a monorepo with a clear separation between the ingestion layer, the storage layer, and the visualization frontend.

• ▸ Backend: Go service handling trace ingestion via REST and SSE streaming
• ▸ Frontend: React dashboard with real-time trace visualization
• ▸ Storage: PostgreSQL for structured data, optimized for time-series trace queries
• ▸ SDKs: Python and TypeScript, both published to their respective package registries
• ▸ Billing: Stripe integration with webhook-driven subscription lifecycle

The entire platform is open source. You can self-host it, fork it, or contribute to it. The codebase lives at gitea.repi.fun/repi/agentlens.

Why We Built This

At Vectry, we build AI-powered systems for clients. That means we deploy agents in production, and we need to know what they're doing. We tried bolting observability onto existing tools. We tried structured logging. We tried building custom dashboards on top of Grafana.

None of it worked well enough. The fundamental problem is that traditional observability assumes request-response patterns. An agent is different: it's a multi-step, branching, sometimes recursive process where the "request" is a goal and the "response" is a sequence of decisions. You need tooling that understands that model.

AgentLens is the tool we wished existed. Now it does.