AgenticOS

Sovereign Agentic AI Layer

AI agents your whole team can use and improve.
Self-hosted on infrastructure you control, with budgets, approvals and a recorded run.
_{Apache-2.0 · built on Pydantic AI}

See it · What is it? · Quick start · Integrations · Product tour · Find your path · What ships · FAQ · Introduction deck · Documentation

English · Polski · Deutsch · Español

AgenticOS is a sovereign, self-hosted layer for your company's AI agents: they work with files, run code and use your company's tools and knowledge. 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 14-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 44-slide product tour. Arrow keys step through either deck; O lists every slide.

📸 See it in action

agenticos-intro-16x9-4k.mp4

_{AgenticOS in 45 seconds. Build any agent in the browser, publish it where your team works, let it run on its own, and keep every request under the same controls. Narrated with a synthetic voice. Watch (46 s, 4K)}

demo-chat-short.mp4

_{Brief → research → shared result. A recorded run: an agent reads a campaign brief in Notion, researches repositories on GitHub and publishes an interactive planner. Watch (37 s)}

Build in the browser. Instructions, model and tools; publish versions.	Work with files and code. A CSV in, a chart and findings out.
Teach how your team works. Skills written once, reused by every agent.	Answer from your documents. Upload or sync, then cite.
Publish results as pages. Stable links and versions. Demo data.	See usage and spend. Runs, outcomes and budgets in one view.
A catalog of agents. Private, shared with a group, or company-wide.	Access follows your organization. Roles, groups and company sign-in.

_{Captured from a test deployment. Figures are test records, not benchmarks.}

💡 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 27 model providers, including 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 it fits into your company. Illustrated people; the agents are examples.}

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.

_{At a glance: 26 built-in capabilities · 8 places an agent answers · 27 model providers · 5 document sync sources · 5,700+ MCP server listings and 99 curated servers · 29 tutorials.}

✨ 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.

Inspect the installer or deploy another way

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	99 curated MCP servers (Notion, GitHub, Jira, HubSpot, Stripe…) plus 5,700+ registry listings 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	27 providers, 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 artifacts. 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 artifact

📊 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 artifact with a group in one step.

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.

Deciding whether to adopt it: the problem it solves, what it takes, how to start

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

Reviewing security: data flows, identity, controls, what stays with your IT

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

Looking for a first task: 29 tutorials, each with a check you can run

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

📦 What ships today

All 26 built-in capabilities, as text

• Knowledge and memory: knowledge search with citations, skills, context, memory files, memory through mem0, conversation search.
• Web: web search (DuckDuckGo by default; Tavily, Brave or Exa with a key), web fetch, browser automation, and browser-use (wired, not yet installable).
• Files, code and output: run Python, files and shell in a container sandbox, charts, image generation (OpenAI or Google), artifacts.
• How it works: delegation to other agents, planning, thinking, tool search, date and time, system reminders.
• Safety and limits: guardrails that redact secrets and personal data, context management, media offload, tool output limits.
• Chat channels: 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, and which models they use

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.
• 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.

🎯 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:

Not available today:

• Source-system permissions, such as SharePoint ACLs, are not mirrored per user. Scope the source credential instead.
• There is no built-in Microsoft 365 trigger.
• The visual workflow builder is in development.
• There is no native MFA, SAML or SCIM. Use your identity provider through OIDC.
• There is no reranker.
• AgenticOS runs on a single host with Docker Compose. There are no Kubernetes manifests.
• Budgets can be overshot by parallel runs.
• Results depend on the model, tools and instructions, so evaluate them on your own task.

🔐 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

Is AgenticOS free for commercial use?

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.

Can AgenticOS run with local models only?

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

Which sign-in methods and roles does it support?

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

How does AgenticOS keep agents under control?

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

How is it different from ChatGPT Enterprise, Copilot Studio or n8n?

AgenticOS runs on your infrastructure with any of 27 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

What does it take to run?

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