Changelog

A script, a CI hook or another iota can now send a running chat a message: iota resume <id> -m "…" on a session that is open elsewhere — and iota run <bot> -m "…" on a bot that is running — hands the message to that chat instead of refusing, and prints one line saying what became of it. A provider's rate limit or usage cap no longer turns into an endless loop: finished background jobs stop starting new attempts, iota tries again on its own later, and Esc holds the work queued behind the turn you stopped.

A reply that breaks after it is on screen is no longer sent again — up to ten times, each retry printing the same answer. Now the failure is shown once and what arrived is kept. And tool_timeout_sec: 0 is refused when a run that uses the server starts, where it used to time out every call to that server the moment it was made.

/tools is now one list — the tools iota ships with, then each MCP server, with its tool count and how it stands — and Enter opens a page for one of them, from which a server can be reconnected without leaving the chat. When a server does fail, the notice says what went wrong and what to check instead of quoting the library. A server that dies mid-session is shown as stopped, and a tool call it never answers no longer holds the turn forever.

You can now tell at a glance that a turn is still going. The status row stays busy from the moment you send a message until the turn is over, says what the turn is doing, and keeps one clock for all of it. Which tool is running, and for how long, stays on the tool's own line. And a tool call the model writes more text after no longer runs with nothing on screen.

/new starts a fresh session in the chat you are in: the one you leave stays on disk, the new one keeps the model and everything else the chat runs under, and a dim line marks where it begins. An agent that writes no choices: is now offered its own model: alone in /model, no longer every models: entry — if you relied on the old list, write it out (below). /model rows lose their (moves the chat) annotation, a compaction in progress shows in the transcript instead of the status row, and /session now opens a session with the settings iota resume would give it.

A chat is no longer tied to the provider it started on. Pick a row on another endpoint in /model and the chat moves there — at once before the first reply, after you agree once a reply exists — and iota resume <id> -M now moves a session for good. To make that possible, a session records the providers: entry it runs on by name, and sessions written by earlier versions are no longer read until you convert them once (below). The Anthropic dialect asks for up to 32000 output tokens instead of 4096, a new max_tokens: key sets that ceiling, and an output the ceiling cut off is shown as an error instead of being passed off as the answer.

A small release. /status gains three rows — the version, the mode and the session's title. The Linux binaries now run on glibc 2.28, so RHEL 8, Debian 11 and Ubuntu 20.04 join in, and the shell installer no longer turns away the RHEL 9 family and Amazon Linux 2023, where the binary always ran. And on Windows, every local time iota showed or sent — the date an agent is told is today among them — was UTC; it is local now.

A third mode, bot: one conversation that never ends. iota run <name> opens it wherever you left it — no /new, no picker, no resume — with a plain Markdown memory beside it that the model writes, you can edit, and every request carries; when the context fills, the bot saves what matters and compacts by itself. workspace: true becomes mode: agent, with no compatibility: a config that still says workspace: fails to load until you change it. Elsewhere, Ctrl+J puts a newline in the composer, a provider that stops sending fails after 300 seconds instead of hanging the turn, and closing the terminal no longer loses the turn in progress.

An MCP server whose tool schema escapes a character needlessly — exa's agent_run does — no longer makes a strict provider such as DeepSeek refuse every request; iota reads the schema the way the standard does and leaves the rest as the server wrote it. Two fixes to jobs ride along: a job's page reads its log off the loop that draws the screen, and the host no longer shows iota idle while a job's end is still to be taken.

Two fixes to 0.5.0: the last lines of a reply printed while the window was being made narrower no longer disappear when the drag ends, and two jobs changing at nearly the same moment no longer leave /jobs, the status row or the host on a set that is not the one running.

Long commands stop holding the turn. A shell call that is still running after 20 seconds carries on as a background job, /jobs lists the jobs live — their pages, their clocks, a Kill tab — and the status row shows what is running. A call has no deadline unless it sets one. The terminal side is iota's own now: a resize while a reply streams loses no line, large updates appear in one piece, and the banner is a card.

iota tells its terminal what it is doing, and the config says which model a chat starts on. Inside a herdr pane the chat is listed from the moment it is up — working, blocked, idle, released on exit — and the host is named in the harness prompt and on the banner. An agent now writes model: for the model it starts on and choices: for what /model and -M offer, a breaking change to the config file. The startup banner is a logo and three facts.

The model knows where it is. Every agent with tools now sends a built-in harness paragraph ahead of its own prompt — who it runs inside, what the machine looks like, and how iota's own command line is driven — and iota itself runs outside the shell sandbox, so a child agent or an iota mcp add from the chat just works. A first run writes the starter config; add --url logs in on the spot; /mcp leaves the chat; the reference moves to iota.sh.

MCP servers are managed from the command line and logged in to. iota mcp add|list|get|remove edits the mcp_servers: block of one file; a server behind OAuth 2.1 is one iota mcp login <name> signs in to — the client identified three ways, the consent prompt asked for, auth discovered from the server's own 401 — the shape one Logto tenant taught, a finding at a time.

The tree is native now. Nineteen refactoring steps took the port from a module-by-module translation to a Rust shape of its own — a layered module tree that a test pins, one editing core, typed errors instead of strings, an enum where a bag of flags used to be — with every step green on all three platforms and every user-visible text byte-identical. What you can see is below; the rest is in docs/ARCHITECTURE.md.

A fix release. Three of the fixes are about a token count that read 0, or a request that read 400, against endpoints that speak a dialect almost right. They were found the same way: one prompt sent through every provider in a real config, and the bytes on the wire read back.

Four parameters — context_window, effort, temperature and top_p — were read once, when a session started, and never looked at again. They now resolve from layers, at every moment that can change the answer. The rule is one sentence: when the config speaks the config decides; when the config is silent your hand-set value stands.

The first tagged release of iota as a Rust binary. It is an agent CLI: you configure agents — a model, a prompt, a set of tools — and run them. If you used the Go build, this is the list of things that changed under you.