AgenticOS launched as an open-source, self-hosted platform that aims to be a single operating system for enterprise AI agents. Built by VStorm and released under Apache-2.0, it runs on Postgres, Redis, and Docker, and its core claim is straightforward: one place to build, run, and govern every agent your company deploys, with one audit trail covering all of them.

The problem it is trying to solve

Most companies running AI agents today have them scattered across multiple platforms and frameworks. Some live in LangChain scripts, others in custom Python deployments, others in SaaS tools with no shared governance. The result is a set of questions nobody can answer reliably: what agents are running, what each one cost to execute, what data it touched, and who approved its deployment. AgenticOS addresses this by moving agents out of code and into a governed environment where non-engineers can build and edit them while finance teams and compliance officers can audit them.

Seven operating system functions, mapped to agent governance

The project draws an explicit analogy between traditional operating system functions and what it provides for agents. Each mechanism is implemented in code, not just described as a feature.

Process isolation becomes agent isolation, where each run is tracked with its cost and tenants are separated at the database schema level rather than in application code. Resource limits translate to per-agent monthly budgets checked before each model call, so a runaway agent stops mid-execution rather than producing an unexpected invoice. Access control is handled through a permission catalog in code, with roles composed from it and per-resource grants that can widen but never narrow. Hardware drivers map to a single interface supporting 27 model providers and any MCP server by URL, letting you swap a model profile and have every dependent agent update without republishing. The filesystem becomes collections, skills, and context stored in Postgres with embeddings keyed per organization. A unified shell serves web chat, the HTTP API, Slack, Telegram, Mattermost, widgets, and scheduled automations, all enforcing the same budgets and approval gates. The audit log records who ran what, when, what it cost, and who approved it, even for failed runs.

The harness: capabilities as configuration switches

An agent in AgenticOS is a specification, not a codebase. It defines instructions, a model, which capabilities it can access, the knowledge bound to it, a budget, and where it answers. Capabilities are toggled per agent in a visual builder. Each one carries its own settings, permission scope, and approval gate.

The available capabilities include retrieval over document collections, web search and browser automation, Python execution in a sandboxed environment with file and shell access, chart and image generation, delegation to subagents, and guardrails that redact or block output. Any MCP server can be attached by URL, and the platform ships with a catalogue of 5,802 servers, 99 of which have been manually verified with OAuth flows wired. Nothing is shipped until a publish action, and every publish creates a versioned snapshot that can be rolled back with a click.

Skills, context files, and MCP at registry scale

Three features distinguish the platform from simpler agent builders. Skills are procedures written in plain language that the agent loads on demand when it determines they are relevant. Edit a skill and the next answer reflects the change, with no deployment cycle required. Context files like AGENTS.md or CLAUDE.md function as standing instructions attached to every agent that needs them, centralizing product names, policies, or house tone in one place instead of forty separate prompts. The MCP integration treats the Model Context Protocol as a first-class registry, letting you search the 5,802-server catalogue by name or connect any server by URL without writing a connector.

Document handling and knowledge management

The platform includes three PDF readers optimized for different content types: PyMuPDF for standard documents, LlamaParse for tables, and a self-hosted LiteParse option for OCR on scanned files. You can set the reader per collection or per file, configure chunking strategy, and specify OCR language. A scanned price list and a legal contract do not need the same processing pipeline, and AgenticOS lets you configure that at the collection level without code changes.

Governance, budgets, and human approval

The governance layer is where AgenticOS differentiates itself most clearly from agent frameworks that treat deployment as an afterthought. Budgets are checked before each model request, not tallied afterward. Any tool that produces a side effect, sending an email, filing a refund, creating a record, requires explicit human approval with the intended action written out. Approval decisions are recorded once and applied consistently. Secrets are encrypted per organization, so a key copied from one tenant cannot be decrypted for another, and no API response ever returns a plaintext secret.

The dashboard provides 35 cards covering runs, spend, service health, answer quality, sync freshness, and sandbox capacity. Each card is gated on what the reader is allowed to see, so a finance lead and an engineer can maintain different views on the same deployment without separate installations.

Deployment and desktop experience

The quick start is a single curl command that downloads a Docker Compose file, pulls the published images, asks four questions, and returns a working console. It supports macOS with Docker Desktop or OrbStack, Linux with the standard Docker installation, and Windows through WSL2. No .env file is required; every compose variable has a default. The images are published for both amd64 and arm64 by every release.

The desktop app is a thin shell around the same web console, with two additions a browser tab cannot provide: a pet that lives on the desktop, draggable and interactive, and a global keyboard shortcut that captures a screenshot of any region and opens a new chat with it attached. The desktop app is optional, not a separate product, and shares the same sign-in and permissions as the web interface.

How it compares to alternatives

AgenticOS positions itself against Cloudflare OS, Glean, and library-based approaches like LangGraph and Pydantic AI. Against Cloudflare, it claims advantages in self-hosting, air-gapped operation, and agent editing by non-engineers. Against Glean, it offers open-source licensing and local model support. Against library-based tools, it argues that the governance, budget enforcement, and multi-tenant isolation it provides are things you would have to wire yourself, and that the right shape for forty small company agents is not a pull request and a release cycle but a governed platform where the person who knows what the agent should say can edit it directly.

The project acknowledges gaps in its feature set, including ACL-aware connectors to SaaS systems, an evaluation harness, and SAML or SCIM integration, and publishes these as roadmap items. The comparison table includes rows where the honest answer is "not yet," which is a rare level of transparency for a project making this kind of claim.

The underlying philosophy

AgenticOS is built on the premise that most agent frameworks give you a library and ask you to write Python, deploy it, and manage every behavioral change through code review and release cycles. That works for product features built by engineering teams. It does not work for the dozens of small agents a company actually wants, where the person with domain knowledge does not have commit access. By treating agents as versioned specifications governed by budgets and approvals rather than as code deployments, AgenticOS tries to make agent management accessible to the people who understand what the agent should do, not just the people who know how to deploy it.

The project is live on GitHub under Apache-2.0, with Docker images published for every release and a quick start that gets a working instance running in minutes. Whether it gains the community traction to match its ambitions depends on adoption, but the technical foundation addresses real gaps in how companies currently manage AI agents at scale.