An open exploration in agentic software

A place for thoughts.
A workspace for agents.

What if the outline you think in was also the place where work happens? Below is the actual outliner, playing a short story with scripted agents. Watch, or click in and take over.

  1. 1Write a thought
  2. 2Mention an agent
  3. 3Answer when it asks
  4. 4Review what comes back
  5. 5Keep the result
Playing

Write a thought. A bullet is a thought, and nesting gives it context. The outline is a normal outline until you ask for help.

Everything runs in this page: the outline, the room, and the agents, which are deterministic simulations. Nothing is sent anywhere, and a reload starts over.

The idea

Start small. Keep the thread.

Before the infrastructure, a few simple ideas about how working together should feel. Written, naturally, as an outline.

Humans author intent. Agents do the work. The outline is where both meet.1 need you1 to review
Intent has a shape #principle
A bullet is a thought. Nesting gives it context
Each bullet keeps a stable ID, so a thought can move and evolve without losing its history
Work needs its own space #principle
@claude implement the invite flowClWorking
Each run gets an isolated workspace: its own branch, terminal, and observations
All of it stays connected to the bullet that asked for it
@cursor build the share dialogCuNeeds you
Changes are a conversation #principle
@codex review the sharing testsCx2 to review
Agents propose. You accept or reject
Accepted changes become thought history; code lives in the project’s own Git
On the workbench

The agents above are scripted. The local harness is not.

threadvm open serves the same outliner against a Git-backed outline in your project. Delegated bullets run real agents in their own worktrees and tmux sessions, and report back as proposals.

OutlineLocal project↗
The running ThreadVM outline with nested project tasks, inline agent suggestions, and an Inbox for human review
A real local capture, with a seeded example project and proposals submitted through the CLI.
Built
Git worktrees, tmux sessions, ACP agents
Inline proposals and review
One outline across browser windows
Exploring
Markdown round-trip editing
From the local harness to a workspace runtime
Try the local workflow ↗
Look closer: proposals in reviewThreadVM showing proposed outline changes waiting for a person to accept or reject them

Proposals stay separate until a person accepts them.

Under the surface

Three histories. One connected story.

The document, the execution, and the code have different jobs. Keep each history where it belongs, and connect them with stable IDs.

Read the architecture note →
Thought

The outline and accepted proposals

.threadvm/ → nested Git repository
Execution

Runs, observations, and agent activity

events.jsonl → append-only events
Code

The actual changes to your project

project Git → worktrees + branches
Field notes 3

Thinking out in the open.

All plans & source ↗

What should come next?

This is a work in progress, built in the open. Good tools start with good questions.