Skip to main content
Glama

πŸ“‘ Table of Contents


AgentLens is a flight recorder for AI agents. It captures every LLM call, tool invocation, approval decision, and error β€” then presents it through a queryable API and real-time web dashboard.

Related MCP server: GoLogX (logx-mcp)

πŸ”’ Tamper-evident by design

What sets AgentLens apart from other observability tools: every event is SHA-256 hash-chained to the one before it, the same way git commits and blockchains are linked. The audit log is append-only and cryptographically verifiable β€” alter, delete, or reorder a single record after the fact and verification fails, pointing at the exact event that broke. Purpose-built for the record-keeping obligations of EU AI Act Article 12 and the emerging IETF Agent Audit Trail work.

See it for yourself in 30 seconds (needs Docker):

git clone https://github.com/agentkitai/agentlens && cd agentlens
./demo/aha.sh
1/5  Starting AgentLens (SQLite, zero-config)…   βœ“ up at http://localhost:3400
2/5  Ingesting a 5-event agent trace…            βœ“ 5 events ingested
3/5  Verifying the hash chain…                    βœ“ CHAIN VALID β€” no tampering detected
4/5  Tampering with one event in the database…   βœ“ altered llm_call (changed the logged model)
5/5  Re-verifying the hash chain…                 βœ— CHAIN BROKEN β€” tampering detected βœ…

The demo ingests a real trace, verifies the chain (passes), edits one record directly in the database behind the audit log's back, then re-verifies (fails). Auditors get a signed, verifiable JSON snapshot from GET /api/audit/verify/export.

Five ways to integrate β€” pick what fits your stack:

Integration

Language

Effort

Capture

πŸ”­ OpenTelemetry

Any

Point your OTLP exporter

Any gen_ai.*-instrumented agent β€” no AgentLens SDK

πŸ€– OpenClaw Plugin

OpenClaw

Copy & enable

Every Anthropic call β€” prompts, tokens, cost, tools β€” zero code

🐍 Python Auto-Instrumentation

Python

1 line

Every OpenAI / Anthropic / LangChain call β€” deterministic

πŸ”Œ MCP Server

Any (MCP)

Config block

Tool calls, sessions, events from Claude Desktop / Cursor

πŸ“¦ SDK

Python, TypeScript

Code

Full control β€” log events, query analytics, build integrations

πŸš€ Quick Start

One command β€” server + dashboard on SQLite, zero config:

docker run -p 3400:3400 -e AUTH_DISABLED=true -e JWT_SECRET=dev-secret ghcr.io/agentkitai/agentlens
# Open http://localhost:3400

Or without Docker:

npx @agentkitai/agentlens-server
# http://localhost:3400 with SQLite β€” zero config

AUTH_DISABLED=true is for a quick local trial (JWT_SECRET is still required by the hardened image). For anything shared, drop AUTH_DISABLED, set a real JWT_SECRET, and create an API key (below).

Full stack (Postgres + Redis, auth, TLS) β€” runs from source:

git clone https://github.com/agentkitai/agentlens && cd agentlens
cp .env.example .env
docker compose up
# production overlay (auth, restart policies):
docker compose -f docker-compose.yml -f docker-compose.prod.yml up

Create an API Key

curl -X POST http://localhost:3400/api/keys \
  -H "Content-Type: application/json" \
  -d '{"name": "my-agent"}'

Save the als_... key from the response β€” it's shown only once. Then head to the Integration Guides to instrument your agent.

πŸ“– Full setup guide β†’

πŸ—οΈ Architecture

graph TB
    subgraph Agents["Your AI Agents"]
        PY["Python App<br/>(OpenAI, Anthropic, LangChain)"]
        MCP_C["MCP Client<br/>(Claude Desktop, Cursor)"]
        TS["TypeScript App"]
        OC["OpenClaw Plugin"]
    end

    PY -->|"agentlensai.init()<br/>auto-instrumentation"| SERVER
    MCP_C -->|MCP Protocol| MCP_S["@agentkitai/agentlens-mcp"]
    MCP_S -->|HTTP| SERVER
    TS -->|"@agentkitai/agentlens-sdk"| SERVER
    OC -->|HTTP| SERVER

    subgraph Server["@agentkitai/agentlens-server"]
        direction TB
        INGEST[Ingest Engine]
        QUERY[Query Engine]
        ALERT[Alert Engine]
        LLM_A[LLM Analytics]
        HEALTH[Health Scoring]
        COST[Cost Optimizer]
        REPLAY[Session Replay]
        BENCH[Benchmark Engine]
        GUARD[Guardrails]
    end

    SERVER --> DB[(SQLite / Postgres)]
    SERVER --> DASH["Dashboard<br/>(React SPA)"]

    EXT["AgentGate / FormBridge"] -->|Webhook| SERVER

πŸ”§ Integration Guides

πŸ”­ OpenTelemetry (any GenAI agent β€” no SDK)

If your agent is already instrumented with the OpenTelemetry GenAI semantic conventions β€” via OpenLLMetry, OpenInference, or the official OTel instrumentations β€” just point its OTLP exporter at AgentLens. No AgentLens SDK required.

# Send standard OTLP/HTTP to AgentLens (JSON or protobuf, /v1/traces)
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:3400
export OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://localhost:3400/v1/traces

AgentLens maps gen_ai.* spans into its model and into the tamper-evident audit log:

OTel GenAI span (gen_ai.operation.name)

Becomes

chat / text_completion / generate_content

a paired llm_call + llm_response (model, provider, messages, usage.input_tokens/output_tokens, finish reason, latency, cost)

execute_tool

tool_call (gen_ai.tool.name, gen_ai.tool.call.id, arguments)

embeddings

embedding event with token usage

invoke_agent / create_agent

agent-invocation event

Each OTel trace maps to a session (or gen_ai.conversation.id if present), and every event is hash-chained like any other β€” so traces from any GenAI framework get the same verifiable audit trail. Set OTLP_AUTH_TOKEN to require a bearer token on the OTLP endpoints in production.

Cost with no SDK: OTel GenAI instrumentation reports tokens but rarely cost. AgentLens reconstructs costUsd from the model's per-1M-token pricing (fuzzy-matched on the model id), so OTel-only agents get the same cost analytics as SDK-instrumented ones β€” no per-call cost attribute required.

πŸ€– OpenClaw Plugin

If you're running OpenClaw, the AgentLens plugin captures every Anthropic API call automatically β€” prompts, completions, token usage, costs, latency, and tool calls.

cp -r packages/relay-plugin /usr/lib/node_modules/openclaw/extensions/agentlens-relay
openclaw config patch '{"plugins":{"entries":{"agentlens-relay":{"enabled":true}}}}'
openclaw gateway restart

Set AGENTLENS_URL if your AgentLens instance isn't on localhost:3400. See the plugin README for details.

🐍 Python Auto-Instrumentation

One line β€” every LLM call captured automatically across 9 providers (OpenAI, Anthropic, LiteLLM, AWS Bedrock, Google Vertex AI, Google Gemini, Mistral AI, Cohere, Ollama):

pip install agentlensai[all-providers]
import agentlensai

agentlensai.init(
    url="http://localhost:3400",
    api_key="als_your_key",
    agent_id="my-agent",
)
# Every LLM call is now captured automatically

Key guarantees: βœ… Deterministic Β· βœ… Fail-safe Β· βœ… Non-blocking Β· βœ… Privacy (init(redact=True))

πŸ“– Python SDK full docs β†’

πŸ”Œ MCP Integration

For Claude Desktop, Cursor, or any MCP client β€” add to your config:

{
  "mcpServers": {
    "agentlens": {
      "command": "npx",
      "args": ["@agentkitai/agentlens-mcp"],
      "env": {
        "AGENTLENS_API_URL": "http://localhost:3400",
        "AGENTLENS_API_KEY": "als_your_key_here"
      }
    }
  }
}

AgentLens ships 22 MCP tools β€” covering core observability, intelligence & analytics, and operations. Full MCP tool reference β†’

πŸ“– MCP setup guide β†’

πŸ“¦ Programmatic SDK

Python:

pip install agentlensai
from agentlensai import AgentLensClient
client = AgentLensClient("http://localhost:3400", api_key="als_your_key")
sessions = client.get_sessions()
analytics = client.get_llm_analytics()

TypeScript:

npm install @agentkitai/agentlens-sdk
import { AgentLensClient } from '@agentkitai/agentlens-sdk';
const client = new AgentLensClient({ baseUrl: 'http://localhost:3400', apiKey: 'als_your_key' });
const sessions = await client.getSessions();

πŸ“– SDK reference β†’

✨ Key Features

  • 🐍 Python Auto-Instrumentation β€” agentlensai.init() captures every LLM call across 9 providers automatically. Deterministic β€” no reliance on LLM behavior.

  • πŸ”Œ MCP-Native β€” Ships as an MCP server. Works with Claude Desktop, Cursor, and any MCP client.

  • πŸ”­ OpenTelemetry GenAI β€” Ingests gen_ai.* OTLP traces from any OTel-instrumented agent (OpenLLMetry, OpenInference, official OTel) β€” no AgentLens SDK required.

  • 🧠 LLM Call Tracking β€” Full prompt/completion visibility, token usage, cost aggregation, latency measurement, and privacy redaction.

  • πŸ“Š Real-Time Dashboard β€” Session timelines, event explorer, LLM analytics, cost tracking, and alerting.

  • πŸ”’ Tamper-Evident Audit Trail β€” Append-only event storage with SHA-256 hash chains per session.

  • πŸ’° Cost Tracking β€” Track token usage and estimated costs per session, per agent, per model. Alert on cost spikes.

  • 🚨 Alerting β€” Configurable rules for error rate, cost threshold, latency anomalies, and inactivity.

  • β€οΈβ€πŸ©Ή Health Scores β€” 5-dimension health scoring with trend tracking.

  • πŸ’‘ Cost Optimization β€” Complexity-aware model recommendation engine with projected savings.

  • πŸ“Ό Session Replay β€” Step-through any past session with full context reconstruction.

  • βš–οΈ A/B Benchmarking β€” Statistical comparison of agent variants using Welch's t-test and chi-squared analysis.

  • πŸ›‘οΈ Guardrails β€” Automated safety rules with dry-run mode for safe testing.

  • πŸ”Œ Framework Plugins β€” LangChain, CrewAI, AutoGen, Semantic Kernel β€” auto-detection, fail-safe, non-blocking.

  • πŸ”— AgentKit Ecosystem β€” Integrations with AgentGate, FormBridge, Lore, and AgentEval.

  • πŸ”’ Tenant Isolation β€” Multi-tenant support with per-tenant data scoping and API key binding.

  • 🏠 Self-Hosted β€” SQLite by default, no external dependencies. MIT licensed.

πŸ“Έ Dashboard

AgentLens ships with a real-time web dashboard for monitoring your agents.

Overview β€” At-a-Glance Metrics

Dashboard Overview

The overview page shows live metrics β€” sessions, events, errors, and active agents β€” with a 24-hour event timeline chart, recent sessions with status badges, and a recent errors feed.

Sessions β€” Track Every Agent Run

Sessions List

Every agent session with sortable columns: agent name, status, start time, duration, event count, error count, and total cost.

Session Detail β€” Timeline & Hash Chain

Session Detail

Full event timeline with tamper-evident hash chain verification. Filter by event type, view cost breakdown.

Events Explorer β€” Search & Filter Everything

Events Explorer

Searchable, filterable view of every event across all sessions.

🧠 LLM Analytics β€” Prompt & Cost Tracking

LLM Analytics

Total LLM calls, cost, latency, and token usage across all agents with model comparison.

🧠 Session Timeline β€” LLM Call Pairing

LLM Timeline

LLM calls in session timeline with model, tokens, cost, and latency.

πŸ’¬ Prompt Detail β€” Chat Bubble Viewer

LLM Call Detail

Full prompt and completion in a chat-bubble style viewer with metadata panel.

β€οΈβ€πŸ©Ή Health Overview β€” Agent Reliability

Health Overview

5-dimension health score for every agent with trend tracking.

πŸ’‘ Cost Optimization β€” Model Recommendations

Cost Optimization

Analyzes LLM call patterns and recommends cheaper model alternatives with confidence levels.

πŸ“Ό Session Replay β€” Step-Through Debugger

Session Replay

Step through any past session event by event with full context reconstruction.

βš–οΈ Benchmarks β€” A/B Testing for Agents

Benchmarks

Create and manage A/B experiments with statistical significance testing.

πŸ›‘οΈ Guardrails β€” Automated Safety Rules

Guardrails

Create and manage automated safety rules with trigger history and activity feed.

☁️ AgentLens Cloud

Don't want to self-host? AgentLens Cloud is a fully managed SaaS β€” same SDK, zero infrastructure:

import agentlensai
agentlensai.init(cloud=True, api_key="als_cloud_your_key_here", agent_id="my-agent")
  • Same SDK, one parameter change β€” switch url= to cloud=True

  • Managed Postgres β€” multi-tenant with row-level security

  • Team features β€” organizations, RBAC, audit logs

  • No server to run β€” dashboard at app.agentlens.ai

πŸ“– Cloud Setup Guide Β· Migration Guide Β· Troubleshooting

πŸ“¦ Packages

Python (PyPI)

Package

Description

PyPI

agentlensai

Python SDK + auto-instrumentation for 9 LLM providers

PyPI

TypeScript / Node.js (npm)

Package

Description

npm

@agentkitai/agentlens-server

Hono API server + dashboard serving

npm

@agentkitai/agentlens-mcp

MCP server for agent instrumentation

npm

@agentkitai/agentlens-sdk

Programmatic TypeScript client

npm

@agentkitai/agentlens-core

Shared types, schemas, hash chain utilities

npm

@agentkitai/agentlens-cli

Command-line interface

npm

@agentkitai/agentlens-dashboard

React web dashboard (bundled with server)

private

πŸ”Œ API Overview

Endpoint

Description

POST /api/events

Ingest events (batch)

GET /api/events

Query events with filters

GET /api/sessions

List sessions

GET /api/sessions/:id/timeline

Session timeline with hash chain verification

GET /api/analytics

Bucketed metrics over time

Full API Reference β†’

⌨️ CLI

npx @agentkitai/agentlens-cli health                          # Overview of all agents
npx @agentkitai/agentlens-cli health --agent my-agent          # Detailed health with dimensions
npx @agentkitai/agentlens-cli optimize                          # Cost optimization recommendations

Both commands support --format json for machine-readable output. See agentlens health --help for all options.

πŸ› οΈ Development

git clone https://github.com/agentkitai/agentlens.git
cd agentlens
pnpm install

pnpm typecheck && pnpm test && pnpm lint  # Run all checks
pnpm dev                                   # Start dev server

Requirements: Node.js β‰₯ 20.0.0 Β· pnpm β‰₯ 10.0.0

🀝 Contributing

We welcome contributions! See CONTRIBUTING.md for setup instructions, coding standards, and the PR process.

🧰 AgentKit Ecosystem

Project

Description

AgentLens

Observability & tamper-evident audit trail for AI agents

⬅️ you are here

AgentGate

Human-in-the-loop approval gateway + reactive guardrails

Lore

Cross-agent memory and lesson sharing

AgentEval

Testing & evaluation framework

FormBridge

Agent-human mixed-mode forms

πŸ“„ License

MIT Β© Amit Paz

Available Tools

22 tools
agentlens_agentsA

List, inspect, and manage AgentLens agents.

When to use: To see which agents are registered, check agent details and error rates, or unpause a paused agent.

Actions:

  • list: List all agents with error rates

  • detail: Get agent detail by ID

  • unpause: Clear paused state for an agent

Example: agentlens_agents({ action: "list" })

Inputs: action (required), agentId, clearModelOverride.

agentlens_alertsA

Manage alert rules and view alert history.

When to use: To create alerting rules for error rates, costs, or latency thresholds; manage existing rules; or review past alert triggers.

Actions:

  • list: List all alert rules

  • create: Create a new alert rule

  • update: Update an existing alert rule

  • delete: Delete an alert rule

  • history: View recent alert triggers

Example: agentlens_alerts({ action: "create", name: "High error rate", condition: "error_rate_above", threshold: 0.1, windowMinutes: 60 })

Inputs: action (required), ruleId, name, condition, +6 more.

agentlens_analyticsA

Query operational analytics: metrics, costs, agent performance, and tool usage.

When to use: To understand system performance trends, cost breakdowns, agent activity, or tool usage patterns over time.

Actions:

  • metrics: Get bucketed metrics with optional range/date filters

  • costs: Get cost breakdown

  • agents: Get per-agent metrics

  • tools: Get tool usage statistics

Example: agentlens_analytics({ action: "metrics", range: "24h" })

Inputs: action (required), range, from, to, +2 more.

agentlens_benchmarkA

Manage A/B benchmarks: create, list, check status, get results, and control lifecycle.

When to use: To set up controlled experiments comparing different agent configurations (models, prompts, parameters), track which variant performs better, and get statistical results.

Workflow:

  1. create β€” Define a benchmark with 2+ variants and metrics

  2. Tag sessions with variant tags during data collection

  3. start β€” Transition benchmark to running

  4. status β€” Check progress (session counts per variant)

  5. results β€” Get statistical comparison with p-values

  6. complete β€” Finalize the benchmark

Actions:

  • create: Set up a new benchmark (name, variants[], metrics[])

  • list: List benchmarks, optionally filter by status

  • status: Get benchmark detail with per-variant session counts

  • results: Get formatted comparison table with statistical analysis

  • start: Transition benchmark to running state

  • complete: Transition benchmark to completed state

Example: agentlens_benchmark({ action: "create", name: "GPT-4o vs Claude", variants: [{name: "gpt4o", tag: "v-gpt4o"}, {name: "claude", tag: "v-claude"}], metrics: ["cost", "latency", "success_rate"] })

Inputs: action (required), name, description, variants, +5 more.

agentlens_contextA

Retrieve cross-session context for a topic β€” related session summaries and lessons ranked by relevance.

When to use: At the start of a session to load relevant history, when building a system prompt with past experience, when starting work on a topic the agent has handled before, or to audit what happened with a specific topic.

What it returns: Related sessions (with summaries, key events, and relevance scores) and related lessons, all ranked by relevance to the topic. Includes an overall summary.

Example: agentlens_context({ topic: "database migrations", limit: 5 }) β†’ returns past sessions about DB migrations with key events, plus any lessons learned about migrations.

Inputs: topic (required), userId, agentId, from, +2 more.

agentlens_cost_budgetsA

Manage cost budgets and anomaly detection.

When to use: To create/manage spending limits, check budget utilization, or configure cost anomaly detection.

Actions:

  • list: List all cost budgets

  • create: Create a new budget

  • update: Update an existing budget

  • delete: Delete a budget

  • status: Check spend vs limit for a budget

  • anomaly_config: Get anomaly detection configuration

  • anomaly_update: Update anomaly detection settings

Example: agentlens_cost_budgets({ action: "create", scope: "global", period: "daily", limitUsd: 10, onBreach: "alert" })

Inputs: action (required), budgetId, scope, agentId, +7 more.

agentlens_delegateA

Delegate a task to another agent in the AgentLens network.

When to use: When you've discovered an agent capable of handling a specific task (via agentlens_discover) and want to delegate work to it.

Example: agentlens_delegate({ action: "delegate", targetAgentId: "anon-abc123", taskType: "translation", input: { text: "Hello", targetLang: "es" } })

Inputs: action (required), targetAgentId (required), taskType (required), input (required), +3 more.

agentlens_discoverA

Discover available agent capabilities in the network.

When to use: Before delegating a task, to find agents that can handle a specific task type. Returns ranked results with trust scores, estimated cost, and latency.

Example: agentlens_discover({ action: "discover", taskType: "code-review", minTrustScore: 70, limit: 5 })

Inputs: action (required), taskType (required), minTrustScore, maxCost, +2 more.

agentlens_guardrailsA

Check guardrail status for the current agent. Returns active guardrail rules, their current state, and recent trigger history.

When to use: To check what guardrails are protecting this agent, whether any have been triggered recently, and what conditions/actions are configured.

What it returns: A list of configured guardrail rules with their status (enabled/disabled, trigger count, last trigger time) and recent trigger history.

Example: agentlens_guardrails({}) β†’ returns all guardrail rules and their status.

Inputs: agentId.

agentlens_healthA

Check the health score of the current agent. Returns overall score (0-100), trend, and dimension breakdown.

When to use: To assess the current health and performance of the agent, to check if error rates or latency are degrading, or to get a quick overview of agent reliability metrics.

What it returns: An overall health score (0-100), a trend indicator (improving/stable/degrading), and a breakdown by five dimensions: error rate, cost efficiency, tool success, latency, and completion rate.

Example: agentlens_health({ window: 7 }) β†’ returns health score with dimension breakdown for the last 7 days.

Inputs: window.

agentlens_log_eventB

Log an event to an active AgentLens session.

Inputs: sessionId (required), eventType (required), payload (required), severity, +1 more.

agentlens_log_llm_callB

Log a complete LLM call (request + response) to an active AgentLens session. Emits paired llm_call and llm_response events.

Inputs: sessionId (required), provider (required), model (required), messages (required), +9 more.

agentlens_optimizeA

Get cost optimization recommendations. Analyzes LLM call patterns and suggests cheaper model alternatives.

When to use: To identify cost-saving opportunities by switching expensive models to cheaper alternatives for tasks that don't require the most capable model. Analyzes call complexity (simple/moderate/complex) and success rates.

What it returns: A list of model switch recommendations with estimated monthly savings, confidence levels, and success rate comparisons. Sorted by potential savings.

Example: agentlens_optimize({ period: 7 }) β†’ returns recommendations like "Switch gpt-4o β†’ gpt-4o-mini for SIMPLE tasks, saving $89/month".

Inputs: period, limit.

agentlens_promptsC

Manage prompt templates and versions.

Actions:

  • list: List prompt templates (optional category, search filters)

  • get: Get a template with all versions by ID

  • create: Create a new prompt template with initial content

  • update: Create a new version of an existing template

  • analytics: Get per-version metrics for a template

  • fingerprints: List auto-discovered prompt fingerprints

Example: agentlens_prompts({ action: "list", category: "system" })

Inputs: action (required), templateId, name, content, +8 more.

agentlens_query_eventsC

Query events from an AgentLens session.

Inputs: sessionId (required), limit, eventType.

agentlens_reflectA

Analyze behavioral patterns from agent sessions β€” error patterns, tool sequences, cost analysis, and performance trends.

When to use: To identify recurring errors and their root causes (error_patterns), to understand cost drivers and optimize model usage (cost_analysis), to discover common tool usage chains and their success rates (tool_sequences), or to track performance over time (performance_trends).

What it returns: A list of structured insights with type, summary, data, and confidence score, plus metadata about how many sessions/events were analyzed. Each analysis type returns different data shapes.

Example: agentlens_reflect({ analysis: "error_patterns", agentId: "my-agent", from: "2026-01-01" }) β†’ returns recurring error patterns with counts, first/last seen, and affected sessions.

Inputs: analysis (required), agentId, from, to, +2 more.

agentlens_replayA

Replay a past session as a structured, human-readable timeline.

When to use: To review what happened in a previous session β€” understand failures, decision patterns, timing, or cost accumulation. Great for debugging or post-mortem analysis.

What it returns: A session header (agent, status, duration, cost, event counts) followed by numbered, timestamped steps with event type icons and context annotations.

Parameters:

  • sessionId (required): The session to replay

  • fromStep/toStep: Replay a specific step range

  • eventTypes: Comma-separated filter (e.g., "llm_call,tool_call")

  • summaryOnly: Set true to get just the summary header (fast for large sessions)

Example: agentlens_replay({ sessionId: "ses_abc123", summaryOnly: true }) β†’ returns session summary without steps.

Inputs: sessionId (required), fromStep, toStep, eventTypes, +1 more.

agentlens_session_endB

End an active AgentLens monitoring session.

Inputs: sessionId (required), reason (required), summary.

agentlens_sessionsA

Browse and inspect AgentLens sessions.

When to use: To find past sessions, inspect session details, or view a timeline of events within a session. Useful for debugging, auditing, or reviewing agent activity.

Actions:

  • list: List sessions with optional filters (agentId, status, date range, tags)

  • detail: Get full session detail with aggregates

  • timeline: Get timestamped event list for a session

Example: agentlens_sessions({ action: "list", agentId: "my-agent", status: "completed", limit: 10 })

Inputs: action (required), sessionId, agentId, status, +5 more.

agentlens_session_startA

Start a new AgentLens monitoring session. Returns a sessionId to use for subsequent events.

Inputs: agentId (required), agentName, tags.

agentlens_statsA

Get storage statistics and system overview metrics.

When to use: To check database/storage utilization or get a high-level system overview.

Actions:

  • storage: Get storage stats (database size, event counts, etc.)

  • overview: Get overview metrics (active sessions, agents, recent activity)

Example: agentlens_stats({ action: "storage" })

Inputs: action (required).

agentlens_trustA

Get trust scores for agents.

When to use: To check the trust/reliability score of an agent before delegating tasks or to monitor agent reputation.

Actions:

  • score: Get trust score for a specific agent

Example: agentlens_trust({ action: "score", agentId: "my-agent" })

Inputs: action (required), agentId.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 22 tools

    Disambiguation5/5

    Each tool targets a distinct domain (agents, alerts, analytics, benchmarks, etc.) with clear boundaries. Even closely related tools like agentlens_sessions and agentlens_session_start/end are differentiated by lifecycle management vs. browsing. No significant overlap.

    Naming Consistency5/5

    All tools follow a consistent 'agentlens_' prefix with snake_case naming. The pattern is uniform across all 22 tools, with verb_noun style for actions (e.g., agentlens_session_start, agentlens_log_event) and noun style for collections (e.g., agentlens_agents, agentlens_alerts).

    Tool Count4/5

    22 tools is slightly above the typical 3-15 range but still appropriate for a comprehensive monitoring platform. Each tool serves a clear purpose, and the count reflects the breadth of functionality (monitoring, alerts, budgets, benchmarks, delegation, etc.) without being excessive.

    Completeness5/5

    The tool set provides full coverage for agent monitoring: session lifecycle, metrics, alerts, cost budgets, benchmarks, delegation, trust, guardrails, logging, prompt management, optimization, and reflection. It covers all common operational needs with no obvious gaps for the stated domain.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      Universal MCP server that emits Context Passport records for AI agent decisions and actions. Drop into any MCP-compatible client to give your agent a commit/verify/replay/export toolset for verifiable, tamper-evident records.
      5
      82 npm
      Apache 2.0
    • A
      license
      Not graded
      quality
      C
      maintenance
      Tamper-evident audit logging for AI agents. Append-only, hash-chained, optionally Ed25519-signed log. The MCP server lets an agent keep and verify a record of what it actually did.
      8
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      MCP server that provides cryptographic audit trails for AI agent actions, making every action tamper-evident via HMAC-SHA256 signed hash chains.
      10
      Apache 2.0
    • A
      license
      Not graded
      quality
      C
      maintenance
      Local-first MCP server that lets AI agents query their own LLM call history as a branchable DAG and offload conversation context into immutable, AES-256-GCM-encrypted capsules β€” restorable in full or per segment, crypto-shreddable, with RAID-style replication. 12 tools, no API keys, no cloud.
      122 npm
      3
      MIT