oat-agents CLI
A Rust CLI where a meta-agent hands work to Claude Code and Codex, each on its own branch and tmux session, in one view.
- 61 ★ on the repository
- Last commit
- MIT
Broad access
Why this level
- Agents run without permission prompts and can reach anything your account can.
- Installation runs a script from the network and builds the program from source.
Install
- Works in
Manual install
curl -fsSL https://raw.githubusercontent.com/Noopher-AI/oat-agents/main/install.sh | shREADME command: builds the program, puts `oat-agents` in `~/.local/bin` and installs the `oat-agents-cli` skill.
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- Agents run without permission prompts and can reach anything your account can.
- Installation runs a script from the network and builds the program from source.
This is third-party code. Review the repository files before installing.
What it does
oat-agents runs a two-level team of coding agents: a meta-agent splits your goal into pieces and sends out members. A member is an ordinary Claude Code or Codex session in its own git worktree on branch `oat/<run>/<name>` and its own tmux session. `oat-agents tui` shows everyone on one screen with live, diff, timeline and log tabs, and `enter` types straight into the selected session. Team composition, roles and rules live in a plugin: `role.toml` sets the model, concurrency and skills, and `instructions.md` describes the role work. The `oat-agents-cli` skill installs with the program so your agent can explain and drive oat-agents.
Who it is for. People running five or more agents on one change who want to see each state and step into the right session.
Good fit when
- A large change is split into parts and a separate agent works each one on its own branch.
- The team needs roles such as a security auditor with its own model and instructions.
- One agent is stuck and you need to enter its session and type yourself.
- The same team has to be shared across several repositories as a plugin.
Not a fit when
- You need hard isolation: a worktree separates work but does not limit what an agent can reach.
- The machine has no `git` or `tmux`, both are required.
- One agent on a small edit is enough: team structure only adds steps.
Example request
Run the team on this goal: limit login to five attempts per minute per account, with tests, and open the team screen.Limitations
Agents run unattended, so oat-agents starts their CLIs with permission prompts turned off. A worktree separates edits by branch but does not limit access, so run it only on a machine and with credentials you would trust an agent with. Building needs Rust 1.85 or newer, `git` and `tmux`, plus an installed and logged-in Claude Code or Codex. A role with `exec_environment = true` runs builds and tests in a pod built from `.devcontainer/`, supported only for Kubernetes today. A team plugin must be approved once with `plugin trust`.
How to disable. Stop the Run, delete the `oat/<run>/...` branches and worktrees. Remove the program from `~/.local/bin` and the state from `~/.local/state/oat-agents/`.
FAQ
Which agents are supported?
Claude Code and Codex. The backend is chosen per role, so one team can mix both. A Codex meta-agent starts with the `--agent codex` flag.
Where is run state stored?
In branches, tmux sessions and plain files under `~/.local/state/oat-agents/`. The workflow log is a JSONL file you can read with `tail -f`, `jq` or `grep`. There is no server or database.
How do I write my own team?
Create a plugin with `oat-plugin.toml` and a `roles/<role>/` folder holding `role.toml` and `instructions.md`, pin it with `oat-agents init --force --embedded --path team my-team` and trust it.
What must be installed first?
`git`, `tmux`, Rust 1.85 or newer for the build, and Claude Code or Codex already logged in.
How do I step into an agent work?
In `oat-agents tui` the `↑↓` keys pick an agent, `←→` switch tabs, `enter` types into its session and `ctrl+]` gives the keys back.
Discussion
No questions or reviews yet.
Related
CLI toolsA tmux-based TUI that runs Claude Code, Codex and other agents in one list: status, quick prompts, worktrees and diff review
multi-agents runs a team of coding agents on a task and measures whether it beat a single agent and what it cost.
A Rust terminal task board: every task runs in its own git worktree and tmux window while Claude Code, Codex, Gemini CLI and other agents work in parallel
Octomind is a coding agent in one Rust binary: safety rules in TOML instead of approval prompts, with a supervisor model on top
OpenRig
openrig
A CLI for persistent teams of Claude Code and Codex agents: the team is described in YAML and started with one command, with roles and monitoring
A local dashboard for many Claude Code sessions: each job gets its own context and todo, agents spawn child agents and message each other
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Repository stars | Main difference |
|---|---|---|---|
| oat-agents (this card) | no | 61 | |
| Claude Squad | no | 8,790 | runs parallel sessions with no roles; oat-agents adds a meta-agent, plugin roles and a run log |
| Agent Deck | no | 1,252 | a manager of agent session lists; oat-agents itself hands tasks to members per the meta-agent plan |
README in short
The structure has two levels with no server or daemon: a Run consists of branches, tmux sessions and files. Agents need not keep notes for a human, the program itself writes the workflow log.