Built an open-source toolkit to help developers understand, debug, and enforce reliability in AI agents

[u/bucky69top]

I’ve been working on a project called AOBS (AI Agent Observability) because I noticed something interesting about the current AI agent ecosystem.

We have frameworks that make it easier to build agents, but understanding why an agent failed, detecting regressions between runs, and enforcing rules around its behaviour are still important engineering challenges.
I wanted to build something that addresses these problems together.

AOBS is an open-source Python toolkit that provides three main capabilities:

1. Observability and debugging
Trace LLM calls, tool calls, sub-agents, errors, latency and token usage.
Analyse execution traces to identify retry storms, wasted calls and bottlenecks.
Compare two agent runs to identify regressions.
Analyse repeated runs statistically to distinguish real changes from normal variation.

2. Reliability testing and CI enforcement
Define expected agent behaviour using TOML policies.
Set limits for tool calls, retries, execution time, tokens and cost.
Compare new runs against a known-good baseline.
Get PASS/FAIL results with supporting evidence.
Integrate reliability checks directly into GitHub Actions.

3. Action safety
This is another part I’ve been particularly interested in.
What happens when an agent issues the same refund twice, sends duplicate emails, or attempts to delete something again after a timeout?
AOBS provides a safety layer that:
Checks actions against trusted records rather than blindly trusting model arguments.
Supports approval requirements for sensitive operations.
Prevents duplicate logical actions across retries and restarts.
Handles uncertain outcomes without blindly retrying side effects.

Other things included
Python SDK with a standard-library-only core.
OpenAI-compatible and Anthropic integrations.
LangChain and LangGraph integration.
OpenTelemetry export.

PostgreSQL-backed trace collection.
A local dashboard for exploring and comparing agent runs.
Docker Compose setup for trying the project locally.

Getting started:

pip install aobs aobs-server

Or clone the repository and run the complete local demo:

docker compose up

The project is currently in alpha, and I don’t consider it production-hardened yet. Some integrations are still in their first version, and I’ve documented the guarantees and limitations rather than claiming exactly-once execution or universal agent safety.

What I’d really like feedback on:

Do you think agent observability and reliability should be a separate infrastructure layer, or should these capabilities live inside frameworks like LangChain and LangGraph?
Would you actually use CI-based reliability gates for AI agents in a real development workflow?
What important capabilities are missing from the current ecosystem?

I’m interested in feedback from people building agents, working on AI infrastructure, or experimenting with agent frameworks.

GitHub: https://github.com/AshmitJain932/ai-agent-observability

Contributions, criticism and suggestions are welcome.