AgentLens
Captures LLM calls to Google Gemini models automatically via Python auto-instrumentation.
Captures LangChain LLM calls automatically via Python auto-instrumentation.
Captures LLM calls to locally hosted Ollama models automatically via Python auto-instrumentation.
Captures every OpenAI API call automatically, including prompts, tokens, cost, and tool calls, via Python auto-instrumentation or OpenTelemetry.
Ingests traces from any GenAI agent instrumented with OpenTelemetry GenAI semantic conventions, mapping spans into the tamper-evident audit log without requiring the AgentLens SDK.
π 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.sh1/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 |
π€ OpenClaw Plugin | Copy & enable | Every Anthropic call β prompts, tokens, cost, tools β zero code | |
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:3400Or without Docker:
npx @agentkitai/agentlens-server
# http://localhost:3400 with SQLite β zero config
AUTH_DISABLED=trueis for a quick local trial (JWT_SECRETis still required by the hardened image). For anything shared, dropAUTH_DISABLED, set a realJWT_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 upCreate 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/tracesAgentLens maps gen_ai.* spans into its model and into the tamper-evident audit log:
OTel GenAI span ( | Becomes |
| a paired |
|
|
| embedding event with token usage |
| 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
costUsdfrom 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 restartSet 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 automaticallyKey guarantees: β
Deterministic Β· β
Fail-safe Β· β
Non-blocking Β· β
Privacy (init(redact=True))
π 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 agentlensaifrom 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-sdkimport { 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

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

Every agent session with sortable columns: agent name, status, start time, duration, event count, error count, and total cost.
Session Detail β Timeline & Hash Chain

Full event timeline with tamper-evident hash chain verification. Filter by event type, view cost breakdown.
Events Explorer β Search & Filter Everything

Searchable, filterable view of every event across all sessions.
π§ LLM Analytics β Prompt & Cost Tracking

Total LLM calls, cost, latency, and token usage across all agents with model comparison.
π§ Session Timeline β LLM Call Pairing

LLM calls in session timeline with model, tokens, cost, and latency.
π¬ Prompt Detail β Chat Bubble Viewer

Full prompt and completion in a chat-bubble style viewer with metadata panel.
β€οΈβπ©Ή Health Overview β Agent Reliability

5-dimension health score for every agent with trend tracking.
π‘ Cost Optimization β Model Recommendations

Analyzes LLM call patterns and recommends cheaper model alternatives with confidence levels.
πΌ Session Replay β Step-Through Debugger

Step through any past session event by event with full context reconstruction.
βοΈ Benchmarks β A/B Testing for Agents

Create and manage A/B experiments with statistical significance testing.
π‘οΈ Guardrails β Automated Safety Rules

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=tocloud=TrueManaged 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 |
Python SDK + auto-instrumentation for 9 LLM providers |
TypeScript / Node.js (npm)
Package | Description | npm |
Hono API server + dashboard serving | ||
MCP server for agent instrumentation | ||
Programmatic TypeScript client | ||
Shared types, schemas, hash chain utilities | ||
Command-line interface | ||
React web dashboard (bundled with server) | private |
π API Overview
Endpoint | Description |
| Ingest events (batch) |
| Query events with filters |
| List sessions |
| Session timeline with hash chain verification |
| Bucketed metrics over time |
β¨οΈ 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 recommendationsBoth 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 serverRequirements: 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 |
Human-in-the-loop approval gateway + reactive guardrails | ||
Cross-agent memory and lesson sharing | ||
Testing & evaluation framework | ||
Agent-human mixed-mode forms |
π License
Available Tools
22 toolsagentlens_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 ratesdetail: Get agent detail by IDunpause: 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 rulescreate: Create a new alert ruleupdate: Update an existing alert ruledelete: Delete an alert rulehistory: 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 filterscosts: Get cost breakdownagents: Get per-agent metricstools: 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:
createβ Define a benchmark with 2+ variants and metricsTag sessions with variant tags during data collection
startβ Transition benchmark to runningstatusβ Check progress (session counts per variant)resultsβ Get statistical comparison with p-valuescompleteβ Finalize the benchmark
Actions:
create: Set up a new benchmark (name, variants[], metrics[])list: List benchmarks, optionally filter by statusstatus: Get benchmark detail with per-variant session countsresults: Get formatted comparison table with statistical analysisstart: Transition benchmark to running statecomplete: 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 budgetscreate: Create a new budgetupdate: Update an existing budgetdelete: Delete a budgetstatus: Check spend vs limit for a budgetanomaly_config: Get anomaly detection configurationanomaly_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 IDcreate: Create a new prompt template with initial contentupdate: Create a new version of an existing templateanalytics: Get per-version metrics for a templatefingerprints: 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 aggregatestimeline: 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
Scored across 22 tools
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.
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).
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.
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
Related MCP Connectors
Hash-chained HMAC-signed audit log MCP for A2A (agent-to-agent) calls. Every tool-call, agent-ha...
Signed, publicly logged records of what your AI agent did, with proofs anyone can check offline.
Bitcoin-anchored, tamper-evident audit log for AI agents β record, disclose and verify actions.
Tamper-evident proof creation and verification for AI agents via MCP, A2A, and REST.
Related MCP Servers
- AlicenseAqualityCmaintenanceUniversal 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.582 npmApache 2.0
- AlicenseNot gradedqualityCmaintenanceTamper-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.8MIT
- AlicenseAqualityBmaintenanceMCP server that provides cryptographic audit trails for AI agent actions, making every action tamper-evident via HMAC-SHA256 signed hash chains.10Apache 2.0
- AlicenseNot gradedqualityCmaintenanceLocal-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 npm3MIT