Features

Everything Codealong does, and how.

One Mac app over every coding agent you run. It sends new work where it belongs, lets you answer any agent from wherever you are, and keeps each one running in the harness it was built for.

● Routing

How routing works.

One front door for every harness and every account. It routes the work, not the API calls: no proxy, no API keys. Your prompt reaches the same harness, on the same plan, as if you’d typed it there yourself.

The quick panel: a typed prompt, with Jev suggesting to send it to the session already load-testing the limiter.

⌥⌘/ from any app, even over full-screen ones.

How the prompt gets there

  • Claude Code in a terminaltyped into its own Ghostty, iTerm2, Terminal or tmux tab
  • Claude Code background jobthrough Claude Code’s background service
  • Claude appas a message from another session
  • Codex appa new turn, started by Codex itself
  • OpenCodethrough its own service
  • A stopped sessionresumed with your prompt, in the place you pick
  • A session on another Macthrough that Mac’s Codealong, when it allows remote control
  1. Say it once.

    ⌥⌘/ opens the quick panel over any app. With nothing typed, it lists what needs you, then finished turns, then the todos ready to start.

  2. Jev finds where it goes.

    Once you pause, Jev weighs what you typed against every running session and worktree and suggests up to three places, each with how likely it is. ⏎ takes the first, and the next is one ↓ away. If a running agent may already be doing the work, the start row says so.

  3. Auto picks the account.

    Starred accounts first, while they have room. An account at 90% of a limit it would spend has none. Of the rest, the one whose week resets soonest, so no week’s room goes unused. When a model’s own week runs low, it starts on Opus, then Sonnet.

  4. It goes in the way that harness takes it.

    Typed into the agent’s own tab, sent through its service, or started as a new turn in its app. A session waiting on your approval is opened instead, so what you typed can’t answer its prompt by accident.

The Worktrees view: eleven worktrees on two Macs, sorted into Needs you, Working, Your turn and In review, with plan usage for every account across the top.
91% · passed overAuto starts here
Every account’s limits in one bar: the 5-hour window, the week and per-model limits like Fable, with the time until each resets. Here claude is at 91% for the week, so Auto starts new work on claude-work.

● Answering

Answer any agent without leaving what you’re doing.

A session kept on the desktop, waiting to run git push: Deny, Always and Allow are on screen.
  • Allow, Always or Deny.

    Or deny it and say what to do instead, in the same keystroke, and the turn keeps going.

  • Nothing to switch on.

    Claude Code’s own prompt stays up too, and whichever answer comes first wins. With Codealong closed, your agents ask you the usual way.

  • Only you approve.

    Agents can see what another agent waits on, and can deny it. Only you can allow it.

Approvals and questions are answered for Claude Code (in its terminal tab, as a background job, or as a subagent), OpenCode, and any agent you run in Codealong. Codex, Cursor and Antigravity sessions show what they’re waiting on and open where they ask. What works with each harness →

● Status

It reads every turn, so you don’t have to.

Once per turn, Jev reads the end of the last reply and the command a session runs or waits on. The board then says what you’d have opened the session to find out.

The Worktrees view: worktrees sorted into Needs you, Working, Your turn and In review, each session with what it waits on and how far its work got.
risk
The Worktrees view: worktrees sorted into Needs you, Working, Your turn and In review, each session with what it waits on and how far its work got.
asks youhow far it got
The Worktrees view: worktrees sorted into Needs you, Working, Your turn and In review, each session with what it waits on and how far its work got.
looks finishedlanded in main
  • It asks you something

    A reply that ends on a question moves the session to Needs you, and the row shows the question.

  • It waits for approval

    The command it wants to run is rated for risk, from reads only up to destructive.

  • How far the work got

    Each finished turn is marked Landed, Pushed, Committed or Not committed, so you know what’s left without opening the session.

  • Slow isn’t stuck

    A long build or a job left polling in the background stays Working. A session that goes quiet in the middle of a turn is marked stuck.

  • Looks finished

    A worktree whose sessions all read as done says so, ready to clean up.

Jev is TypeSafe’s small, fast model. It’s optional. Each Jev feature is off until you switch it on in Settings, and each switch says what it sends. Answers are kept, so a turn is only ever asked about once. Without Jev, sessions are still sorted by what their harness reports.

● Every Mac

Start it on the Studio. Answer it from the laptop.

Link your Macs once. Each one shows the others’ worktrees and sessions beside its own, and says which Mac each one is on. Read a conversation running on another Mac, send it a message, answer its approval or start work there.

A session running on the Mac Studio, open on the MacBook Pro: its conversation, an On Mac Studio chip, and a box to send it a message.
  • Peer to peer.

    Your Macs find each other on your tailnet, or reach each other anywhere through iroh. They talk directly, encrypted end to end. There’s no Codealong server in the middle.

  • Link once.

    On your tailnet, both Macs show the same six digits and you say yes on the other one. Anywhere else, enter a link code from one Mac on the other.

  • You decide what reaches in.

    Remote control is off until you turn it on at that Mac. Once it’s on, your linked Macs can send prompts, answer approvals and start sessions there, and every request goes into a log.

  • Asleep isn’t gone.

    A Mac that’s asleep or offline keeps its place on the board, showing its work as it was when you last saw it.

● Codealong for iPhone

Your agents, in your pocket.

Read any session on any of your Macs, and when one asks, answer it from the couch. It’s the same queue as the Mac: answer one and the next that waits on you is a tap away.

  • Every Mac, one list.

    Sessions from each of your Macs, in the order the Mac shows them: what needs you first, then finished turns.

  • Answer from anywhere.

    Allow or deny a call, answer its questions, reply, stop a turn, or start new work on the Mac, worktree and account you pick.

  • Peer to peer.

    The phone links to your Macs the way they link to each other, end to end encrypted. No Codealong server, no account.

  • Free and open source, like the rest.

    Other tools put their phone app on a paid plan. Codealong’s is free, Apache 2.0, with every feature.

It’s early: for now you install it from source with Xcode, and there are no notifications yet. A phone acts on a Mac only where that Mac has remote control on, and every action is logged there. Questions

Codealong for iPhone: the sessions on both Macs that need you, then finished turns, and a box to start new work on a Mac.
Codealong for iPhone, on a session that wants to run git push: Deny, Always allow and Allow.

● Todos

Todos that know which agent is on them.

Write the work down once. When you hand it to an agent, the todo stays linked to that agent until it’s done.

  • Start session hands it over.

    The todo becomes the agent’s prompt, on the account Auto picks, and the session is linked to it. The todo moves to In progress and shows its agents live.

  • Waiting is a state, not a guess.

    A todo can wait on other todos. It can also wait on something outside the list, like an auditor’s template, and stays under Waiting until that turns up.

  • Done when you say so.

    When a todo’s session lands the work or its PR merges, Jev marks it Looks done. You decide if it is.

  • One owner per todo.

    The first session on a todo is its primary one. A second agent started on it is told to send its findings there, instead of redoing the work.

The Todo view: todos in progress with the agents working on them, ready todos, and todos waiting on others.

● Canvas

Remember work by where it is.

Lists sort by time. A canvas lets you put things somewhere. Every repo gets a frame and every worktree a column, and each session, todo and PR is a card you can pick up and move.

The Canvas view: a frame per repo, a column per worktree, with session, todo and PR cards.
The canvas zoomed out: every card becomes a block in its status color.

Halyard’s canvas: a frame per repo, a column per worktree, and the todos with no worktree yet on the side.

  • Tidy lays it out once.

    A column per worktree, a frame per repo or per day, with its sessions, todos and PRs under it. You choose what it holds: sessions from the last hour to the last week, open todos, your PRs.

  • New work finds its place.

    A new prompt, a finished turn or a question for you brings a card onto the canvas beside what it belongs to. Nothing leaves by itself.

  • Every card is the real thing.

    Hover for the rest. Select one for its panel, where a session shows its whole conversation and takes messages. Double-click to open it where it lives.

  • Controls you already know.

    Scroll or Space-drag to pan, pinch to zoom, ⇧1 to fit. Add notes and frames of your own; a frame carries what’s in it.

● Pull requests

Every PR, with the agents behind it.

The PRs view joins each pull request to the worktree that holds it and the exact sessions that made it, pushed to it or commented on it, on any harness and any Mac.

The Worktrees view: worktrees sorted into Needs you, Working, Your turn and In review, each session with what it waits on and how far its work got.
  • GitHub’s merge box, built in.

    Merge, squash or rebase, auto-merge, the merge queue, updating the branch. A merge is refused if the branch moved since you looked.

  • Reviews wait in the same queue.

    PRs waiting on your review sit beside the agents that need you. Approve, comment or request changes from the notch or the Waiting window.

  • Hand a review to an agent.

    Review with… starts a review session on the account Auto picks, or let Codealong start one for every PR that asks for your review. Ask puts private questions about the diff to an agent.

  • Agents hear what happens.

    Turn on nudges for a PR and the sessions that worked on it are told about new reviews, requested changes, failing checks and the merge.

GitHub is read through your own gh sign-in. Codealong never handles a token.

● For agents

Your agents can read the board too.

The codealong command and its skill give every agent the same view you have. An agent can see what the others did in this repo, pick the next ready todo, and check which account has room, and it prints JSON when it’s piped.

Claude Code

Add the repo as a plugin marketplace. You get the command, the skill, and a hook that tells each new session who it is.

/plugin marketplace add codealong/codealong
/plugin install codealong@codealong

Every harness

Settings › Agents installs the command and the skill into every account: Claude Code, Codex, OpenCode and Antigravity. It keeps the copies current and leaves alone any you’ve edited.

codealong install
Reads the agents you already run
  • Claude Code CLI
  • Claude app
  • Codex CLI and app
  • OpenCode CLI
  • Antigravity app
  • Cursor app and CLI

● Native harnesses

Keep the harnesses. Lose the mess.

The harness is half the result.

A model is only as good as the loop around it: the tools it can call, the prompts it runs on, how it keeps its context, what it asks before it acts. Anthropic builds Claude Code for Claude. OpenAI builds Codex for its models. Both change every week.

Put every model behind one interface and you give most of that up. Codealong doesn’t wrap anything. It reads the files each harness already writes, and when you open a session, it opens where it lives.

An SDK or chat wrapperCodealong
Tools, prompts and contextIts own, shared by every modelThe vendor’s, tuned for its model
New featuresOnce the wrapper adds themThe day the vendor ships them
AccountsWhatever the wrapper supportsEvery subscription you already pay for
Where you workInside the wrapperGhostty, the Claude app, Codex, Cursor

Open where it lives

Double-click a row or press ⏎. Codealong takes you to the session itself, not to a copy of it.

  • Claude Code or Codex in a terminalIts own Ghostty, iTerm2 or Terminal tab, brought forward, even on another screen
  • A Claude app sessionThe Claude app, on that conversation
  • A Codex app threadThe Codex app, on that thread
  • OpenCodeIts terminal, or resumed in a new one
  • Antigravity or CursorBrought forward in its own window
  • The worktreeYour editor, or a new terminal tab beside it

● Harnesses

What works with each harness.

Codealong reads what every harness already writes, so it sees all of them. What it can do from there depends on what each harness lets another program do. Where it can’t act, it opens the session where it lives.

HarnessSees itSends promptsAnswers approvalsStarts sessionsSeveral accountsUsage limits
Claude Codein a terminalTypes into its tab5-hour, weekly, per model
Claude Codebackground jobsIts background service5-hour, weekly, per model
Claude appAs a message from another sessionOpens the appOpens it with the promptIts signed-in accountShared with Claude Code
CodexCLITypes into its tabIn its terminal5-hour, weekly
Codex appStarts a new turnIn the appIts signed-in account5-hour, weekly
OpenCodeIts own service—You bring the provider
AntigravityOpens it, prompt on the clipboardIn the appIn its own window—Shown in the app
Cursornewcursor-agent in a terminal; app chats get the prompt on the clipboardIn Cursorcursor-agent——
In CodealongClaude Code, Codex or OpenCodePer account

Terminals: Ghostty (exact tab, keypresses, tabs beside their worktree), iTerm2 and tmux (typing and keypresses), and Terminal (typing). Approvals for Claude Code go through Codealong’s plugin, which Settings › Agents installs into each account. In Codealong means the agent runs in Codealong’s own panel, over the Agent Client Protocol.

Run every agent.
Know where each one is.

Free and open source under Apache 2.0. macOS 13 or later.