Agentic OS: The Local Control Plane That Turns AI Skills Into a Feedback Loop
A FastAPI and vanilla-JS operating environment for multi-agent work, persistent memory, cron automation, and task scoring that improves how agents behave over time.

Layer 3 gives each skill a standardized structure (SKILL.md + learnings + eval + score history) so they improve over time. Layer 4 provides persistent memory via a shared brain/ folder and SQLite FTS5 — agents remember context across sessions.
- Agentic OS treats skills as durable objects, so execution, scoring, and learnings become a reusable feedback loop instead of one-off automation.
- The repo works like a local control plane because memory, scheduling, and routing are all built to support repeated agent work on the same machine.
- Its real differentiator is not multi-agent branding, but the way it preserves context and performance history across runs.
- Compared with framework-first tools, it optimizes for operating AI work locally, cheaply, and with tighter governance over every task.
Skills Are the Unit of Intelligence
Most agent projects start with orchestration. This one starts with the unit that actually gets better over time: a skill. In Agentic OS, a skill is not just a script. It is a managed object with instructions, evaluation, learning notes, and a score history that makes each run part of a longer memory.
That matters because it changes the shape of the product. Instead of asking, “Which model should handle this request?” the repo asks, “What is the best reusable way to solve this task, and how did the last attempt perform?” That is a more operational question, and a more durable one.
How the Control Plane Routes Work
The architecture is straightforward once you name the pieces. A FastAPI backend in server.py sits in the middle. The dashboard talks to it, the router decides where work should go, and three specialized agents handle different kinds of tasks: opencode for code and DevOps, Hermes for memory and scheduling, and Gemini for research.
| Layer | What it does | Why it matters |
|---|---|---|
| Dashboard | Thin vanilla-JS operator surface | Keeps the UI light and local |
| Server | FastAPI bridge and security boundary | Coordinates requests without hiding the filesystem |
| Router | Dispatches work to the right agent | Prevents every task from becoming a generalist prompt |
| Skills | Executable task objects with history | Turns repeat work into an asset |
| Brain | SQLite FTS5 plus markdown memory | Shares context across sessions and agents |
| Scheduler | Cron-style automation and file watching | Lets the system act without manual restart |
The interesting part is not that the parts exist. It is that they are wired to behave like an environment. The browser is an operator console, the filesystem is part of the runtime, and the agents are specialized workers inside a local control plane.
Memory Is Not a Chat Log Here
The memory layer is closer to operational context than conversation history. The repo indexes markdown content through SQLite FTS5, then uses that shared brain to make prior work visible to later runs. That means the system is not only remembering what was said. It is remembering what was learned, what was built, and what should be reused.
That distinction is practical. A chat log is passive. A searchable local brain becomes an input to later decisions, which is what you want if agents are going to work on the same project for days, not just answer a single prompt.
Scheduler Turns the System Into an Environment
The scheduler is what keeps the repo from feeling like a batch script. APScheduler handles cron-style jobs, and a file watcher can reload automation when job files change. That means tasks can recur, adapt, and keep running without the operator having to babysit the process.
This is where the operating system metaphor stops sounding decorative. A useful OS does not just launch programs. It keeps background work alive, notices changes, and makes automation feel native.

I built an operating system for AI agents. Not a terminal. Not a chat app. A full dashboard that coordinates three agents — opencode (code/DevOps), Hermes Agent (memory/scheduling), and Gemini CLI (research) — into one unified control plane.
Why This Is Different From Agent Frameworks
CrewAI and AutoGen are frameworks. Agentic OS is closer to a local workbench with memory, scheduling, and skill governance built in. That difference sounds subtle until you look at what is missing from many orchestration-first projects: persistent task history, a durable operator surface, and a feedback loop for improving specific jobs over time.
| Dimension | Agentic OS | Typical agent framework |
|---|---|---|
| Core unit | Skill with eval history and learnings | Agent, chain, or workflow |
| Memory | Local brain with searchable context | Often external or app-specific |
| Automation | Built-in scheduler and file watching | Usually added separately |
| Feedback loop | Scores and learnings persist per skill | Often ad hoc or manual |
| UI surface | Light dashboard for operators | Mostly libraries or demos |
| Deployment | Local-first and self-hostable | Often cloud-oriented or toolkit-based |
| Best for | Repeated AI work with governance | Building custom agent workflows |
The repo is not trying to win by being the biggest framework. It is trying to make repeated local work feel coherent. That is a narrower goal, but a sharper one.
The Trade-Offs Behind the Design
This design buys you control, but it also adds moving parts. You get repeatability, task history, and local ownership. You also inherit more surface area to maintain, test, and secure. The system is useful precisely because it is opinionated about how agents should work together.
That is a fair trade if your priority is long-lived AI labor on a machine you control. It is less attractive if you want a minimal library or a purely cloud-managed service. The repo is optimized for operators who care about process, not just prompts.
What the Repo Is Really Optimizing For
Agentic OS is optimized for locality, reuse, and evaluation. It wants AI work to leave a trail that can be measured and improved. It wants automation to survive restarts. It wants memory to be queryable, not mystical.
That is the real contribution here. The project does not just run agents. It turns their work into a local system with enough structure to learn from itself.





