Interactive TUI

The TUI is where you work through a task with Ante: ask a question, add context, review proposed changes, and guide the next step.

Open a terminal in your project and run:

cd your-project
ante

If this is your first session, connect a provider before sending a prompt.

Explore an unfamiliar project

Start with a question that gives Ante a clear place to look:

Explain how this project starts up. Find the main entry point
and trace how a request reaches the database.

Type your message and press Enter. Ante streams its response and shows the files and commands it uses along the way. Follow up in the same conversation to narrow the investigation.

To point at a particular file, type @ and select it from the completion menu:

Explain @src/main.rs and show which modules it depends on.

You can also mention a folder, paste a screenshot, or include a URL. See Providing Context for those workflows.

Make a change and review it

Give Ante a concrete outcome and any constraints:

Add a clear error message when the config file is missing.
Keep the existing CLI behavior, and run the relevant tests.

1. Clarify the task. If Ante asks a question, choose an option or use Chat about this to explain what you want.
2. Review requested actions. When a tool needs approval, press Tab to inspect its proposed diff or command details. Approve it, reject it, or reject with feedback about what to do differently.
3. Inspect the result. After the turn, run /diff to review the working-tree changes, including untracked files. Ask Ante to adjust anything that needs another pass.
4. Check the outcome. Ask it to run the relevant checks and explain any failures before you wrap up.

The Approvals guide walks through permission choices and session grants.

Answer a clarifying question

When Ante needs your input, it can present a question with selectable answers directly in the TUI. Read the options, use the arrow keys to choose, and press Enter. Choose Type something or Chat about this when you want to give your own answer or discuss the decision.

Look into the details

Press Ctrl+O to open the full transcript, including expanded tool output and reasoning hidden in the main conversation. Scroll with j / k or PgUp / PgDn, then press Ctrl+O or q to return to chat.

Change direction while Ante works

If the task needs another constraint, type it and press Enter while Ante is running:

Also handle an empty config file, and reuse the existing error type.

The message joins a queue. Press Ctrl+S to send that guidance into the running turn, or leave it queued for the next turn.

To stop the current approach, press Escape when no popup is open, or Ctrl+C. Then send a corrected prompt; the conversation keeps its context. See Interrupting & Steering for examples.

Revise an earlier prompt

Run /rewind, or press Esc twice quickly with an empty composer and no popup open. The picker lists inputs that can still be restored, newest first. Use the arrow keys to choose, Enter to confirm, or Esc to cancel.

Ante restores the current conversation to just before the selected input, removes that input and the conversation after it, and puts the prompt text back in the composer for editing. Press Enter after editing to start a new turn.

Rewind changes the conversation and model context; it does not undo file edits, shell commands, or other external actions. Finish or interrupt the active turn, resolve queued inputs, clear any goal with /goal clear, and wait for background jobs to finish before rewinding. Session saving must be enabled. Reachable inputs survive a resume and are carried into forks, so you can also choose prompts from a previous run or copied from the parent. A successful compaction that replaces history, or a provider switch, makes earlier cut points unavailable; a failed compaction preserves them.

Fork a conversation

Run /fork to save an independent conversation and switch to it. Choose (end of conversation) to keep everything, or choose a reachable input to branch from just before it and put its prompt text back in the composer. Press Enter to confirm or Esc to cancel.

The original session stays unchanged. The new session names its source session ID below the header; use /resume to return to the parent. Forking requires session saving, no running or queued turn, and no active goal. Input cuts share rewind's restore boundaries; you can still fork the whole conversation when no input is in reach. Forking saves and switches conversations without creating a Git branch or separate working directory, and starts no new task by itself.

To keep the parent open and put the child beside it, select a row in /fork and press s. Ante opens the saved child in a terminal split, with the selected prompt ready to edit and send. Choosing (end of conversation) opens the child with an empty composer. Both sessions use the same working directory, so coordinate any file edits between them.

The split needs tmux and uses the same launchers as /term: tmux, iTerm2, WezTerm, Kitty, or Ghostty. If the launcher fails, the child remains saved; use the printed ante --resume <SESSION_ID> command to open it manually. See terminal sessions for attaching and detaching the viewer, or branch in another terminal for other agent CLIs.

Run a command yourself

Start a message with ! to run a shell command directly:

!git status
!cargo test

The command's output becomes context for your next message. Follow up with Explain this failure and fix its cause. to work from the result you just saw.

These commands run immediately under your authorization. For interactive programs, use a terminal session instead.

Check on background jobs

Ask Ante to run a long command in the background, such as a build or a test suite, and keep working while it runs. The footer shows N bg jobs. With the composer empty, press ↓ to select it (below the sub-agent list, if one is showing) and Enter to see each command's status, runtime, and latest output. ← goes back to the list and Esc closes it. Ante is notified when each job finishes.

Orchestrate agents with /term

/term opens a terminal that both you and Ante can drive. Use it to work with another Ante instance, Claude Code, Codex, a development server, or a REPL. You can give instructions in your main conversation, watch the other program work, and step in to type directly whenever you need to.

Open an agent and give it a task

With tmux installed, type this inside Ante:

/term ante

A new terminal session starts another Ante instance in a split or window. Back in the main conversation, try:

In the ante terminal, ask the other agent to review the current diff.
Read its findings and tell me which issues we should address.

Ante sends the task, reads the other agent's output, and can follow up while you watch. This demo shows it opening another Ante session, asking a question, reading the answer, and detaching the viewer:

Use /term claude or /term codex for those installed CLIs. Ask Ante to give each agent the same problem and compare their answers, or assign different parts of a task to separate sessions. Each terminal keeps its own conversation, and you can interact with it directly to answer questions or guide the work.

Explore in another terminal

To explore another direction from a saved Claude Code or Codex conversation, open a fresh named terminal:

/term review

Choose one of these commands to run in that terminal, depending on the installed agent:

# Fork the most recent Claude Code conversation in this directory
claude --continue --fork-session

# Fork the most recent Codex conversation
codex fork --last

The agent's native fork command carries its saved conversation into a new session. To work in parallel with your current Ante conversation, ask Ante to start another named session with an explicit handoff:

Start another Ante session named edge-cases. Give it our task,
constraints, and findings so far. Have it investigate edge cases
while we continue with the implementation here.

Then open /term edge-cases to watch or join that conversation. The handoff supplies the new agent's context; each session has its own history.

Keep interactive subagents available

Run /term to list live sessions and attach to the one you need. Running /term <name> again detaches its viewer while the program keeps running. Terminal sessions survive the main Ante exiting or restarting, so a later conversation can reconnect and continue coordinating them while the tmux server is still running.

Opening an existing session attaches to its running program; launch arguments only apply when creating a session. For another agent or conversation branch, use a fresh session name and ask Ante to launch the program there. Stop sessions through the /term picker when their work is finished.

The same flow works for a development server, REPL, or other interactive tool. See terminal controls for launch options, supported terminal apps, and session management, or Sub-Agents for delegation through the built-in Agent tool.

Choose a model for the next step

Use /models to change the model or effort level on your current provider. Use /providers when you want to switch providers, then confirm the model in its picker.

For example, you might use one model to explore the code, then select another for a difficult debugging step in the same conversation. See Models & Effort for the selection flow.

Check session usage

Run /usage to see token counts by model, cache use, and turn counts. Supported subscriptions also show quota information. Use this to understand the session's usage; your provider's dashboard remains the billing record.

Continue a longer task

For a task with a clear finish line, set a goal:

/goal all tests pass and cargo clippy reports no warnings

Ante continues checking progress against that condition. Use /goal to inspect it and /goal clear to end the loop. See Goal Sessions for how completion and interruptions work.

If the conversation gets long, run /context to inspect its size. Use /compact focus on the remaining test failures to summarize older work while preserving the thread you need next.

Name the work

Give the conversation a recognizable title before leaving:

/rename config error handling

The title appears in the resume picker and terminal tab.

Pick up where you left off

With session saving enabled (the default), you can exit with /exit and return later:

1. Run ante from the same project directory.
2. Type /resume and find the conversation by its title or first message.
3. Press Enter, then send your next instruction.

Ante restores the saved conversation and uses your current permission settings. You can also run ante --resume (or ante -r) to open the picker directly, or ante --resume <SESSION_ID> to choose a session by ID. If the current directory has no saved sessions, bare --resume exits with a message. Sessions started with --no-session-save aren't available to resume.

The picker lists sessions by last use. Resuming inside the TUI opens a fresh screen with the selected session's header and history. Saved system prompts and prompt mode are preserved; current prompt flags apply only to fresh sessions. If the local date, OS, or shell changed, Ante tells the model once on its next turn.

Continue work from Claude Code or Codex

Use /resume-claude or /resume-codex to pick up a recent conversation from the current project. These bundled skills read the previous transcript, reconstruct the task and progress, and confirm the next step with you before continuing. Add a session ID to choose a specific conversation.

Make the terminal comfortable

Run /config to adjust preferences, or /theme to pick a theme. If your terminal loses inline scrollback, launch with ante --fullscreen or change Render mode in /config.

For individual commands and controls, see Slash Commands, keyboard shortcuts, and the TUI Reference.