नेता · Hindi: leader

You talk to a leader.
It runs the missions.

Neta keeps a long-lived Node for every workspace. The coordinator reasons, opens missions, and directs mission leads; each mission lead works directly or with agents of its own — every mission numbered, every outcome closed out.

One Node serves every client. The terminal attaches to the leader's conversation, and the desktop draws the same state as a spine of missions, a mission bar for work that needs you, and chat on the exact same sessions. Close any client and the work keeps running.

MIT one bundled file no build step node 22+

$ npm i -g @intervene/neta

$ neta open ~/your-repo

attaching to coordinator · Lead, read-only

› the signup flow drops 4% of users at the email

step. find out why and fix it.

● mission 12 opened · mission lead assigned

● agent gray-owl investigating the checkout flow

» gray-owl: the token expires before the mail

provider retries

● mission 12 ready to close · merged, evidence recorded

✓ mission bar clear · 3 missions closed this week

1 mission · 2 agents · every turn in the event log

› ▌

A leader, not just a chatter

The coordinator stays available in one continuous conversation and routes sustained work into missions. A small bounded task it handles itself; anything that writes becomes a mission, so isolation, access, and closeout stay visible.

One mission, one objective

Each mission has a permanent number, one owning workspace, one worktree, and one mission lead. Numbers are never reused, and a closed mission stays on the spine at its start position — archived and read-only, never deleted.

Work survives the UI

The Node owns every session, mission, and event. Closing the terminal or the desktop changes nothing on the Node; the next client takes one snapshot and resumes exactly where the previous view left off.

Finish, then close

Merging a branch does not close a mission. The leader reviews the handoff, records merged or abandoned with evidence, and only then is the mission closed. The mission bar keeps every open mission visible until then.

One tree, three levels

leader · mission lead · agent

coordinator

One continuous conversation per workspace. It opens missions, sets access, and owns closeout — merged or abandoned, with evidence, for every mission.

mission

One bounded objective with a permanent number that never changes. Its worktree, agents, conversations, and closeout state all belong to it.

mission lead

The agent responsible for one mission. It may work directly or create ordinary agents, and it moves between Lead and Lead++ as the work demands.

agent

A bounded helper beneath a mission lead. It receives a task, read-only or read-write access, a provider and a model — and creates nothing further.

Agents take display names from a fixed pool, unique across the workspace's open missions. Activity shows Running or Not running from actual execution. Archiving hides an agent from the sidebar and preserves its conversation.

Lead first, Lead++ when it earns it

access is visible and reversible

Mode

Coordination

Workspace writes

How it ends

Lead

opens missions, directs agents

never writes

the default, always

Lead++

everything in Lead

builds and writes, one writer lease at a time

returns to Lead when mutation work ends

Mission lead

directs its mission's agents

in Lead++ only, under a decision record

closing the mission returns it to Lead

Every Lead++ request carries a decision record — objective, target mission and worktree, files affected, validation, duration. Duration counts active connected time only; after ten minutes the canvas warns and a reminder falls due every two minutes. Nothing expires on its own.

Missions you can open

every conversation is the real one

Every leader, mission lead, and agent holds a real OpenCode conversation owned by the Node. Selecting it — in the terminal or on the canvas — opens that exact session with its full history. No dummy surfaces, no second orchestration path.

The desktop draws the spine with its missions, the mission bar with the coordinator and every open mission that needs a person, and a navigator that jumps anywhere. The terminal attaches to the same leader conversation the desktop shows, so both views see each other's turns.

netaattach to the leader, starting the Node if needed

neta open .open this workspace and its leader

neta mission 7open mission 7 by its permanent number

neta missionsmissions, states, and what needs you

neta eventsread the workspace event log

neta node statusthe Node, without starting one

neta node stopstop the Node and what it owns

neta mcp --actor <id>tool proxy for one agent session

mission 12 · signup recovery · lead: juniper · Lead++

objective: find the drop-off and fix it

Mission lead juniper

Two call sites set the cookie directly, so the

token is signed in session.ts and read back in

the middleware.

● agent gray-owl read-only · checkout flow mapped

● agent sorrel read-write · worktree mission/12-signup

integration evidence

branch mission/12-signup is ancestor-verified

» 41/41 tests pass

⠹ ready to close · awaiting leader review

│ merge and close mission 12▌ │

enter prompts this conversation now · ctrl+c closes

Providers & skills

one OpenCode path, every agent

Every agent runs in OpenCode

One transport for the coordinator, mission leads, and agents — clicking any of them opens that exact session.

Each provider has a configured default model; the mission lead may override it for an individual agent.

Provider, model, access, and conversation identity persist with the session. Interrupted work is marked honestly, never replayed.

Neta controls private OpenCode servers through their native API. Each server uses the operator's OpenCode provider connections.

Skills, not fixed identities

An ordinary agent is described by its task, model, access, and skills — never by a permanent caste.

Skills are composable instruction and tool bundles the mission lead attaches to the task at hand.

Each Git mission gets its own worktree by default, and each worktree admits at most one active writer; further writers queue.

Ordinary markdown you can override per project — as are the provider defaults in settings.

Owned by one Node, seen by every client

what each side does

The Node owns

Workspaces, leaders, missions, agents, OpenCode session identities, the event log, and conversation history under ~/.neta — written atomically, files only.

One complete snapshot on connect, then live push on the same connection — no client ever merges a delta into a stale base.

Restart restores the recorded conversations and marks interrupted work, with the prior state preserved for the leader to decide on.

The clients borrow

The terminal acts and formats: it opens workspaces, attaches to the leader, lists missions and events, and stops the Node.

The desktop renders and caches: the spine, the mission bar, the navigator, and chat — with a bounded read cache for offline reading.

The tool proxy only forwards: one stdio process per agent session, carrying the actor's token and adding no behavior of its own.

Run it in a workspace you know

Neta needs Node 22+ and a connected OpenCode model provider. The first neta open starts the Node; everything after that is conversation.

Read the docs The manifesto