AgentOS - the operating sytem for AI agents

Agent-OS — the operating system for AI agents, that makes them easier to understand, control, and improve.

Comment

Inspiration

I was inspired by the impact operating systems had on personal computing. Before systems like Windows made computers more approachable, people had to understand a lot of technical complexity just to get useful work done. AI agents feel similar today. They can be powerful, but users often cannot clearly see what the agent is doing, why it made a decision, where it failed, or how much effort it spent on a task. I wanted to build an operating system for agents: a layer that makes agents more visible, understandable, controllable, and eventually more effective for everyday users.

What it does

AgentOS is an infrastructure layer for building, running, observing, and optimizing AI agents.

It provides:

  • A Python SDK for emitting structured agent events.
  • A local server and SQLite event store for agent runs, traces, decisions, errors, tools, and token usage.
  • A React dashboard with Live, History, and Paused modes.
  • Human readable execution timelines and failure insights.
  • Agent specific summaries called Skill Seeds, which capture lessons from past runs for future improvement.

How I built it

I built AgentOS around a structured event model.

Agent → AgentOS SDK → Local Server → SQLite Event Store → Dashboard → Insights / Skill Seeds

The SDK allows any instrumented agent to report key actions such as planning, model calls, tool usage, decisions, failures, retries, and completion. The backend stores these events, while the React dashboard turns them into practical insights for users.

I also built a controlled simulated coding agent to demonstrate how a real agent would plan, use tools, encounter an error, recover, and complete a task.

Challenges I ran into

  • The main challenge was balancing technical detail with usability. Raw logs are useful for developers, but they can overwhelm users who only want to understand whether their agent succeeded and what to do next.
  • Ensuring that the AgentOS monitoring for the events does not impact the performance of the task at hand being executed by the Agent. It achieves this by keeping network latency and a temporarily unavailable AgentOS server off the agent's execution path. The queue is bounded (10,000 events by default), so a busy agent will drop excess observability events rather than block its own work.
  • Another challenge was making AgentOS flexible enough to support different agents and environments. I addressed this by using a dynamic SDK base URL rather than tying the SDK to one fixed server.

Accomplishments that I am proud of

  • Turning low-level agent events into a dashboard that is easier for people to understand.
  • Building Live, History, and Paused modes so users can monitor or investigate agents at their own pace.
  • Creating Skill Seeds that keep lessons isolated to the relevant agent.
  • Simulating realistic agent behavior, including failures and recovery, without requiring an external AI API.
  • Should not capture any secrets or API keys used. Recursively masks sensitive fields and common API key, bearer token, private key, GitHub token, AWS key, and secret-bearing URL patterns.
  • Establishing the foundation for AgentOS as an operating system for AI agents.

What I learned

I learned that observability is not just about collecting logs. For agents, the real value is helping users answer questions such as:

  • Did the agent complete the task?
  • Why did it make a decision?
  • Why did token usage spike?
  • Where did it fail?
  • How did it recover?
  • What should be improved next time?

I also learned that agent memory must be scoped carefully. Different agents need different lessons, constraints, and patterns of improvement. Learned about the importance of performance and secure capturing of events. So the agents execution continues seamlessly without compromising on its security.

What's next for Agent-OS

My future scope with this project is

  • Include multiple assistants, which is just like different drivers for the operating system, some of them are multi-agent orchestrator assistant, prompt enhancer assistant, remote agent execution assistant, token optimiser assistant, etc.
  • I also plan to add richer observability assistants, more agent integrations, actionable performance recommendations, and ways for users to compare runs over time. The long-term goal is to make agents feel less like black boxes and more like systems that users can understand, trust, and improve.

Note: Implemented the initial draft of future scope changes in the https://github.com/abhay-bharat/AgentOS/tree/future-scope branch

Share this project:

Updates