AgenticOS Goes Public — The First Multi-Agent System Built by a Human and AI Together

What happens when one developer and multiple AI agents collaborate for nine months to build a full-stack agentic process operating system? You get AgenticOS — and this week, the source code goes public on GitHub.

The Backstory: Building with AI, Not Just Using It

AgenticOS wasn’t built by a team of ten engineers. It was built by one human orchestrating multiple AI agents across nine months. Not “AI-assisted” in the way people mean when they say Copilot autocompleted a function signature. This was a fundamentally different development model — the developer as orchestrator, not just coder.

The pattern emerged early: decompose a feature into architecture decisions, implementation tasks, test plans, and review passes. Route each to the AI model best suited for it. Claude Opus for architecture and design reasoning. Claude Sonnet for fast implementation and scaffolding. OpenAI Codex for autonomous task execution in sandboxed environments. Gemini 2.x for cross-validation and alternative perspectives. Different models from different providers reviewing each other’s output as genuine second opinions — not rubber stamps, but adversarial quality gates where one model catches what another missed.

What used to take a team two weeks compressed into half-day sprints. Entire development cycles — design, implement, test, review, merge — completed in hours. Not because corners were cut, but because the bottleneck shifted from typing speed to judgment speed. The human makes architecture decisions, evaluates trade-offs, manages context across sessions, and calls the final merge. The AI handles the volume.

A solo developer with AI support isn’t truly solo anymore. The result is AgenticOS: 10 services, 7 transition types, 42 agent tools, a visual editor, distributed execution, secret management, a CLI, a Telegram bot, full observability — and now, publicly available on GitHub.

What Is AgenticOS?

AgenticOS is the Multi-Agent Framework for real operations. At its core are Agentic-Nets — Petri nets extended with seven transition types that bridge deterministic automation, AI reasoning, distributed execution, and structural knowledge in a single executable graph.

Chat agents are great for exploration. Agentic-Nets are what you use when exploration turns into operations.

This isn’t another framework or SDK. AgenticOS is a complete system: a visual editor for designing nets, an orchestration engine that executes them, distributed executors that run shell commands across networks, a secrets vault, a CLI with multi-provider LLM support, a Telegram bot for conversational control, and a full monitoring stack with Grafana, Prometheus, and distributed tracing. Everything you need to go from “I have an idea for an agentic process” to “it’s running in production” — without writing glue code.

The Components: How They Work Together

Closed-Source Core (Available on Docker Hub)

Three services form the foundation. They ship as pre-built Docker images on Docker Hub — pull and run, no compilation required.

agentic-net-node (:8080) — The event-sourced content repository. Every place, token, and inscription lives in a hierarchical structure backed by immutable events. Query anything with ArcQL. This is the ground truth of every Agentic-Net.
agentic-net-master (:8082) — The brain. Orchestrates all seven transition types, manages agent sessions with 42 tools and role-based capability flags (rwxh), integrates with multiple LLM providers, and handles the full transition lifecycle: bind tokens, execute action, emit results.
agentic-net-gui (:4200) — The Angular visual editor. Drag-and-drop net design, token inspection, Monaco-based inscription editing, session management, and Docker container panels. Build and observe your Agentic-Nets without writing JSON by hand.

Source-Available Services (On GitHub This Week)

Six services and a complete monitoring stack — all source code, all build configs, all deployment manifests.

agentic-net-gateway (:8083) — OAuth2 API gateway with JWT authentication. Routes traffic to master and node, enables secure executor-to-master communication across networks. Executors authenticate once, then poll with tokens.
agentic-net-executor (:8084) — Distributed command execution. Polls master for work using egress-only connections — no inbound ports, no firewall holes, no VPN tunnels. Deploy executors anywhere: on-prem, in a VPC, on a Raspberry Pi. They call home, not the other way around.
agentic-net-vault (:8085) — Secrets management via OpenBao (the open-source Vault fork). Stores transition credentials so your Agentic-Nets can authenticate against external APIs without hardcoding secrets in inscriptions.
agentic-net-cli — Command-line interface with multi-provider LLM support. Talk to AgenticOS directly from your terminal. Supports Claude, Ollama, Claude Code, and Codex as providers. Dual mode: connect directly to services or route through the gateway.
agentic-net-chat — Telegram bot integration. Conversational control of your Agentic-Nets with session management, auto-compaction, and direct transition execution from chat.
sa-blobstore (:8090) — Distributed blob storage for large artifacts that don’t fit in the token tree.
Monitoring stack — Grafana dashboards, Prometheus metrics, Tempo distributed tracing, and OpenTelemetry collector. Full observability out of the box.

Key Architectural Patterns

Polling over pushing. Executors poll master for assigned work. This is a deliberate design choice: egress-only connections mean executors can sit behind firewalls, inside VPCs, or on air-gapped networks. No inbound ports. No webhook registration. No NAT traversal headaches. The executor calls home every 2 seconds, picks up command tokens, executes them, and reports results. Stateless, scalable, firewall-friendly.

Gateway auto-authentication. In distributed deployments, the gateway handles JWT authentication for all service-to-service traffic. Executors acquire a token once and use it for all subsequent polls. The GUI routes through the gateway transparently. Zero manual token management.

Two deployment modes. The Docker Compose setup ships with two configurations: hub-only (all services from pre-built Docker Hub images — one command to run everything) and hybrid (open-source services built locally, closed-source from Hub — for contributors who want to modify the open-source components).

The Seven Transition Types: Four Lanes of Execution

Every Agentic-Net is built from seven transition types organized into four lanes. Three are deterministic — they execute without AI cost, perfectly repeatable. Two use AI reasoning — they handle novel decisions, natural language, and complex judgment. One executes shell commands on distributed infrastructure. And the seventh — Link — defines structural knowledge graph connections that agents navigate to discover context.

The power of this model is pattern crystallization. When an agent transition solves a problem repeatedly, the pattern gets extracted and crystallized into a deterministic transition — a pass, map, or HTTP call that runs without AI cost. The cost curve bends downward over time. AI handles the novel work. Deterministic transitions handle the routine. The system gets cheaper and faster as it matures.

The Link transition is the seventh type and the newest addition. Unlike all other transitions, links never fire at runtime — they carry no action block, consume no tokens, and run on no executor. Instead, they define semantic relationships between places: parent/child, related-to, depends-on. Agents discover these connections via the GET_LINKED_PLACES tool, enabling them to navigate knowledge graphs and find related context without the designer hard-coding every relationship into prompts. Links turn a flat collection of places into a navigable structure.

Nets as Agents: The Multi-Agent Paradigm

Most multi-agent frameworks define agents in code — a Python class, a YAML config, or a prompt string wired to an API. In AgenticOS, the net IS the agent. A Petri net defines everything about an agent’s behavior: what data it can see (places), what tools it can use (roles), where it must write outputs (postsets), what other agents it collaborates with (transitions), and how knowledge flows between them (arcs and links).

This means building a multi-agent system is the same as building a net. Each agent transition within a net is an autonomous AI actor with its own role, tool access, and scope. Wire multiple agent transitions together with places, and you get a multi-agent system where coordination is structural, not conversational. Agents don’t negotiate by chatting — they coordinate through tokens. One agent writes findings to a place. Another agent reads from that place and acts on them. The net topology guarantees the ordering, the data flow, and the isolation.

Consider the Reflexive Brain pattern: two agent transitions (t-brain-answer and t-knowledge-synth) plus a command transition (t-source-explorer) wired into a self-improving loop. Three transitions, each with a distinct role. The brain answers questions and identifies knowledge gaps. The explorer executes shell commands to investigate. The synthesizer distills raw results into structured knowledge tokens. They don’t share a context window or a conversation thread — they share places. The net defines their collaboration pattern, and it’s visible, inspectable, and modifiable without changing code.

You can create multiple Agentic-Nets, each representing a different agent with its own specialization. A DevOps agent net handles infrastructure analysis. A code review agent net handles pull request quality. A documentation agent net keeps architecture docs fresh. Each net is a complete agent definition — self-contained, deployable, and composable with other nets through shared places and link transitions that form a navigable knowledge graph.

This is what makes AgenticOS a multi-agent system, not just an agent framework: the agents aren’t independent programs talking through APIs — they’re structured actors within a formal model where data flow, concurrency, and coordination are mathematically defined by Petri net semantics.

The Licensing Model: Free for Learning, Testing, and Personal Use

AgenticOS uses a dual licensing model designed to enable maximum community access while protecting commercial viability.

All published source code ships under the Business Source License 1.1 (BSL). The code is fully readable and modifiable — free for development, testing, personal projects, and educational use. No restrictions for non-production, non-commercial work. The BSL automatically converts to Apache 2.0 on 2030-02-22 — after that date, the code becomes fully open source under a permissive license. Until then, it’s source-available: you can read it, learn from it, extend it, and run it — the only restriction is commercial production use.

Docker Hub images for the closed-source services (node, master, gui) ship under a Proprietary EULA — also free for personal, educational, and non-commercial use. Pull the images, run the full stack, learn the system. No trial periods. No feature gates. No “contact sales” walls.

The intent is simple: if you want to learn about multi-agent systems, distributed agentic processes, or Petri nets — AgenticOS is yours to explore. Run it locally. Read the source. Build test agentic processes. Extend the services. Write your own executors, CLI plugins, or Telegram bots. The only boundary is commercial production deployment, and even that boundary dissolves in 2030 when the BSL converts to Apache 2.0.

What Makes This Different: Human-in-the-Loop at Scale

Every multi-agent framework demo looks the same: two chatbots talking to each other in a loop, producing increasingly ungrounded output until someone hits Ctrl-C. AgenticOS isn’t that. It was built using a multi-agent development pattern that’s fundamentally different from the autonomous agent fantasies dominating the discourse.

The model is human-in-the-loop at scale. One human orchestrator. Multiple AI agents, each with a role. The human doesn’t write every line — but makes every architectural decision, evaluates every trade-off, and passes final judgment on every merge. The AI agents don’t operate autonomously — they operate under direction, with clear task boundaries and quality gates between each step.

Consider the traditional alternative. A system like AgenticOS — 10 services, event sourcing, distributed execution, a visual editor, secret management, CLI, Telegram integration, full observability — would traditionally require a team of 8-10 engineers working 18-24 months. Millions in salary. Months of coordination overhead. Meeting-driven architecture decisions.

The human-in-the-loop model compresses this. Not by cutting corners, but by eliminating the communication overhead that dominates traditional teams. There’s no “let me sync with the backend team” when the same orchestrator holds the full context. There’s no “we’ll discuss this in the architecture review” when the architecture agent and the review agent can iterate in the same afternoon. The half-day sprint becomes possible because the bottleneck is no longer parallel human coordination — it’s sequential human judgment.

Cross-model review deserves special mention. When one AI model implements a feature and a different model reviews it, you get genuine second opinions. Not because the models have different “personalities” — but because they have different training data, different architectures, different failure modes, and different blind spots. A bug that Claude Sonnet introduces, Gemini catches. An over-abstraction that one model creates, Codex flags as unnecessary. Code generated by one provider gets stress-tested by another. This isn’t rubber-stamp review. It’s adversarial quality improvement across provider boundaries.

Getting Started

The fastest path to running AgenticOS is the hub-only Docker Compose deployment. Every service pulls from Docker Hub — no compilation, no build tools, no JDK required.

# Clone the repository
git clone https://github.com/alexejsailer/agentic-nets.git
cd agentic-nets/deployment

# Configure environment
cp .env.template .env
# Edit .env with your settings (LLM provider, API keys, etc.)

# Start everything
docker compose -f docker-compose.hub-only.yml up -d

# GUI:      http://localhost:4200
# Grafana:  http://localhost:3000 (admin/admin)
# Node API: http://localhost:8080
# Master:   http://localhost:8082

For contributors who want to modify the source-available services, the hybrid deployment builds those locally while pulling closed-source images from Docker Hub:

# Hybrid mode: build OSS locally, pull core from Hub
docker compose up -d

The repository is available on GitHub this week. Star it, clone it, break it, build on it.

What’s Next

Community contributions — The source-available services are ready for pull requests. Build new executors, add CLI providers, extend the Telegram bot, improve the monitoring dashboards.
Production deployment guides — Kubernetes manifests, cloud provider templates, and operational runbooks are coming. AgenticOS already runs in Docker Compose; production-grade deployment documentation is next.
More transition types — The seven types cover a wide range, but the inscription model is extensible. WebSocket transitions, scheduled triggers, and event-driven transitions are on the roadmap.
Cluster mode — Multi-node master clustering for high availability and horizontal scaling. The consensus infrastructure already exists (sa-consensus); integration with the transition engine is the next step.
Blog series continues — Deep dives into Agentic-Net patterns, the Reflexive Brain, ArcQL query strategies, and real-world agentic process examples.

AgenticOS was built using the human-in-the-loop multi-agent development pattern described in this article. Every service, every line of architecture, every deployment config was created through collaboration between a human orchestrator and AI agents — primarily using Claude (Anthropic) with models including Claude Opus and Claude Sonnet, alongside OpenAI Codex for autonomous sandboxed execution and Google Gemini 2.x for cross-provider validation. The system you’re reading about was built by the process it describes.