AgenticOS

What is AgenticOS about?

AgenticOS provides an open‑source, self‑hosted layer that lets companies create, share, and control AI teammates. Agents can work with files, code, web pages, and company tools while staying under governance policies such as budgets, approvals, and audit trails.

How to use AgenticOS?

1. Deploy – Run the provided Docker‑Compose quick‑start script (curl -fsSL https://raw.githubusercontent.com/vstorm-co/agenticos/main/scripts/quickstart.sh | bash). The installer asks for a model provider, API key, and admin credentials, then starts the stack (FastAPI, PostgreSQL, Redis, Next.js).
2. Create agents – Use the web console to write plain‑language instructions, select a language model, and toggle capabilities (e.g., web browser, file sandbox, skills, RAG).
3. Publish – Publish the agent version and expose it via web chat, Slack, Mattermost, Telegram, a widget, or the HTTP/WebSocket API.
4. Govern – Define roles, groups, budgets, and approval policies; every run is recorded for audit.

Key Features

• Unified chat for humans and agents – Live rooms where teammates and AI agents converse together.
• Tool integration – Real browser, file sandbox, code execution, charting, image generation, and 4,700+ MCP connectors (Notion, GitHub, Jira, etc.).
• RAG & Knowledge management – Upload or sync documents, create searchable knowledge bases, and use citation‑aware answers.
• Governance – Per‑agent budgets, approval workflows, role‑based access, and immutable audit logs.
• Extensible capabilities – 29 built‑in tools plus custom Python capabilities.
• Model flexibility – Supports 28 providers, including hosted APIs (OpenAI, Anthropic, Google) and self‑hosted models via Ollama, vLLM, LiteLLM.
• Multi‑channel output – Answers can be delivered via web chat, widgets, hosted pages, API, WebSocket, Slack, Mattermost, Telegram.
• Interactive apps – Agents can publish dashboards or calculators as stable, versioned links.

Use Cases

• Document assistants – Query company handbooks, policies, or contracts with citation‑backed answers.
• Coding helpers – Agents hand off code generation to Claude Code or Codex, run tests in an isolated sandbox, and report results.
• Research & analysis – Gather market data, produce CSV analyses, generate charts, and publish interactive reports.
• Operational automation – Trigger agents on GitHub issues, email events, or scheduled routines to perform routine checks or data syncs.
• Customer support – Provide agents that can browse internal knowledge bases and answer tickets in Slack or web chat.

Frequently Asked Questions

• Is AgenticOS free for commercial use? Yes. It is licensed under Apache‑2.0; you only pay for infrastructure and any external model or service usage.
• Can it run with only local models? Absolutely. Configure Ollama, LiteLLM, vLLM, or LM Studio as the model provider and use local embedding models for RAG.
• What authentication methods are supported? Email/password via magic links, Google, generic OIDC (Entra ID, Okta, Keycloak, etc.), LDAP, and Kerberos. MFA is delegated to the identity provider.
• How are budgets and approvals enforced? Before each model request the system checks the configured monthly budget; sensitive tool calls pause until a designated user approves the action.
• What hardware is needed? A single host with at least 4 vCPU and 8 GB RAM; scaling can be achieved by adding more API workers or Prefect workers.
• How does the audit trail work? Every run logs the agent version, prompt, tool calls, token usage, cost, and decisions. Logs are hash‑chained per organization and can be exported for compliance.
• Can I extend functionality? Yes. Engineers can add new typed Python capabilities, connectors, or MCP catalog entries that become selectable in the console.

AgenticOS gives every team AI teammates: agents that work with files, run code, browse the web and use your company's tools and knowledge. Your colleagues and your agents work in the same live chat, and any agent can hand code to Claude Code or Codex, on the ChatGPT or Claude subscription you already pay for. It is open source (Apache-2.0) and self-hosted, a layer you run on your own infrastructure. Build and publish agents in the browser, share them with colleagues, and manage their access, cost and results in one place.

New here? Click through the 17-slide introduction: the problem, the idea, the product on real screens, its controls and limits, and how to start. For every screen in detail, open the 47-slide product tour. Arrow keys step through either deck; O lists every slide.

⚡ Highlights

Your team and your agents, in one live room

A project gives everyone the same files, instructions and a computer for the agents. Invite colleagues and work the way a team works: see who is here, watch a teammate's agent answer as it is written, and bring in any agent, tool or document with an @.

Reply to anyone, and the agent knows who said what

Reply to a person or an agent's answer, and the agent applies the change and says whose it was. Every message carries a name, so a decision has an owner.

Claude Code and Codex, on your team

Any agent can hand software work to Claude Code or Codex. They build in the agent's own computer, on your ChatGPT or Claude subscription, and report what they changed, what they checked and what they need from you.

Ask how it works, get a drawing you can use

An agent draws while it writes: a diagram from your documents, a calculator with sliders, a chart or a 3D scene, live under its message. One click saves it as an app your team opens by link.

Write to an agent and leave

Ask for research that takes a while and close the tab. The agent keeps working, the answer lands in the conversation, and the bell tells you it is done.

Your day, on one screen

Open the console to what your agents did, the calls waiting on you and the conversations to pick up again - with a tour of what they can do that is easy to miss.

Agents that work as a team

A lead agent hands parts of a task to colleagues and writes up what they found - you see who it asked, and what each said.

A real browser, right in the chat

Watch it click through sites, take over when a sign-in needs you, point at a spot to comment.

Build, equip and test in one window

Switch tools on from illustrated cards, then give the draft a real job in the test chat beside them - here it charts a quarter's revenue against costs and reads the margin, before anyone else sees the agent.

Apps, not just answers

An agent publishes a dashboard or a report as a page with a stable link and versions.

4,700+ MCP servers

Connect Notion, GitHub, Jira or your own server, and choose which tools each agent may call.

Work in AgenticOS from Claude Code, Codex or Cursor

AgenticOS is an MCP server. Add it with one command and sign in through the browser: your coding assistant can list and run agents, read runs and what they cost, and search and fill knowledge bases, within what you allowed.

📸 See it in action

💡 What is AgenticOS?

AgenticOS is an open-source (Apache-2.0), self-hosted layer for building, sharing and governing AI agents across a company. Teams configure an agent in the browser by writing its instructions, choosing a model and switching on tools. They connect it to company documents and apps, and publish it to web chat, Slack, Mattermost, Telegram, a website widget or an API. Administrators control who can use each agent, what it may spend and which actions need a person's approval. Every run is recorded.

Most agent frameworks give you a library, so every change to an agent's behaviour is a pull request, a review and a release. That is the wrong shape for the small agents a company actually wants, because the person who knows what the agent should say is not the person with commit access. Code defines, configuration composes: engineers extend what there is to assemble, and configuration can only ever reach what code registered.

It runs on your own infrastructure with Docker Compose and works with 28 model providers, including your ChatGPT subscription and local models through Ollama and vLLM. Agents run on Pydantic AI and pydantic-ai-harness; the layer around them uses FastAPI, PostgreSQL with pgvector and Next.js. It is maintained by Vstorm.

Who it is for:

• Companies that want an internal AI agent layer they own, instead of per-seat assistants in a vendor's cloud.
• Teams with repeated work over documents and tools, such as reports, support answers, contract checks and data analysis.
• IT and security teams that need data sovereignty, company sign-in, budgets, approvals and an audit trail for AI agents.
• Engineers who want typed Python extension points and a console their non-technical colleagues can use.

How AgenticOS fits into a company: departments such as finance, operations or the board use shared agents in web chat, Slack or a private workspace. Your systems call agents through the API, and events or schedules start them automatically. Every request passes the same controls: roles, budgets, approvals, guardrails and a recorded run. Your data, vectors, code sandboxes, the credential vault and optional local models stay on your infrastructure. Hosted models, SaaS tools and document sources outside are used only when you configure them.

✨ What you can do

For your team	What AgenticOS provides
Work with files and code	Analyze CSVs, produce charts and documents, work on repositories
Build reusable agents	Choose models and tools, publish versions, share agents with colleagues
Connect company knowledge	Reuse skills, context and searchable documents across agents
Share the results	Publish interactive pages with stable links and version history
Run and monitor	Customize dashboards, inspect runs, schedule tasks and set budgets
Organize company access	Combine roles, department groups and company sign-in

🚀 Quick start

Start with Docker Compose and access to a model provider. On macOS or Linux, run:

curl -fsSL https://raw.githubusercontent.com/vstorm-co/agenticos/main/scripts/quickstart.sh | bash

On Windows, run the same command inside WSL2 with Docker Desktop's WSL2 integration switched on. The installer asks for a model provider and key, your login and an organization name, pulls the published images and starts a deployment with a working agent in it. A host with 4 vCPU and 8 GB of RAM runs it. Then open http://localhost:3000 and sign in with the login you chose during installation.

Your first agent: follow the document-assistant walkthrough to upload a handbook, ask questions and check answers against cited sources. Then pick a next task from 29 tutorials, each with a sample input and a check you can run.

Read the installer before running it. To check prerequisites without installing:

curl -fsSL https://raw.githubusercontent.com/vstorm-co/agenticos/main/scripts/quickstart.sh | bash -s -- --check

For manual Docker Compose setup, pinned versions and troubleshooting, follow the installation guide. For development from source, see Contributing.

🔌 Connect the apps your team already uses

AgenticOS connects agents to the models, chat tools, business apps and document stores a company already uses, so an agent can read a Notion brief, search SharePoint documents or answer in Slack under the same access rules and budget.

Connect	How	Read
Chat tools	Publish an agent to Slack, Mattermost or Telegram, a website widget, a hosted page, the API or a WebSocket	Channels
Business tools	4,700+ MCP servers in the gallery (Notion, GitHub, Jira, HubSpot, Stripe…) and your own servers; choose which tools each agent may call	MCP
Documents	Sync Google Drive, S3/MinIO, Git repositories, websites, SharePoint and OneDrive into knowledge bases	Sync sources
Events	Start agents on a schedule, a new GitHub issue, a Gmail message or a signed webhook	Routines
Models	28 providers, your ChatGPT subscription, your cloud contract (Azure, Bedrock, Vertex) or local models (Ollama, vLLM)	Models

Registry listings are publisher-provided metadata; each connection needs its own setup and access review. Outlook email and calendar connect through a third-party MCP service. Logos identify connection options and do not imply a partnership.

🧩 Build, share and operate

🤖 Build agents your team can reuse

Choose an agent's model, instructions and tools in the browser. Publish a version for colleagues to use; inspect earlier versions and roll back when needed. Keep specialized agents for research, reporting, coding or operations in one catalog.

The agent builder has four areas: (1) the name and publishing status, where a draft stays private until you publish a version; (2) tabs for the toolbox, MCP servers, limits, availability and version history; (3) the instructions, written in plain language like a brief for a new colleague; and (4) the model, chosen per agent from your configured providers.

Colleagues can use a published agent in web chat, Slack, Mattermost or Telegram when those channels are configured, on a website widget or a hosted page, or through the API and WebSocket. Build an agent · Connect a channel

📂 Work with files and code

Ask an agent to analyze a spreadsheet, produce a chart, prepare a document or work on a repository. With a container-backed sandbox configured and command execution enabled, it can read and edit files, run shell commands, and execute Python or JavaScript. The bundled workbench includes data, charting and document tools, including LibreOffice.

If you use Claude Code or Codex, the file-and-command workflow will feel familiar. AgenticOS brings that kind of work into a shared, self-hosted layer with company knowledge, reusable agents and organization access controls. What an agent can accomplish depends on its model, enabled tools and instructions. Sandbox configuration

🧠 Teach agents how your team works

• Skills hold reusable procedures: how to review code, write a report or research a market. Maintain them once and reuse them across agents.
• Context holds standing knowledge such as a glossary, policy or brand voice. Include it in the prompt or let the agent read it on demand.
• Knowledge bases (RAG) make uploaded documents searchable. Choose parsing options, inspect processing status and chunks, or sync them from a source listed below.

How retrieval-augmented generation (RAG) works in AgenticOS: documents are uploaded or synced from Google Drive, S3/MinIO, Git, websites, SharePoint or OneDrive. They are read by a parser: PyMuPDF and LiteParse run locally, with OCR for scans, while LlamaParse is a cloud service. Documents are then split into chunks, embedded with an OpenAI, OpenRouter or local Ollama model, and stored in PostgreSQL with pgvector. At question time the agent searches the vectors with filters and answers with citations.

Skills · Context · Document processing · Sync sources

🎨 Publish results as interactive pages

Agents can publish reports, interactive comparisons and small dashboards as apps. Choose who can open them; updates keep the same link and earlier versions remain readable. Public links can expire, require a password or restrict which sites may embed them. Share an app

📊 Track runs, costs and approvals

The dashboard answers six questions for a chosen period: how many runs there were, how many finished, what they cost and how many people used agents; how runs changed over time; what failed, waited for approval or was stopped by a budget; where runs came from; and which agents people actually use.

Customize the dashboard around your work. Activity lets you inspect runs and tool calls, compare agent versions and export records. Budgets per agent and organization are checked before each model request. Approval policies make sensitive tools wait for a person, and routines repeat work on schedules or events such as a new GitHub issue, a Gmail message or a signed webhook. Run history, budgets and approvals · Routines

👥 Organize teams with roles and groups

Roles define what people may do. Groups define who you share with. Use roles such as Builder, Operator, Member and Viewer, then create departments or working groups such as Operations, Engineering, Finance and Research. Share an agent, skill, collection, context file or app with a group in one step, or limit it to chosen departments when you create it. Departments and groups

Bring existing company accounts through OIDC single sign-on (Entra ID, Okta, Keycloak and others), LDAP directory login or Kerberos integrated Windows sign-in. Directory mappings connect directory groups to a role and a group at sign-in. Roles and permissions · Directory sign-in

🧭 Find your path

Building on it? Go to For developers and operators.

The question your teams cannot answer today	How AgenticOS answers it
Who may use which data?	Roles, department groups and per-resource sharing, with company sign-in
What does it cost?	Monthly budgets per agent and organization, checked before each model request
Who approved that action?	Sensitive tools wait for a person; every decision is recorded
Where does our data go?	You run AgenticOS and choose each model, parser and tool it may reach

What it takes: a host (4 vCPU, 8 GB RAM), someone to operate the deployment, and subject experts who maintain instructions and documents. Costs are model usage, infrastructure, external services and people's time; the software is Apache-2.0, commercial use included.

How to start: choose one repeated task and the person who will judge the answers, set it up with the model and access rules you choose, and check it against measures agreed beforehand. Plan a rollout · Compare approaches

Security is layered. Credentials sit in an envelope-encrypted vault. Code runs in isolated sandboxes. Published pages are sandboxed. Every organisation has a hash-chained audit log. Sessions are short-lived and revocable, and rate limits apply. Logs are redacted and data is swept on a retention schedule.

Outbound destination	Used when	Local alternative
Model provider	Every agent run	Ollama, vLLM or LM Studio on your hardware
Embedding provider	Indexing and searching documents	Local Ollama embedding models
LlamaParse	Collections set to that parser	PyMuPDF or LiteParse, both local
Web search	Agents with web search enabled	Turn the capability off
MCP servers, chat channels	Only those you connect	Self-hosted servers, web chat
Logfire tracing	Only when a token is configured	Built-in run history

• Vault: a data key per secret, wrapped per organization and key version; master keys rotate; values are never shown again.
• Sandboxes: the API holds no Docker socket; containers get no network unless needed, with CPU, process and time limits; gVisor optional.
• Audit log: hash-chained per organization, verifiable and exportable.
• HIPAA profile: deploy/profiles/hipaa/ and agenticos cmd doctor --profile hipaa check a running deployment against the §164.312 technical safeguards. It is a configuration check, not a certification. What it does not claim
• Stays with your IT: disk encryption at rest, egress firewall, MFA through your identity provider (no native MFA, SAML or SCIM), and backups that include the vault key.

Security and data flows · Data protection · Secrets · SECURITY.md

All tutorials. 24 have a reference run by the maintainers; they are starting points, not customer results.

📦 What ships today

• Knowledge and memory: knowledge search with citations, skills, context, memory, memory through mem0, past conversations.
• Web: web search (DuckDuckGo by default; Tavily, Brave or Exa with a key), reading web pages, and a web browser the agent drives and you can take over.
• Files, code and output: calculations in Python, a sandbox with files and a shell, a coding agent that hands work to Claude Code or Codex, charts, drawings (diagrams, calculators, 3D scenes), image generation (OpenAI or Google), apps.
• How it works: subagents, planning, thinking, work while tools run, tool search, date and time, instruction reminders, asking the user.
• Safety and limits: guardrails that redact secrets and personal data, long conversations, media offload, tool output limits.
• Chat channels: chat channel lookup for Slack, Telegram and Mattermost bots.

Plus any tool from a connected MCP server, and capabilities your engineers add in typed Python. Capability reference

Where agents answer: web chat, a website widget, a hosted page, the HTTP API, a streaming WebSocket, Slack, Mattermost and Telegram.

Model providers:

• Hosted (22): OpenAI, Anthropic, Google Gemini, OpenRouter, Mistral, DeepSeek, xAI, Cohere, Groq, Cerebras, Together, Fireworks, Hugging Face, GitHub Models, Alibaba, Moonshot, Z.AI, Nebius, OVHcloud, SambaNova, Heroku and Vercel AI Gateway.
• Your subscription: ChatGPT, through Codex, after one sign-in.
• Through your cloud contract: Azure OpenAI, AWS Bedrock and Google Vertex AI.
• Self-hosted: Ollama and LiteLLM, plus vLLM and LM Studio through an OpenAI-compatible endpoint.

🆚 How it compares

	Where it runs	Source	Models
AgenticOS	Your infrastructure	Apache-2.0	28 providers, including local ones and your ChatGPT plan
OpenAI dots	OpenAI's cloud	Proprietary	OpenAI only
Grok Bot	xAI's cloud	Proprietary	Grok only
Viktor	Viktor's cloud	Proprietary	OpenAI, Anthropic, Google, Kimi
n8n	Self-hosted or n8n Cloud	Sustainable Use License	Many, including Ollama

AI teammates are arriving in every vendor's cloud. AgenticOS is the one you run yourself, on any model, with the source open. Every comparison, in detail.

🎯 Is AgenticOS the right fit?

Choose it when a team has repeated document or tool-based work, subject experts who can maintain the instructions, and someone responsible for operating a self-hosted deployment. Know where it stops today:

🔐 Own your deployment, models and access

Sovereign means control over deployment, model providers, data flows and agent access. AgenticOS is Apache-2.0 software you can inspect, modify and operate.

There are two common setups. Self-hosted, with hosted models: AgenticOS, documents, vectors and logs run on your servers, and models come from a provider under your own contract and keys. Fully local: the same layer with open models through Ollama or vLLM on your hardware, plus local parsers and tools. Self-hosting the console does not make every model, parser or tool local, so review each destination you configure. Configure models · Security and data flows

🛠️ For developers and operators

AgenticOS is built with FastAPI, Pydantic AI, PostgreSQL with pgvector, Redis, Prefect and Next.js. Engineers add capabilities, sync connectors and MCP catalog entries in typed Python; teams compose agents from the registered capabilities in the console.

Layer	What runs there
Console	Next.js
API	FastAPI
Agent runtime	Pydantic AI and pydantic-ai-harness, one runner behind every surface
Background work	Prefect workers, Redis or Valkey
Data	PostgreSQL with pgvector
Code execution	Containers started by sandboxd

Call a published agent with POST /api/v1/agents/{id}/run as an authenticated member, or stream tokens over the WebSocket.

Architecture · API · Add a capability · Capability reference · Contributing

The operating-system analogy explains the architecture. The optional desktop app adds a dedicated window, a pet and a macOS screenshot shortcut.

❓ Frequently asked questions

Yes. AgenticOS is licensed under Apache-2.0, which allows commercial use, modification and private deployment. You pay for the infrastructure you run it on and for the model providers and external services you choose. The AgenticOS name and logo are not covered by the licence.

Yes. Configure Ollama, LiteLLM or an OpenAI-compatible server such as vLLM or LM Studio as the model provider, use local embedding models through Ollama, and parse documents with PyMuPDF or LiteParse. Self-hosting the console alone does not make every model, parser or tool local: check each destination you configure. Models · Data flows

Email and password with magic links, Google, generic OIDC single sign-on (Entra ID, Okta, Keycloak, Auth0, Authentik, Google Workspace), LDAP and Kerberos. Six built-in roles (Owner, Admin, Builder, Operator, Member, Viewer) combine with department groups and per-resource sharing. Multi-factor authentication comes from your identity provider; there is no native MFA, SAML or SCIM yet. Permissions

Monthly budgets per agent and per organisation are checked before each model request. Sensitive tools wait for a person's approval. Optional guardrails redact secrets and personal data, and every run is recorded with its agent version, tools, tokens and cost. Governance

AgenticOS runs on your infrastructure with any of 28 model providers and has no seat or credit fee of its own. It builds agents for the organisation, published to chat, websites and APIs, rather than assistant seats for individual employees. Compared with n8n it starts from the agent rather than a workflow canvas, and many teams use both. The guides also cover the self-hosted builder Dify and coding agents such as Claude Code. Comparisons

Docker Compose on one host. A machine with 4 vCPU and 8 GB of RAM runs it, and two API workers suit a team of ten. Someone needs to own updates, backups (including the vault key), access and the external services you connect. Deploy · Rollout

💬 Community

• Questions and ideas: GitHub Discussions.
• Bugs and requests: issues; planned work is grouped into milestones.
• Contributing: read the contributing guide and code of conduct. Report vulnerabilities privately as SECURITY.md describes.
• Releases: read the release notes, or choose Watch → Custom → Releases on GitHub to be notified.

📄 License

Apache License 2.0. See NOTICE and third-party notices for attribution and bundled components.

🤝 Need help putting agents into production?

Vstorm deploys AgenticOS in client infrastructure, writes the documentation, defines the processes and builds custom capabilities. Maintenance and support are agreed per engagement.

Built with care by Vstorm · Vstorm on GitHub

👥 Contributors

Everyone who has helped build AgenticOS: