The Ecosystem · 2025–present
Continuum
Work should persist, a cognitive workspace where intent, not conversation, is the unit of collaboration with machines.
A desktop workspace for running fleets of agents on real work, where what persists between them is not the conversation but what it decided.
Continuum's Activity Hub, a worklist of tasks grouped by status beside a Supervision panel where the three tasks of a milestone are drawn as a dependency graph, each card carrying its mode chips from exploring through to finalizing.
The evaporation
Every tool for working with a machine assumes the session is the container.
A chat opens, context accumulates, the window fills, the window closes. Whatever understanding was built in there is gone, and what remains is a transcript, which is not the same thing as a place where work is kept. This is a strange shape to have settled on, because it is the opposite of how professional work behaves.
-
The window is the boundary
Context accumulates until it no longer fits, and then the understanding built inside it ends. Not archived. Ended. The session was never designed to hand anything to its successor, so it doesn't.
-
Re-briefing, every morning
Each new session begins by explaining the situation again: what this is, what was already decided, what is half-finished, what must not be broken. The explanation is the expensive part, and it is performed from memory.
-
The human became the scheduler
The agent writes the code. The person decides when exploring becomes researching, loads the right standards for it, composes the prompt, watches the window fill, and saves the state before it closes. That choreography, not the code, is what fills the day.
-
State bound to a machine
Work that lives in an editor's workspace, a terminal's history and one laptop's disk cannot be resumed from the other machine, or after the branch changed, or two weeks later.
-
A transcript is not a memory
A conversation records everything that was said and privileges none of it. The decision, the rejected alternative, the thing still owed: all present, all weighted the same as the typos, none of it addressable.
-
Nothing holds the outstanding
Between one session and the next, the only thing that knows what the system is still responsible for is the person. Which is precisely the thing they were trying to put down.
The contradiction underneath
The reframe
Intent is the unit. The conversation was only how it arrived.
If the session is the wrong container, the question is what the right one holds. Not the transcript. The transcript is exhaust. What is worth keeping is narrower and far more useful: what was decided, what is in flight, and what the system is still responsible for.
The person states intent and judges outcomes. The architecture takes everything in between: context, choreography, state, transitions.
The second reframe: supervision, not automation
There is an easy version of this idea in which the human is removed, and it is the wrong one. The point was never that agents run unattended. It is that the room stays legible while they do. Running many agents in parallel is not the achievement. The achievement is a space in which that is calm.
So the architecture is built to be supervised. Modes are named, gates are checkable, every session records what it produced and what it cost, and the escape hatch is a single command that opens the exact session an agent ran so it can be continued by hand. Autonomy that cannot be inspected is not autonomy. It is opacity with a better name.
What the architecture holds
Six things that stop living in the operator
Every one of these was, at some point, work the person did between sessions. None of them is judgement. Some things do genuinely require it: is this the right plan, is this worth starting, is this actually done. There the work stops and waits to be read.
Refining demand into something executable
A vague ask is not a task. In one continuous session the raw signal is first explored until the terrain is mapped, then decided upon: scope, granularity, the order things have to happen in. Only then is it written out as briefs for an initiative, its milestones and their tasks. The phases are messages in a single conversation rather than separate sittings, so nothing has to be re-explained to reach the next one. Throughout, the machine proposes and the person decides.
refiner
A gate in front of the backlog
Deep focus lasts days; requests do not wait for it. Everything that arrives, whether a thread, an alert or an idea at midnight, lands in an inbox that carries no obligation, is digested into a structured packet, and is classified by what kind of work it would become. Then, in a window you choose rather than the moment it arrived, you accept, defer, delegate or discard. Incidents skip the queue. Nothing else does.
steward
The choreography between sessions
The prompt for each mode is composed, not typed: the task's identity and current state, the files that need to be in front of the agent, the standards that apply to this particular mode, and the directive for what to do next. Around the session sit deterministic hooks: rebase before, commit and push after, state written back. What used to be eight manual setups for one task became one command, with the interruptions kept available rather than required.
foreman
State that is a file, not a claim
One YAML per task is the single source of truth for execution: which mode it is in, which branch it is on, what is blocking it, and every session that has run against it with its turn count, its cost and the artifacts it produced. It lives in git, beside the work but outside the source tree, which is why the same task survives a branch switch, a worktree, or being picked up on a different machine entirely.
dao
A limit that actually holds
Work waiting to run is a queue with priorities and dependencies, and how much of it runs at once is a number you set rather than a habit you fight. Milestones carry a dependency graph and are resolved in topological order, so something genuinely blocked stays blocked instead of being started a second time because nobody remembered the first.
marshal
A machine is somewhere to run, not somewhere to be
Compute is provisioned from recipes and reached through tunnels, which makes a laptop, a node on the desk and a rented GPU the same kind of thing to the system: places where execution happens. What is left over per device is projection: which windows, which applications, which layout. That is separated into a layer of its own, so the environment is something work is rendered into rather than the place it lives. That layer is scaffolded; its per-platform adapters are still being written.
ita · plumber · canvas
Architecture
Three planes, and a hierarchy the filesystem already knows
The shape follows the two claims. Intent has to be made dense before anything can execute it, so refinement is a plane of its own rather than a step. And execution has to remain inspectable, so state is a file rather than a service.
Three planes
The context plane is the newest and the one that carries the argument. Its premise is borrowed from an older era of this industry: crude material has no direct value until it is refined. Meetings, threads, constraints and half-formed intentions are crude. A brief with scope, dependencies and success criteria is not. Every step between them exists to raise the density of intent until an executor, human or agent, can act without stopping to ask.
Below that, orchestration is deliberately unglamorous. It schedules, it runs sessions, it checks gates, it writes state back, and it makes no decision about what is worth doing. The substrate plane makes none about what to run at all; it only runs. Judgement concentrates at the top, where the person is, which is the only place it was ever going to be any good.
One task, end to end
A task moves through named modes, and every transition is guarded by an artifact rather than by an assertion. Planning cannot begin until research exists as a file. Implementation cannot begin until there is a plan, a checklist, and a written definition of what validated will mean. Validation cannot begin while the working tree is dirty, and nothing finalizes until every box in that definition is ticked.
It is a small idea with a large consequence. Because the gate is a file, progress is verifiable by anything that can read a directory: the orchestrator, the desktop app, the next session, you. An agent that reports it is finished and an agent that is finished become distinguishable without anyone reading the transcript.
Above the task sits the rest of the hierarchy: a milestone that groups tasks into a shipped capability, an initiative that groups milestones into a strategic goal with a dependency graph between them. No metadata store holds that structure together. The path on disk is the structure. Where a file sits is what it belongs to.
The substrate
There is no database in any of this. Work state is YAML and markdown in a directory tree, kept in git, and deliberately separated from the source it acts on. That separation is what lets one task outlive a branch, a worktree, a machine, and eventually the tooling that reads it.
Above the tree sit a few dozen small command-line tools, grouped by the layer each one serves. The desktop app is a supervisor's view of exactly those files, not a second system with its own opinion about what is true.
- contextdigestion, refinement, intake
- orchscheduling, execution, state, gates
- flownavigating and isolating work across repositories
- substrateprovisioning and connectivity
- canvasmaterializing the environment per device
- observethroughput, calibration, cost
- gradientsthe standards that load into a session by mode
What persists
Sessions are disposable. What they wrote down is not.
This is the thesis stated as a mechanism rather than as a hope. The session, the thing every other tool treats as the container, is the one part of this architecture designed to be thrown away.
By the time a task is finished it holds a written account of its own reasoning: the brief it was handed, what exploring the codebase turned up, what the research concluded, the plan, the checklist, the definition of done and whether it was met. None of that was produced as documentation. Each file existed because it was the gate that let the next mode begin, which is exactly why it exists at all. The record is a byproduct of the mechanism rather than a chore appended to the end of it.
Beside it sits the execution ledger: every session that ran, in which mode, for how many turns, at what cost. That converts a set of questions usually answered by instinct into questions with an answer: where the time actually goes, which mode is expensive, whether a task was badly sized before anyone started it. The value is not the figures. It is that a supervisor can be wrong about their own system and find out.
The same conviction runs through the other two ecosystems. Compass exists to get the work, and when a contract closes it hands over more than a name: the working hours discussed in a screening, the communication rhythm observed across a process, the delivery expectations, written into the profile under which Continuum then runs that work. Ciclus sustains the person doing both, and refuses to gamify them for it. Three systems, one premise: what a person learns should be held by something other than their memory.
What Continuum is finally arguing is architectural, and it is about a room rather than a tool. When some of the inhabitants of a workspace are agents, the design question is not how to make them faster. It is what the space has to be for a person to stay oriented inside it: what surfaces for a decision, what is absorbed in silence, what can be opened and inspected on the day trust runs out. This is the studio’s first principle made structural: presence over noise. Good orchestration, like good architecture, disappears into the experience of simply working, and the measure of it is not how much ran while you were away. It is how little of it you had to hold.