What ARI-OS is

ARI-OS is an orchestrator-first layer on top of Claude Code. It changes one thing, and that one thing changes everything: you stop doing the work and start directing it.

You stay in the chair. You make the judgement calls. Background workers do the execution. The point is not to remove you from the loop. The point is to move you up a level, so your attention goes to shaping the outcome and judging the result, not to typing every step yourself.

This is the core claim the whole system is built around. AI accelerates, it does not generate. The acceleration is real, and it is large. The taste, the standard, and the final yes remain yours.

The loop

Directing is not one action. It is a loop you run, again and again, at whatever pace the work needs.

You define the outcome in plain language. You dispatch the defined work to background workers. You review what comes back. You ship only what passes. The same shape holds for a quick fix and for a week of building. Once the loop is familiar, the size of the task stops mattering.

The loop is not a one-way pipeline. Review can send work back to dispatch. A weak spec sends you back to plan. That is the system working as intended. The judgement stays with you at every turn, and nothing ships until you say so.

The four pillars

Underneath the loop sit four pillars. Each one removes a different kind of friction, and together they are what make directing practical rather than aspirational.

• Spec-firstpillarYou define the outcome in plain language before any code is written. The spec is the brief, and the brief comes first.
• Background dispatchpillarDefined tasks run detached, on cheaper workers, while your session stays free. You are not blocked waiting on a build.
• Handoff continuitypillarContext survives when a session ends, so the next one starts without losing the thread. Nothing has to be rebuilt from memory.
• Live local Cortex brainpillarA memory layer on your own machine that both reads and writes, and pulls the right past context back when you need it.

Spec-first is the discipline that makes everything else safe. If the outcome is vague, the work that comes back will be vague, no matter how fast it arrives. Writing the spec first is how you keep the acceleration pointed at the right target.

Background dispatch is what frees your attention. The execution happens on workers, detached from your session, so the slow part of the work does not hold your seat hostage. You can shape the next task while the last one runs.

Handoff continuity is what lets the work outlive a single sitting. When a session ends, the thread is preserved, so the next session picks up where you left off instead of starting cold.

The live local Cortex brain is the memory layer underneath all of it. It runs on your own machine. It reads and it writes, and it returns the past context that is relevant now, so the loop stays informed without you having to repeat yourself.

What you need

ARI-OS requires Claude Code. It is a layer, not a replacement, so it sits on top of an existing setup rather than standing in for it. If you already work in Claude Code, you already have the foundation.

It is version 2.0.0, open-source under the PolyForm Noncommercial licence, at https://github.com/PUSHINGSQUARES/ARI-OS.

One thing worth settling early is when to reach for a one-off task and when to build a repeatable workflow. The first is a single dispatch. The second is a shape you will run more than once, so it is worth defining properly.

Where this goes

You direct and review. The workers execute. That division is the whole idea, and once it is in place the rest is practice.

You direct and review. The workers execute.

Next, install it. The install guide walks you through setting up the layer on top of your existing Claude Code.