NEW IN 0.5 Tachyon: Init — detects your stack and writes your tachyon.yml. →

SEVERAL AGENTS. ONE EDITOR. NATIVE TERMINALS.

Any AI agent. Side by side. Inside VSCode.

Claude Code Codex Gemini OpenCode Qwen Code ＋any CLI

Stop alt-tabbing to babysit agents: Claude Code, Codex, Gemini, OpenCode — or any CLI — each as a tmux session in a native editor terminal, with one orchestrating the rest through an embedded MCP Bridge. 100% local, on the subscriptions you already pay for.

Install from the Marketplace GitHub

Real capture: Claude (left) asked Codex (right) to review a route via write_input — Codex is reading the code and running lint, audit and tests.

How it works

Three steps, no magic

Open a project

The Get Started walkthrough opens on install. Run Tachyon: Init — it detects your stack and writes a commented config.

Set up your agents

Agents, terminals, commands and runbooks — configure in the Agent Studio UI or write the tachyon.yml yourself.

Start your fleet

Auto-start agents boot the moment you open the project, coordinate via MCP, and notify you when they need you.

Observability

Know which agent needs you

With several agents running, the expensive part is noticing which one stopped. Tachyon watches every pane and tells you — and your other agents — exactly who is running, who is idle, who crashed, and who is waiting for your answer.

needs you — high-precision prompt detection ([y/n], confirmations, selectors): yellow bell, a badge on the ⚡ icon, one toast with an Open button
idle — CPU-aware silence: a thinking agent is never flagged as stuck
crashed — exit N — the dead pane is kept frozen for postmortem; opt-in auto-restart with backoff and a crash-loop guard
Every state is exposed to orchestrating agents via list_agents — a parent can spot a stuck sibling and answer it

Sidebar showing four live agent states: asker needs you, claude running, crashy crashed with exit 7, watcher idle — plus the attention badge

Bring your own agent

Works with the CLIs you already use

Claude Code, Codex, Gemini, OpenCode, Copilot, Aider — plus any dev server, watcher or build command. No lock-in, no reselling your tokens.

Claude Code Codex Gemini OpenCode Qwen Code ＋Custom

Tachyon: Init auto-detects Node, Laravel, Rust, Go, Python & Rails the moment you open a project.

Config as code

Your whole fleet in one tachyon.yml

Define every agent and process once. Commit it to the repo. Your teammate clones, opens the project, and gets the exact same workspace — same agents, same instructions, same commands.

Per-agent env, working dir, auto-start and watch-restart
Role instructions injected as the agent's startup prompt
Curated commands & gated runbooks agents can run safely
Your comments survive every UI edit — the file stays the source of truth

tachyon.yml

# Your whole fleet, versioned in git
agents:
  claude:
    cmd: claude
    autostart: true
    instructions: "Senior engineer. Ship clean PRs."
  dev:
    cmd: npm run dev
    watch: "src/**"

commands:
  test: {cmd: npm test}
  lint: {cmd: npm run lint}

runbooks:
  ship:
    steps: [lint, test, ./deploy.sh]

The Bridge — built-in MCP server

One agent becomes a fleet

Tachyon runs a local MCP server per workspace. Your agents use it to spawn sub-agents, read each other's output, type into each other's terminals, and ping you when they're done — and the whole tree is right there in your sidebar.

Sidebar lineage: claude with a nested worker, which has a nested researcher

⚡
Spawn on demand

An agent calls spawn_agent with a role prompt to delegate to a fresh sub-agent — children are full agents and can spawn their own.
⛶
Workspace-isolated

Each folder gets its own Bridge, port and token. Sub-agents only see siblings in their own workspace — no cross-talk.
👁
You stay in the loop

Every sub-agent appears in the tree with live status; orphans are promoted, never cascade-killed, and any agent can toast you with notify.

18 MCP TOOLS, OUT OF THE BOX

spawn_agentStart declared agents or ad-hoc sub-agents with a role prompt

kill_agentStop any running agent

restart_agentKill + respawn with the same definition

list_agentsEveryone's state: running, attention, crash, lineage

read_outputRead another agent's terminal

write_inputType into another agent's terminal

wait_for_agentBlock until a sibling is idle / needs input / dead — event-driven

notifyShow the human a VSCode notification

run_commandRun a curated one-shot, get {passed, exitCode, tail}

list_commandsThe curated commands and their last results

run_runbookSequential procedure with an exit-code gate

propose_schedulePropose a timer — inert until the human approves it

list_schedulesActive schedules + pending proposals

create_pinPin a finding to the shared checklist

list_pinsRead the checklist before starting work

complete_pinCheck a pin off when the work is done

get_notesRead the project's shared whiteboard

set_notesReplace the whiteboard — the durable handoff

Commands & Runbooks

Exit code is the result

Agents run forever; commands run once — exit 0 is a green ✓, non-zero is a red ✗ with the dead pane kept for postmortem. Runbooks chain them with an exit-code gate: the first failure stops the procedure and keeps the evidence.

One click for you (▶ in the sidebar), one blocking call for agents (run_command)
A vetted alternative to agents typing arbitrary shell
Failed step reopens its frozen output — inspect exactly what happened

Commands view: lint and test passed with exit 0, runbook failed at step 2

Schedules

Runtime-neutral cron, human-gated

Claude has /schedule; Codex, Gemini and OpenCode have nothing. A schedules: map gives any runtime cron-like timers over the executors you already have. They fire only while the workspace is open — no daemon, no unsupervised agents waking at 3am.

every: 1h or at: "09:00" → run a command/runbook or spawn an agent
Agents can propose_schedule — but the proposal is inert until you approve it (approval writes it into tachyon.yml)
No agent schedules itself into action without your sign-off

Schedules sidebar view: a pending agent proposal awaiting approval, plus an active (paused) schedule

Pins & Notes

Pin it now, deal with it later

Findings shouldn't die in scrollback. Every workspace gets a shared checklist and a whiteboard — yours in the sidebar, your agents' over MCP, and your team's as plain files (.tachyon/pins.json, .tachyon/notes.md) you can commit.

Agents create and check off pins over MCP — they track their own plan as they work
Notes are the durable handoff between parent and sub-agent
Plain files: readable by anything, committable if the team wants shared findings

Pins view: notes summary, two open pins authored by agents, one completed

And the details that keep you in flow

Built for real agent fleets

∞

Survives restarts

tmux owns the processes — close VSCode, reopen, and Tachyon re-attaches your still-running agents. Nothing dies with the window.

⚡

Event-driven engine

One persistent tmux control-mode client: zero subprocess churn, crashes detected in ~1s, transparent fallback if it ever drops.

⛶

Multi-root ready

Each folder is an isolated world — own tmux namespace, own Bridge port and token, own pins. The sidebar groups per folder only when you need it.

🌐

Your theme, your language

Sidebar and Agent Studio render with your theme's tokens — light, dark and high-contrast — in English and Português (Brasil).

Multi-root

Workspace isolation, for real

Two folders in one VSCode window — an API and its worker. Each gets its own Bridge (note the two ports), its own agents, commands and pins. The status bar says ⚡ Tachyon ×2.

Multi-root workspace: two folders each with their own Bridge on different ports, own agents, commands and pins; status bar shows Tachyon ×2

Own tmux namespace, Bridge port and token per folder — sub-agents can't cross-talk
Palette commands ask which folder; tree items act on their own folder
Folders added or removed live are picked up without a reload

Server Inspector

See the whole tmux server

The sidebar shows what this folder owns. The inspector opens an editor view over the entire dedicated tmux -L tachyon socket — every session, across every open folder and the orphans a closed window left behind — grouped by workspace then kind, each with its live / exit-code badge, pid and command.

tmux Server Inspector: every session on the tachyon socket grouped by workspace then kind, with live and exit-code badges, pid and command, and per-session Capture and Kill actions

Cross-workspace — agents, commands, runbook steps and orphaned sessions, with busy/idle and uptime
Per session: Open (attach in a terminal), Capture, Kill — plus one-click Kill-all-dead and Reap-orphans
Only Tachyon's dedicated socket, never your own tmux — Kill stays safe by design

Agent Studio

Manage everything from the UI

One form, five tabs — Agent, Terminal, Command, Runbook, Schedule. Quick-add chips for the AI CLIs detected on your machine, per-runtime flag chips, role instructions. Every edit goes through the same comment-preserving pipeline as hand-editing.

Agent Studio — Agent tab: quick-add chips for detected CLIs, command, instructions, working dir, autostart/restart/attention

Agent Studio — Terminal tab: command and watch globs for restart-on-change

Agent Studio — Command tab: a one-shot command (npm test)

Agent Studio — Runbook tab: steps one per line with live command-vs-shell resolution

Security

Local by design

Loopback only — the Bridge binds to 127.0.0.1, never the network. No cloud, no telemetry, no account.
Bearer auth by default — per-workspace token in the extension's private storage, referenced via env var, never written to a committable file; injected automatically into every spawned session.
Workspace isolation — sessions, port, token and pins are namespaced per folder; Tachyon runs its own tmux server, your ~/.tmux.conf is never touched.
Guardrails — maxAgents caps concurrent sessions (no fork-bombs); destructive UI actions confirm or refuse while running.

Start your fleet. It's free.

MIT-licensed, open source, bring your own agent CLIs.

Install from the Marketplace Star on GitHub