import { Activity, Brain, DollarSign, ArrowRight, CheckCircle2, GitBranch, Cpu, Zap, Terminal, Code2, Eye, Package, Link2, Bot, Star, Clipboard, } from "lucide-react"; export default function HomePage() { return (
{/* Hero Section */}
{/* Subtle grid pattern for depth */}
{/* Top badges row */}
Agent Observability Platform
Open Source

AgentLens

See why your AI agents make the decisions they make.
Complete observability for multi-agent systems.

{/* pip install snippet */}
pip install vectry-agentlens
{/* Features Section */}

Everything you need to understand your agents

From decision trees to cost intelligence, get complete visibility into how your AI systems operate

{/* Feature 1: Decision Trees */}

Decision Trees

Visualize the complete reasoning behind every agent choice. See the branching logic, alternatives considered, and the path chosen.

{/* Feature 2: Context Awareness */}

Context Awareness

Monitor context window utilization in real-time. Track what's being fed into your agents and what's being left behind.

{/* Feature 3: Cost Intelligence */}

Cost Intelligence

Track spending per decision, per agent, per trace. Get granular insights into where every dollar goes in your AI operations.

{/* How it Works Section */}
Quick Setup

Up and running in 3 steps

Go from zero to full agent observability in under five minutes

{/* Step 1: Install */}
1

Install

One command to add AgentLens to your project.

pip install vectry-agentlens
{/* Step 2: Instrument */}
2

Instrument

Add the @trace decorator or use wrap_openai().

@trace / wrap_openai()
{/* Step 3: Observe */}
3

Observe

See every decision in the real-time dashboard.

agentlens.vectry.tech
{/* Connecting arrows decoration */}
{/* Code Example Section */}
Python SDK

Instrument your agents in minutes

Our Python SDK integrates seamlessly with LangChain, OpenAI, and custom agents. Add observability without changing your architecture.

    {[ "Drop-in decorators for automatic tracing", "No code changes required for LangChain", "Async-first design with minimal overhead", "Type-safe with full IDE support", ].map((feature, i) => (
  • {feature}
    • ))}
{/* Code Blocks - Two patterns stacked */}
{/* Decorator Pattern */}
decorator_pattern.py
@trace 
                  
                    from{" "}
                    agentlens{" "}
                    import{" "}
                    init
                    ,{" "}
                    trace
                    {"\n"}
                    {"\n"}
                    # Initialize AgentLens
                    {"\n"}
                    init
                    (
                    {"\n"}
                    {"    "}
                    api_key
                    =
                    "your-api-key"
                    ,
                    {"\n"}
                    {"    "}
                    endpoint
                    =
                    "https://agentlens.vectry.tech"
                    {"\n"}
                    )
                    {"\n"}
                    {"\n"}
                    # Trace your agent function
                    {"\n"}
                    @trace
                    (
                    name
                    =
                    "research-agent"
                    )
                    {"\n"}
                    async{" "}
                    def{" "}
                    research
                    (
                    topic
                    :{" "}
                    str
                    ):
                    {"\n"}
                    {"    "}
                    # Your agent logic here
                    {"\n"}
                    {"    "}
                    return{" "}
                    f"Researching: {"{topic}"}"
{/* OpenAI Wrapper Pattern */}
openai_wrapper.py
wrap_openai 
                  
                    from{" "}
                    agentlens.integrations.openai{" "}
                    import{" "}
                    wrap_openai
                    {"\n"}
                    import{" "}
                    openai
                    {"\n"}
                    {"\n"}
                    # Wrap the OpenAI client
                    {"\n"}
                    client{" "}
                    ={" "}
                    openai.
                    OpenAI
                    ()
                    {"\n"}
                    client{" "}
                    ={" "}
                    wrap_openai
                    (client)
                    {"\n"}
                    {"\n"}
                    # Use as normal - traces automatically
                    {"\n"}
                    response{" "}
                    ={" "}
                    client.chat.completions.
                    create
                    (
                    {"\n"}
                    {"    "}
                    model
                    =
                    "gpt-4"
                    ,
                    {"\n"}
                    {"    "}
                    messages
                    =
                    [
                    {"{"}
                    "role"
                    :{" "}
                    "user"
                    ,{" "}
                    "content"
                    :{" "}
                    "Hello!"
                    {"}"}
                    ]
                    {"\n"}
                    )
{/* Integrations Section */}
Integrations

Works with your stack

First-class support for the most popular AI frameworks. Drop in and start tracing.

{/* OpenAI */}

OpenAI

GPT-4, GPT-3.5, o1

wrap_openai()
{/* LangChain */}

LangChain

Chains, Agents, Tools

Auto-instrumented
{/* Custom Agents */}

Custom Agents

Any Python agent

@trace decorator
{/* Footer */}
); }