What is the difference between the amux board and steering?

The board is the team task tracker — durable work items in backlog, todo, doing, and done that any session can claim and update. Steering is a per-agent message queue — a note left on one agent's desk that is delivered only when it finishes what it is currently doing. Use the board for work that should be tracked; use steering to redirect one agent without interrupting it mid-task.

Why doesn't my steering message deliver immediately?

By design. Steering waits for a genuine turn boundary — the agent must be truly finished with its current task (no spinner, no running subagent, a settled idle prompt) before the message lands. That is the point of the analogy: you are leaving a note on the desk, not barging into the office. If you need to interrupt right now, use direct Send instead of Queue.

What are amux skills?

Skills are reusable markdown playbooks — standard operating procedures any agent can run as a /command. Write the procedure once (deploy steps, a review checklist, a standup format) and every session in the fleet can execute it identically. amux ships four by default: /amux, /standup, /handoff, and /adhd, and they work across Claude Code, Codex, and Gemini sessions.

What does the amux Cost tab show?

The Cost tab is payroll plus the project budget report for your agent team: real dollar-equivalent cost per turn (priced from a per-model table), rolled up by task, by session, by model, and by day, with cache-hit rate as an efficiency signal. It is derived entirely from transcripts and the board — no model calls — so it stays accurate as models improve.

What is the amux scheduler for?

The scheduler gives an agent recurring duties — a prompt on a timer, like 'every weekday at 8am: triage my inbox and email me a digest.' It is the standing-meeting calendar of your agent team. Anything you would put in a human's recurring calendar block can become a schedule.

How is the amux Messages tab different from the terminal?

The terminal shows the agent's live screen right now. The Messages tab is the searchable archive of every instruction you ever sent that agent — like your chat history with a colleague. It is stored server-side, so it is identical from your desktop and your phone.

What is the amux browser and why does it have my logins?

amux runs a shared automated browser with saved authentication profiles. Log into a site once, and any agent can drive that site as you — pulling invoices, publishing posts, or working dashboards that have no API. The analogy: an assistant who already has the passwords, so you never re-onboard them.

Memory is per-project institutional knowledge: durable facts, preferences, and conventions injected into every session that works in that project. New sessions start already knowing how your team works — the same way a good onboarding doc means a new hire doesn't ask questions the wiki already answers.

Do I need to learn all amux surfaces to start?

No. Start with three: Sessions (hire your first agent), the Board (give it tracked work), and Steering (redirect it without interrupting). Everything else — schedules, skills, cost, browser, memory — layers on when the corresponding knowledge-work need appears.

The amux Mental Model — Every Surface Mapped to How You Already Work

Q: What is an amux session?

An amux session is one AI agent (Claude Code, Codex, or Gemini CLI) running in its own terminal, pointed at a working directory, with a model, live status, and token spend. Think of it as an employee with a job: the working directory is their desk, the status dot tells you whether they are working, waiting for you, or idle, and the task label is what they are currently doing.

Updated July 2026 — definitions, analogies, and a mock of every surface

Quick answer: amux makes sense the moment you stop thinking "terminal multiplexer" and start thinking "team you manage." A session is an employee. The board is the task tracker. Steering is a note on someone's desk. Skills are playbooks. The Cost tab is payroll. Every amux surface is a tool you already use to run knowledge work — applied to AI agents.

AI agents are knowledge workers. They take tasks, hold context, produce work, get stuck, and cost money. amux is the management layer around them — and every one of its surfaces maps to something you already do when you work with people. This guide walks the whole map: a definition of each surface, the workplace analogy that makes it click, and a mock of what it looks like.

The whole map at a glance

amux surface	Knowledge-work analog	One-line definition
Sessions	Your team roster	Each session is one agent with a job, a desk (working directory), and a live status.
Peek	Walking to someone's desk	The detail view of one agent: live screen, history, git state, messages, cost.
Steering	A note on their desk	Messages queued for delivery when the agent finishes its current task.
Board	The task tracker	Shared kanban all agents read and update, with atomic claiming.
Scheduler	Recurring duties	Prompts on a cron — standing meetings for agents.
Calendar	The team calendar	Real events, synced to Google/Apple via a private feed.
Skills	Playbooks / SOPs	Reusable procedures any agent runs as a /command.
Messages	Chat history	Searchable archive of everything you told each agent.
Notes	The team wiki	Server-side markdown docs, editable anywhere.
Files	The shared drive	Remote explorer with previews — code, PDFs, even ebooks.
Browser	Assistant with the passwords	Shared automated browser with saved logins agents can drive.
Cost	Payroll + budget report	Dollar cost per task, per agent, per model, per day.
Memory	Institutional knowledge	Per-project facts every session starts already knowing.
People	The rolodex	CRM of contacts and interactions your agents can use.
Workspace	The open-plan office	Grid of live terminals — every desk visible at once.
Metrics	Facilities dashboard	CPU, memory, and per-session resource health.
Alerts	The fire alarm	Urgent owner notifications — push and iMessage, used sparingly.
/standup	The morning standup	One command: what every agent did, what's stuck, what needs you.
/handoff	Shift change	Package state and pass work from one agent to another.

What is a session? — your team roster

Definition: a session is one AI agent running in its own terminal: a working directory, a model, a live status (working / needs you / idle), a task label, and a running token count.

Analogy: an employee with a job. The directory is their desk. The status dot is whether they're heads-down, standing at your door with a question, or between tasks. The token counter is their hours. Hiring is one click: point a new session at a repo and it starts working.

The sessions view: three agents, three desks, three statuses — a roster you can read in one glance.

What is the peek? — walking over to someone's desk

Definition: the peek is one session's detail view: its live terminal, full transcript history, steering queue, git worktree and commits, message archive, schedules, notes, and cost — in tabs.

Analogy: walking to a colleague's desk. The Terminal tab is looking over their shoulder at their screen; Transcript is their day's paper trail; Worktree is the state of their desk; Cost is what this person's work costs. You can do it from your phone — checking on an employee from the beach.

The peek: one agent's screen, history, and paperwork in one place — desk-visit distance from every device.

What is steering? — a note on their desk

Definition: steering is a per-agent message queue. Queued messages deliver one at a time, only when the agent is genuinely finished with its current task — no spinner, no running subagent, a settled idle prompt. Delivery is verified, so nothing silently vanishes.

Analogy: instead of barging into a focused colleague's office, you leave a note on their desk. They finish what they're doing, then read it. A stack of notes gets worked top-down, one per sitting. That's why a queued message doesn't land instantly on a busy agent — that's the feature.

The steering queue: two notes waiting, delivery held until the agent's current task is truly done.

What is the board? — the team task tracker

Definition: a shared kanban — backlog, todo, doing, done, verified — that every session reads and updates over a REST API. Tasks are claimed atomically (two agents can't grab the same ticket), carry an owning session, and gate transitions (a code task can't be closed without acknowledging it merged).

Analogy: Jira/Linear for your agent team, with one upgrade: the workers update it themselves, honestly. "Doing" means an agent is on it right now; "done" means implemented; "verified" means confirmed working in production — the same discipline you wish your human tracker had.

The board: work as durable tickets, claimed and moved by the agents themselves.

What is the scheduler? — recurring duties

Definition: the scheduler runs a prompt against a session on a schedule — daily at 9am, every 15m, every weekday at 8:30, or full cron. Runs are logged with results.

Analogy: standing meetings and recurring duties. "Every morning, triage the inbox." "Every hour, check the deploy." An automation is just a prompt on a timer — anything you'd put in a human's recurring calendar block becomes an agent's job.

The scheduler: recurring prompts with run history — duties, not one-off asks.

What are skills? — playbooks and SOPs

Definition: a skill is a markdown playbook stored once and runnable by any agent as a /command — across Claude Code, Codex, and Gemini sessions. amux ships four by default: /amux (drive the system), /standup (fleet roundup), /handoff (pass work between agents), /adhd (action-first output shaping).

Analogy: the standard operating procedures binder. Write "how we deploy" once; every employee executes it the same way. When you improve the playbook, everyone improves at once.

Skills: the four playbooks every amux ships with — edit them, add your own, all agents inherit.

What is the Messages tab? — your chat history with each colleague

Definition: a server-side, searchable archive of every message ever sent to each session — direct sends and queued steering alike — identical from every device.

Analogy: your DM history with a coworker. "What exactly did I ask them last Tuesday?" is one search away, and clicking any past message copies it to reuse.

Messages: everything you ever told this agent, searchable, from any device.

What is the browser? — an assistant who already has the passwords

Definition: a shared automated browser (Playwright) with saved authentication profiles. Agents navigate, click, type, screenshot, and run whole tasks against real sites using logins you saved once.

Analogy: handing web chores to an assistant who's already on every account — pull the invoices, publish the post, check the ad dashboard. No API? Doesn't matter; they use the website like you would.

The browser: agents run real web workflows with the logins you saved once.

What is the Cost tab? — payroll and the budget report

Definition: a durable per-turn token ledger, priced per model into real dollars, rolled up by task, session, model, and day — with cache-hit rate as the efficiency signal. Derived entirely from transcripts and the board; no model calls.

Analogy: payroll plus the project budget report. Who cost what this week, which project cost what (task attribution via the board), which contractor tier (model) you used, and the trend by day. "This feature cost $4.20 across 37 turns" — finally answerable.

The Cost tab: dollars by task, session, model, and day — the budget report your agent team never used to have.

What are /standup and /handoff? — team rituals

Definition: two shipped skills that encode the two most useful team rituals. /standup compiles what every session did, what's in progress, what's stalled, and what needs you. /handoff packages one agent's goal, state, next step, and gotchas, then transfers the work (and the board item) to another agent.

Analogy: the morning standup and the shift change. You don't visit nine desks — the standup comes to you, leading with what needs your decision. And when work moves between agents, it moves like a good shift handoff: state on paper, nothing lost in someone's head.

/standup: nine desks, one report — leading with the single thing that needs your decision.

The rest of the map, briefly

Calendar = the team calendar. Real events agents can create; a private ICS feed your Google/Apple calendar subscribes to.
Notes = the wiki. Server-side markdown docs — meeting notes, runbooks, drafts — editable from any device.
Files = the shared drive. Browse any directory, preview anything (code, CSVs, PDFs, even EPUB/MOBI ebooks), with per-session scoped shortcuts.
Memory = institutional knowledge. Per-project facts injected into every session — new hires start onboarded.
People = the rolodex. A CRM of contacts and interactions that agents can read and update.
Workspace = the open-plan office. A grid of live terminals — every desk on one screen.
Metrics = the facilities dashboard. CPU, memory, and per-session resource health of the machine everyone works in.
Alerts = the fire alarm. Urgent owner notifications (push + iMessage) — provenance-stamped, deduped, and deliberately rare.

Where to start

Don't learn the whole map. Hire one agent (Sessions), give it one tracked task (Board), and redirect it once without interrupting (Steering). The rest of the surfaces will make themselves necessary the way office tools do — the first time you repeat an instruction, you'll want a Skill; the first time you wonder what the week cost, you'll open Cost.

Getting started guide → amux home →

FAQ

What is an amux session?

One AI agent in its own terminal with a working directory, model, live status, and token spend — the employee of the mental model. See sessions.

What's the difference between the board and steering?

The board is durable, tracked work (tickets). Steering is a transient note to one agent, delivered when it finishes its current task. Track projects on the board; nudge individuals with steering.

Why doesn't my queued message deliver immediately?

Because the agent isn't done — steering waits for a genuine turn boundary (no spinner, no running subagent, settled idle). Use direct Send to interrupt on purpose.

Do agents update the board themselves?

Yes — over the REST API, with atomic claiming and status gates (a code task can't be closed without acknowledging it merged).

Is the Cost tab an estimate?

It prices every real turn from your transcripts against a per-model price table — API-equivalent dollars. On a subscription plan it reads as "value consumed"; either way the by-task/by-session comparisons are exact.

Which agents does amux support?

Claude Code first-class, plus Codex and Gemini CLI sessions — skills and the dashboard work across all of them.