Every release.
Every file.

One command to code with a frontier model.

autobot code --model anthropic   # the first time: sets up Anthropic on your gateway, asks for the key
autobot                          # after that, in any git repository

• autobot code --model <provider>: if the gateway doesn't have that provider yet, Autobot sets it up on the spot. It asks for the key without showing it, adds the model with invincible cloud add, and restarts the gateway service.
• invincible cloud add and remove restart the gateway service themselves, but only the one that uses that configuration.
• autobot code remembers the model and approval mode in ~/.autobot/code.json.
• autobot with no command, inside a git repository, runs autobot code.

Easier upgrades, frontier models in one command, and steering the agent while it works.

• Steer while it works. While a turn runs, what you type shows under the spinner. Enter hands it to the agent before its next step; text that arrives just as the turn ends becomes the next request. Esc stops a turn.
• invincible cloud add deepseek|anthropic|openai|openrouter|custom
• Presets know each provider's API, a starting model, its context and its data policy.
• The key is read without being shown and kept in ~/.invincible/keys, readable only by you.
• egress = "never" becomes "ask" when you add the first cloud model.
• Also invincible cloud list and invincible cloud remove.
• Setup offers a cloud model. On a setup with only cloud models, that model becomes the agent's model, and agent work may use it. Re-running setup no longer offers a 15 GB download as the default.
• Re-running the installer upgrades.
• It replaces the binaries and restarts the running services on them.
• It keeps your setup; INVINCIBLE_SETUP=1 runs setup again.
• It reports upgraded 0.0.6 -> 0.0.7.
• Bigger coding jobs:
• Coding turns get at least 100 steps.
• A built-in read-only explorer takes research questions in a fresh context and answers with file:line references.
• Reads in one reply run at the same time.
• Token counts, including cached tokens, are shown per turn.
• Doctor:
• It waits for a model that is still loading.
• It counts cloud models and checks their keys.
• It explains a cloud-only gateway's routing.
• It never sends a test to a cloud model.
• 17 bug fixes from two reviews (one by a Claude reviewer, one by Autobot itself on DeepSeek):
• Approvals: text typed while the agent worked could answer a question, and a sentence containing an a meant "always". Typed-ahead text is now discarded, and any key other than y, a or n is no.
• /undo: files that were not UTF-8 were deleted instead of restored.
• @ attachments: @/path could attach files outside the project without asking.
• Config edits: a config that could not be read could be overwritten.
• Streaming: tool calls without an index were merged.
• Display: wide characters and tabs broke it, and the spinner wrapped.
• Diff counts: removed -- comment and --- lines were not counted.
• **Ct

autobot code: a coding agent in your terminal, built to work on real projects alongside Claude Code or opencode. Every model call goes through your own gateway, so it is receipted and recorded in the audit log.

cd ~/src/my-project
autobot code --model deepseek --approvals edits

• The terminal
• Answers stream in as Markdown.
• Each tool call is one line with a short result: ⏺ Run cargo test ⎿ … [exit code 0], ⏺ Search fn main ⎿ 3 matches in 2 files.
• Every change is shown as a colored diff before it's made.
• The agent's task list is drawn as checkboxes.
• A spinner shows what the model is thinking.
• Approvals take one key: y, a (always, for this session) or n.
• Ctrl+C stops a turn, and the conversation stays usable.
• The prompt has history and completion (slash commands and @ paths); Alt+Enter starts a new line.
• The project
• AGENTS.md, CLAUDE.md or .autobot/AGENTS.md are added to the agent's instructions.
• In a git repository it works like a careful engineer: it never commits unless asked.
• There is one conversation per project.
• New tools
• search: regular expressions over the files, respecting .gitignore.
• find_files: find files by glob.
• read_file can read long files in parts.
• todo: the agent's task list.
• Tool results grow with the model's context, up to 96 KiB.
• Control
• New approval mode, edits: changes inside the project run without asking; commands still ask.
• /undo puts back every file the last turn changed, takes the turn back, and returns its request for you to edit.
• @file attaches a file.
• !command runs a command yourself and passes its output to your next message.
• /model lists or switches models. Picking a cloud model allows cloud use, and the context sent per call grows to match.
• Also: /approvals, /private, /tools, /context, /diff, /fork, /resume, /status, /memory, /skills, /team, /board.
• Streaming: answers stream from the gateway, including streamed tool calls ([agent] stream, on by default).
• Driven by other tools: autobot run -C DIR --model M --approvals edits --cloud --json "task".
• --cloud approves cloud use for that run, and nothing else.
• --json prints every event as a JSON line: text, tool calls, outputs, diffs and receipts.
• **Trajectories

The Autobot Agent gets safer and steadier with nobody watching, easier to steer, and measurable on your own work.

New

• A sandbox for unattended commands. Scheduled tasks, board work and phone recipes can write only in the working directory and temporary folders: sandbox-exec on macOS, bubblewrap on Linux. With no sandbox available, those commands are refused rather than run unconfined.
• install.sh now installs bubblewrap on Linux.
• autobot doctor checks the sandbox works.
• [agent] sandbox = "always" confines every command, interactive ones too; "off" turns the sandbox off.
• Steer while it works. A message sent mid-turn, from Telegram or POST …/steer, is taken in before the next step.
• Heartbeat. The agent works through ~/.autobot/HEARTBEAT.md every 30 minutes and messages you only when something needs you.
• Fork a conversation: POST …/sessions/{id}/fork.
• autobot eval. Agent tasks run for real in throwaway directories and are checked by rule; evals/agent.jsonl and evals/agent-hard.jsonl are included. On this machine:

| Model | agent.jsonl | agent-hard.jsonl |
|---|---|---|
| Qwen3.5 4B | 16/16 | 8/10 |
| DeepSeek V3 | 16/16 | 10/10 |

• [agent] tools. Choose the agent's tool groups. A shorter list made Qwen3.5 4B twice as fast at the same pass rate.
• Team members keep their own memory.
• The team board in the app: see Autobot#10.

Install

curl -fsSL https://raw.githubusercontent.com/wckdboy/invincible/main/install.sh | sh

The Autobot Agent becomes a team, and gets the web, MCP and a scheduler of its own.

Fix

• write_file could leave a file empty in 0.0.3 (a write that was never flushed). If you use 0.0.3, update.

New in the Autobot Agent

• A team of agents. Define members in config.toml. Each has:
• its own instructions;
• the tool groups you give it;
• optionally its own model.

The agent hands them work with delegate:

• Several hand-offs in one reply run at the same time, up to [team] max_parallel.
• Each member starts fresh, with only the goal and context it was handed.
• Members can't delegate further.
• Their approvals come to you labelled [coder] Approve? …, and their receipts join the turn's.
• Teams on Telegram. In a group, the bot answers you when you @mention it or reply to it. Only you can press its approval buttons, and the rest of the group is ignored. A member with a bot of its own (telegram_token_file) posts its own progress and answers, so the team shows up as bots working together.
• Its own scheduler.
• schedule_task, list_schedules and cancel_schedule, including one-off times (in 10m, at 18:30). The answer comes back to the chat that asked.
• It never touches the system crontab.
• /cron, /actions, /memory and /skills in Telegram.
• web_fetch: a page as text, through the gateway.
• It follows the node's network mode: offline means no fetch, and Tor carries it when set.
• HTTPS only; receipted and in the audit log.
• It asks first; unattended runs may only fetch allowlisted https:// sites.
• MCP servers (stdio): their tools become the agent's, each call approved and logged. Unattended runs need mcp:<server>/<tool> in the allowlist.
• edit_file: replace an exact piece of a file.
• Context compaction: what leaves the context window is summarized through the gateway, with a receipt, not dropped.
• propose_skill: the agent writes down a procedure that worked. It's used only after you accept it, with autobot skills accept.
• search_sessions: find what was said or decided in earlier conversations.

Gateway

• POST /v1/fetch, loopback only (spec/receipts.md).
• Cron accepts CRON_TZ=UTC and once <time> schedules.
• Recipe schedules from the phone collect their runs with receipts (spec/agent.md).

Install

curl -fsSL https://raw.g

Invincible Gateway and the Autobot Agent, one install.

New

• Audit log (spec/audit.md). Every request the node answered is logged with:
• its signed receipt;
• when it was answered;
• who asked: local, or a paired device by name.

Each entry carries the hash of the one before it, so a removed or edited entry breaks the chain.

• invincible audit shows the log; --summary adds totals per model and per host reached; --verify checks the chain and every signature.
• Paired devices read it with GET /v1/audit.
• No telemetry: nothing about your requests leaves the node unless you send it.
• Agent action log. Every command, file write, outside read and cloud send the agent asked for is logged, with whether it ran and who decided: the rules, an earlier "always", or you on the CLI, the app or Telegram.
• autobot actions shows it, and the app reads it through GET /v1/agent/actions.
• Memory and skills.
• The agent keeps short facts with remember, and every later conversation starts with them. autobot memory lists them; --forget removes one.
• Skills are Markdown how-to notes in ~/.autobot/skills/, which the agent reads when one fits. autobot skills lists them.
• The app sees and manages both.
• Recipes from the phone. An Autobot recipe can run on your node: always on, no 8-minute limit, offered only its tool groups.
• The phone sends it in UTC (CRON_TZ=UTC is new in schedules), starts it with POST …/run, and collects each run's whole answer and receipt ids with GET …/runs?after=.
• Receipts older than the in-memory 4096 are found in the audit log.
• Evals (spec/evals.md): invincible eval runs a task file against models the gateway serves, local or cloud, and checks every answer by rule. Thinking models answer directly unless you pass --thinking.

Security fixes

These came from an internal adversarial review of remote access and the agent. It is not yet the independent review.

• invincible tunnel needs the machine's token and a loopback Host. Before, a web page open on the paired machine could reach the node through the tunnel as that device (cross-site requests, DNS rebinding). Update both machines and pass the token (invincible token) to whate

Full Changelog: https://github.com/wckdboy/invincible/compare/v0.0.1...v0.0.2

Full Changelog: https://github.com/wckdboy/invincible/commits/v0.0.1