An extensible ecosystem that starts as a blinking cursor.

The role

What it replaces, and what it extends

You already work this way: a coding agent in a terminal, most of the day. Organon is that — the same harness, the same agent programs, the same permission prompts — running as a native GPU application instead of inside a terminal emulator. It opens on a blinking cursor and nothing else.

What a terminal harness cannot do is grow. You can give the agent new instructions, but you cannot give the application new parts; the surface it draws is fixed when it ships. Organon is extensible from the inside, and there are two doors, neither of which requires rebuilding Organon.

Skills teach the agent. They are text files, loaded from the project the agent is standing in, and one of them covers driving Organon from its own CLI and changing the console the agent is running inside. Adding one changes what the agent can do between recompiles.

Modules teach the window. A module is a separate repository that depends on one small contract crate; you approve it at a specific commit, and Organon clones it, shows you git diff against the commit you last approved, builds it, launches it, and paints its frames into a region you name — viewport left 3d producer ascent.

🚨 A module is a process, not a plugin. There is no dlopen anywhere in the tree and no wasm: the module runs as its own operating-system process and hands over a texture through shared memory. That is the safety property rather than a missing feature — approval gates building, because a build script runs as you, and the process boundary gates running. Revoking a module leaves a saved layout that still opens.

The definition, in the words the repository uses

Organon is a native GPU application. You divide the window into regions, declare what each holds, and save the arrangement under a name. Every arrangement includes an agent that can operate the whole application through the same commands you use.

That paragraph is the product definition's §1.1, quoted rather than re-authored. The claim was once spelled six different ways across the tree, which is how it came to be stale in six places at once; there is one source now, and several front doors. This is one of the doors.

Getting it

Build from source

There are no releases yet. When there are, they will be on the repository's releases page and this section will say so; until then the way in is a clone and a build, and that is the honest description rather than a placeholder.

Rust via rustup is the only prerequisite on macOS and Windows. On Linux the engine pulls in ALSA/JACK and X11/GL, so the dev headers have to be installed first — the README carries the exact list, and without them the build dies inside a build script, which reads like a code error and is not.

cargo test --workspace runs the unit tests and validates every WGSL shader on the CPU with naga, so shader errors are caught on any machine, with no GPU.

One

Arrange

One window, one pane, divided into up to six regions on a three-by-two grid. Every region is a word a person says — left, topcenter, bottomright, twelve of them, each with a short form. A region holds an agent conversation, a column of instrument panels, or a live 3D viewport, and the whole content vocabulary is four words: agent, panel, 3d, off.

A region is a set of cells, and two may coexist exactly when their cell sets are disjoint — so there is no layout arithmetic to get wrong. Assigning onto something already held is resolved by containment, and the displacement is reported. A partial overlap is refused by name, quoting both regions, because it has no unambiguous thing to take away.

The model is flat, never nested, and the reason is the vocabulary rather than the geometry: a tree has no names. /viewport left agent is a sentence a person says and an agent writes; the same intent in a tree is a path through splits that must already exist. What that costs is stated rather than hidden — no uneven splits, and no dragging a divider.

An arrangement has a name and a file, and loading one applies whole or refuses with a sentence. It is validated against eight refusals before a single assignment lands, so a layout that cannot be drawn leaves the one you are looking at standing.

A layout is the unit of identity. What is written to disk is not a window position — it is which program you are running. The visualizer, the model inspector and the agent workstation are three arrangements of one application.

Two

Operate

Every arrangement contains a working agent, and the agent operates the application — not a chat window bolted to one. It runs the same commands you type.

One vocabulary, several front doors. A verb exists for everyone or for no one: the CLI, a slash command in the composer, an agent's tool call and a control inside a region converge on one dispatch, and two tests hold them there — that every console verb is typeable as a slash command, and that all surfaces of a verb produce the same operation value.

That is not tidiness, and it was measured. A command expressed to an agent as prose cost thirteen seconds and a chunk of context, passing through inference, a tool search, and an approval card asking a person to approve their own command. The slash lane removes the inference and the card. It does not remove the discipline.

The agent can read as well as write. Reads a fire-and-forget lane cannot answer are served in-process, so it can ask what the camera is doing or which layouts exist and get an answer — reported as separate facts rather than folded together, because an agent acts on them differently.

Which agent program a tab runs is configuration, not code. Identity, launch command, how to detect it on this machine, where to obtain it, which directory to start it in and whether it runs inside WSL are fields of a registry entry. Built-ins are seeded in code and a user's file is merged over them by id. Pi-first, Pi-not-required; the plain login shell is the entry every registry carries.

Three

The hand outranks the agent

Where a person and an agent can both act on the same thing, the person's action wins by construction rather than by convention — and the surface says so when something moves that nobody is looking at.

An agent's power is bounded by approval, not by good behaviour. Every tool it calls, shell commands included, passes one permission card, answered in-process so the hook is a direct call into the state the interface is already drawing. A skill can teach an agent what to want; it cannot get it past the card.

And nothing on screen may be silent about being empty or refused. A region that draws nothing is indistinguishable from one that is broken, so vacancy is a sentence carrying the word a person would type to fill it, and a refusal names the obstacle and the command that clears it. An empty ring carries the reason it is empty, enforced by a type that cannot be constructed without one.

A subagent is not a turn — it is something a tool call is doing — so its activity folds onto the card that spawned it rather than taking a place in the flow of its own. What such a card honestly shows is that an agent is running, which tool spawned it, and what it did. Never a live feed: token-level deltas from a subagent are not forwarded at all, and a counter guards that claim rather than a comment asserting it.

Four

Extend from within

A skill is instructions: text that teaches the resident agent a part of the application, loaded from the project the agent is standing in. Adding one changes what the agent can do without a rebuild — and one of them covers driving Organon from its CLI and changing the console the agent is running inside.

What a good one encodes is a loop rather than an API listing: see → act → see. Read the live state, change one thing, then look again, with a rendered frame as the agent's eyes and never an assumption that a change did what was intended. The live catalog is the authority over the skill's own prose, so the skill teaches the grammar and points at the tool for the vocabulary.

An agent has to be given somewhere to stand. Which directory a conversation tab starts in decides which project instructions and which skills it can see, and it is resolved by four stated rules with a unit test each — then reported unconditionally, along with which rule chose it and a warning when the directory satisfies no project marker at all.

That report exists because the paradigm was failing silently at its first step. An agent asked to use a skill answered "Unknown skill", because it had been started in the application's own directory and could see no project instructions, and nothing anywhere said so. The only symptom of that is an agent that seems oddly ignorant.

Five

What an arrangement holds

Three exist today. They are the same engine with a different front-of-house: the algorithm, every shader, the shared-memory snapshot layout and the preset store are identical across all of them.

A fourth thing a region can hold is a module — someone else's repository, approved at a commit, running as its own process and painting into the region you named it in.

The visualizer's limits are attributed to it rather than generalised into the platform, and that distinction has since been cashed. One live viewport is that renderer's constraint — its shared frame index and jitter phase — and it says so in the refusal a person reads. Because the limit belongs to the producer rather than to the region model, two hosted viewports are legal: a second producer changed one function and the site that renders it, and left the region model, the layout and the vocabulary alone.

Scientific honesty, three commitments

Structure is read from the source: counts and wiring, never invented. A live signal comes from the real process, not a decorative animation. And every projection is labelled as a projection — a provenance marker is attached to every displayed quantity, and a proxy says so where a person is looking, not only in a document.

The engine is a set of Rust crates licensed MIT or Apache-2.0, and a project outside the repository can depend on them directly. That path is proven rather than asserted: a separate repository consumes four of them pinned by commit, with a licence-graph gate in CI as the enforcement.

Six

State of play

The sections above describe what Organon is. This is what it currently does, as of 22 August 2026. It is kept here rather than behind a link, because the difference between an enforced principle and an intended one is the whole of whether any of the above is worth reading.

⚠️ This table is ahead of the PRD's own §12, which is dated 21 August and says the hosted-module protocol does not exist. It did not, the day that was written; four tiers landed after it. What survives from that paragraph is the narrower and more interesting half — no dlopen, no wasm — which is a design decision rather than an unbuilt feature, and is why a module is a process.

Nothing on this page is a roadmap promise, and nothing on it is unshipped work described in the present tense. Where a claim is direction, the row above says so.

Seven

Read next

The documentation lives in the repository and is maintained in the same change as the code it describes, enforced by hooks. These are the entrances worth using.

• Documentation Build it, run it, and operate it — the region vocabulary, saved layouts, the agent, the visualizer, and the command surface. An index with opinions; every section names the file that owns it
• README Build it, run it, drive it from a terminal. The shape of the repository
• The guide Using the visualizer: installing into a DAW, generators and materials, playing it from clips and controllers, presets, capture
• The reference Every generator, surface, material, parameter and recipe — generated from the source and pinned by a test, so it cannot fall behind the code
• The product definition What the product is, in three lengths; the design principles; the verification bar; and §12, the honest state of play
• Architecture The engine reference: the algorithm, the two-process IPC model, the crate graph, a per-file map
• Contributing How changes get made here — scoping, the tier pattern, the review cycle, the verification bar. Start here before writing code
• Licensing Why the engine is permissive and the plugin is GPL, and what that constrains
• Organon Mind The research the building produced: a pattern language for agent control surfaces, and the papers behind it