/ Built by Przemysław Tarkowski · Software engineer · Warsaw
I built an OS for Claude Code that doesn't stop at the context window.
TarkOS wraps a coding agent and runs a tracked backlog across many sessions. It does the reversible work itself, parks the calls that need a human, learns from every correction, and hands off to a fresh session when it hits the context limit. I watch and steer it from a desktop console.
I'm a software engineer in Warsaw: 11 years shipping production games and game infrastructure. TarkOS is my daily R&D.
Cockpit
Orchestrators
Primitives
Cross-cutting
Deterministic floor
cockpit preview · the interactive demo runs on desktop
/ The core loop
One run, across many sessions.
TarkOS turns the context limit into a handoff, and every step into a tracked file. Here is a full run, end to end.
- backlog
Pulls from a tracked, auditable queue
TarkOS works a backlog of tasks, each with acceptance criteria. It doesn't invent work from thin air; it pulls from a real, version-controlled queue.
- run
Runs the next task and verifies it
The engine picks the highest-priority task, does it, and runs the eval gates before moving on.
- decide
Decides the safe work, parks the rest
Reversible, high-confidence work auto-applies and leaves a reviewable record (do-then-confirm). Irreversible or taste calls park for me; quick questions go to an async tray. It never ratifies its own decision.
- capture
Captures the lesson mid-run
Durable learnings, a correction or a gotcha, are filed where the next session will read them, so it needs less steering.
- ceiling
Hits the context limit, saves cleanly
At the window's edge it checkpoints all state to files and closes, instead of losing the thread.
- relay
Hands off to a fresh session
A new session resumes with the carried context; the relauncher chains sessions so one job runs for hours.
- watch
You watch and ratify from the cockpit
I steer from Mission Control. Every step passed through git-tracked files, so the whole run is auditable and survives restarts.
Then it loops: a fresh session picks up at step 2 and the run continues, for hours.
/ Architecture
An operating system, not a script.
One choice runs through everything: components never call each other. They communicate by reading and writing git-tracked files. There is no hidden in-memory state; the state is the files, in version control. That is why a run is auditable, resumable, and portable.
/ What it does, and the proof
A run that outlives the context window.
A single session dies at the context limit. TarkOS treats it as a checkpoint, not a wall: it saves cleanly and hands off to a fresh session that continues with the carried context. The relauncher chains sessions so one job runs for hours, across many sessions, with no loss of thread.
Auditable, because nothing is hidden.
Every component talks through git-tracked files: no hidden in-memory state, no direct calls between parts. So a run is auditable (read exactly what happened, commit by commit), resumable (restart from the files), and portable (the system installs onto any agent non-destructively).
It decides what's safe, and parks the rest.
Reversible, high-confidence work auto-applies and leaves a record I can review. Irreversible or taste calls park and wait for me; TarkOS never ratifies its own decision. The gating policy only auto-applies when an action is both reversible and above a confidence threshold; calibration tracks how often it was right and proposes tighter thresholds over time. Questions it can defer go to an async tray, so it keeps working while it waits on me.
Less steering, session over session.
When I correct it, the lesson is captured mid-work and filed where the next session will read it. The signal I track is corrections-per-session trending down, shown as the number and the actual rule it captured, not a claim.
/ See it run
See it actually run.
More of the system in motion: the autonomous runs, the project goals, the git-backed state. (The interactive console is up in the hero; click through it.)
TarkOS scores its own readiness across ~11 dimensions, currently ~62%, tracked over time. The self-measurement is part of the engineering: an honest gauge, not a done claim.
/ Why this matters
I build autonomous agent systems as R&D: systems that hold state, stay auditable, keep a human on the decisions that matter, and run past the limits of a single model context. TarkOS is the one I use daily.
TarkOS is a personal R&D system I use daily; it isn't released. I'm happy to walk through the internals in a conversation.
What TarkOS demonstrates
- Autonomous task execution across sessions
- Context engineering: checkpoint and relay past the window
- Git-backed, auditable agent state
- Human-in-the-loop decision systems (gating, calibration)
- Eval-gated, production-minded tooling
Every change passes eval gates and regression tests. The system installs onto any agent non-destructively and is designed to be open-sourced. And it measures its own readiness honestly.