Aude Code
AUDE-TEAM(7) Miscellaneous Information Manual AUDE-TEAM(7)

aude-team — a team of aude sessions

This page is for a model that delegates to subagents of aude(1). The page expects that your tool runs each command in a new shell, with no standard input, and stops it after a time.

  • A subagent has a name, a record and a transcript. They stay after its host exits, so the name stays valid until remove.
  • A listing tells the state of the work: waiting, working, done or failed.
  • Only wait blocks, for at most --limit. Each other command returns at once.
  • The budget of a turn and the limit of a wait are two different times. Give each turn a long budget with start or send. Give each wait a short limit, less than the time your tool allows a command.

start name makes a git worktree .aude/worktrees/<name> in the repository, ignored by git, on the branch name. remove removes them. A session that a person started is not a subagent, and wait with no target does not wait for it.

The host of a subagent runs while the subagent has a turn, and exits after the last turn. The next send starts a new host that continues the conversation. A turn that you send while a turn runs waits in a queue, and does not use its budget while it waits. When the budget ends, the host interrupts the turn as interrupt does: exit 9, and the subagent is failed.

The model commits only when the task tells it to, and git-merge(1) takes only commits. So tell each subagent to commit its work.

attach prints the whole last turn. For a short answer, give each subagent the absolute path of a report file under .aude in the repository, which git ignores, and read that file.

know if it is done with a short limit; exit 9 is not yet
know if it is stuck ; quiet= grows over two waits on a working listing
read what it did ; commits= and dirty= on the listing
interrupt the turn
change the direction , then send
give more work ; the turn runs after the current one
continue a finished subagent
build on other subagents --on
see the team
clean up

Three modules are stubs, and the tests exist. Each task file tells the subagent to commit.

aude start tokenize --harness claude --budget 15m </path/to/tasks/tokenize.md
aude start count    --harness claude --budget 15m </path/to/tasks/count.md
aude start report   --harness claude --budget 15m </path/to/tasks/report.md
aude wait --limit 90s              # exit 9: not yet, so run it again
echo 'Also add a module docstring, and commit.' |
  aude send tokenize --budget 5m
aude wait tokenize --limit 90s
aude attach count                  # the last turn of count
git merge tokenize count report
python3 -m unittest discover -s tests
aude remove tokenize count report

After remove, the next run can use the same names.

To build ‘report’ on the two others:

aude start report --harness claude --budget 15m --on tokenize count \
  </path/to/tasks/report.md

‘report’ waits. When ‘tokenize’ and ‘count’ are done, its host merges them and runs its task.

Exit 0 tells that a turn had no error. It does not tell that the task is correct. Read ‘commits=’, ‘dirty=’ and the last answer, and run the tests.

  • A turn with an error: failed, exit 1. sessions --json shows the error.
  • A turn that the budget or interrupt ended: failed, exit 9. Its edits stay in the worktree.
  • A host that stopped: the listing shows failed and ‘exit=5’. send starts a new host.
  • A host that cannot start: start or send itself exits 3, 4 or 5 with one line.
  • With --on: exit 1 when a named subagent failed, 8 when one was removed, and 64 for a merge conflict. No turn runs. An interrupt of a named subagent also makes it fail. Fix the named subagent, then send the task again: the host merges first, then runs it.
  • of a working subagent, a worktree with uncommitted or untracked files, or a branch that is not merged: exit 64, and nothing is removed. Put build output in .gitignore.

After a failed turn, the next queued turn runs, or send gives a new turn.

aude(1), git-merge(1), git-worktree(1)

A subagent name has only lower-case letters, digits and hyphens, and the branch has the same name, so it cannot be ‘feat/<name>’.

To abandon a failed subagent, clean its worktree or delete its branch with git, then run remove.

A waiting subagent cannot be interrupted or removed until its --on subagents are done or failed.

start needs a git repository.

A subagent runs at the top level of its worktree, so --agent on start names an agent file that is committed there.

October 20, 2026 aude