If you work the way I do now, you don't have an agent. You have a workforce. Claude Code for the hard 10% — architecture, security, the calls that are expensive to reverse. Codex for the autonomous frontend task. DeepSeek for the bulk build. Something for orchestration on top. Each one is sharp. And each one starts every single task the same way: cold.
Cold means no memory of what I'm actually building or why. Cold means no map of the codebase — so the agent opens files at random, greps around, burns half its context window re-reading a repo it read an hour ago, and then confidently scaffolds against an assumption I never made. I'd explain the same constraint for the fifth time. I'd watch an agent "helpfully" refactor three files I didn't ask it to touch, because it had no idea what the task was for. The work compounds; the context doesn't. The tax isn't abstract — it's every task starting from zero.
There's a whole category forming around fixing this, and a lot of it is genuinely good. Cursor put the agent inside the editor where it can see your files. Google Antigravity and agentic IDEs are reaching for the "agent that lives in your workspace" idea. Graphify turns a codebase into a queryable knowledge graph so an agent can ask about structure instead of reading everything. opensrc pulls the real source of your dependencies to disk so the agent stops guessing at library internals. If one of those solves your problem, reach for it.
But none of them solved the problem I actually had, which is narrower and more personal: I don't have one repo or one agent — I have a folder full of projects and a rotating cast of agents, running on my machine, and I wanted a single place to point them at a task and have them start grounded instead of cold. I didn't need a smarter model. I needed one place to stand while I direct them.
So I built one, and I'm open-sourcing it under Antharmaya Labs. It's called Horizon OS.
What "grounded" actually means
The core move is boring and it's the whole thing: before an agent runs, Horizon composes its context. Every deploy carries two blocks the agent would otherwise never have.
The first is who I am and what I'm doing — an operator profile I set once after loading a workspace: the mission, the constraints the agents must never cross, and the goals that matter right now. It's the difference between an assistant that forgets and a cofounder with continuity.
The second is a map of the relevant code — and this is the part I'm proud of. The naive thing is to dump the repo, or dump the whole knowledge graph, into the prompt. That's the anti-pattern; it defeats the point of building a graph at all. Instead, Horizon queries the graph for just the task at hand and injects a budgeted result — a few hundred tokens of "here are the files and calls that matter, traverse these first, only open source if this isn't enough." Concretely, a deployed task spec on my own repo lands at around 1,558 tokens. The same context as dumped files would be tens of thousands. The agent starts knowing the shape of what it's touching, without me paying for it to re-read the world.
Everything else is a control surface on top of that. I deploy a task to a chosen agent from any screen. I watch it run — a live stream of the process, not a spinner — and I can stop it. When it's done, it's a run I can point at and grade, not a black box. I can load any folder of repos and it sweeps them, builds a graph per repo, and the deploy loop just works over the new workspace.
The honest limits
I'm not going to pretend it's finished. Today the deploy pipeline injects the graph of the project an agent is working in, but not yet the graphs of its dependencies — the code for that exists and isn't connected yet. The live console streams and stops real runs, but I've only put it through its paces with a safe test runner; pointing it at a live repo-writing agent is a switch I've built and not yet leaned on hard. And it's still my portfolio's data underneath — making it clean enough for anyone to clone and run over their own repos is the productization work I'm in the middle of. I'd rather say that plainly than ship a demo dressed as a product.
Why open source, and why now
Because one founder can't out-type an agent workforce, but you can out-direct it — and the edge is entirely in the directing: giving each run your goals and the real structure of the code, watching what it does, stopping what it shouldn't, grading the result. That's judgment over generation, and it's the skill the whole field is starting to hire for.
So Horizon OS is going open under Antharmaya Labs, MIT-licensed: point it at your own folder of repos and it becomes your cockpit, not mine. The cost of running it stays near zero — the local agents run on the subscription you already pay for, and building a repo's graph runs about three cents of a cheap model, once.
I built this because I was tired of my agents starting every task blind. If that's your tax too, it'll be yours to run soon.