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.

7 min read • View on GitHub • More from modimihir07

A wide editorial scene of a control room built from labeled drawers and conveyor rails, with tokens moving between skills, memory, scheduler, and three agent paths. It explains that this project is a control plane for AI work, not just a chat interface.
The system is organized around moving work through durable parts: skills, memory, scheduling, and agent routing.

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.

Mihir Modi, Author/Maintainer · modimihir07/agentic-os README
Key Takeaways

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.

A skill here is not a static command. It is a loop that can be executed, judged, revised, and reused with prior context.

A hedcut-style portrait of Mihir Modi based on his GitHub avatar. It serves as a verified author reference for the repo's maintainer and anchors the origin story visually.

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.

LayerWhat it doesWhy it matters
DashboardThin vanilla-JS operator surfaceKeeps the UI light and local
ServerFastAPI bridge and security boundaryCoordinates requests without hiding the filesystem
RouterDispatches work to the right agentPrevents every task from becoming a generalist prompt
SkillsExecutable task objects with historyTurns repeat work into an asset
BrainSQLite FTS5 plus markdown memoryShares context across sessions and agents
SchedulerCron-style automation and file watchingLets 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.

Mihir Modi, Author/Maintainer · I built an operating system for AI agents

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.

DimensionAgentic OSTypical agent framework
Core unitSkill with eval history and learningsAgent, chain, or workflow
MemoryLocal brain with searchable contextOften external or app-specific
AutomationBuilt-in scheduler and file watchingUsually added separately
Feedback loopScores and learnings persist per skillOften ad hoc or manual
UI surfaceLight dashboard for operatorsMostly libraries or demos
DeploymentLocal-first and self-hostableOften cloud-oriented or toolkit-based
Best forRepeated AI work with governanceBuilding 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.