Skip to content

Releases

agent86 v1.1.0

Choose a tag to compare

@github-actions github-actions released this 19 Nov 18:14
9ffb344

agent86 is now also a Rust library. agent86-core is the agent behind the CLI, published on crates.io, and its sdk module builds an agent inside your own program with the same workspace jail, approvals, sandbox, guardrails, and secret redaction the CLI has. The CLI itself is unchanged from 1.0.24.

The library

cargo add agent86-core
  • Agent::builder() takes a provider, a workspace, and whatever else you hand it, and reads nothing else: no config file, environment variable, home directory, keyring, or terminal.
  • Least authority by default. No built-in tools unless you ask for them (Builtins::ReadOnly, Files, or All). Side-effecting calls go to your approver closure, with the same preview and diff the terminal shows; with no approver they are declined, as in a piped agent86 run.
  • Your own tools from a closure and a JSON Schema (FnTool), or by implementing the Tool trait. Providers for OpenAI-compatible servers, Anthropic, Google, and Ollama are included, and Provider is a trait you can implement.
  • Everything else on request: MCP servers (values taken literally, never expanded from your environment), long-term memory and resumable sessions in the CLI's own database format, skills, sub-agents and your own specialists (in parallel or in git worktrees), named models with triage routing, OpenTelemetry spans, and callbacks for the questions a turn asks mid-way: raising a limit it reached, or a secret the model needs.
  • Conversations save to and load from JSON (Conversation::to_json), the same JSON the CLI's sessions keep.
  • A lighter build with default-features = false, which leaves out the OS keyring and the local embedding model: about 170 dependencies instead of 370.

The crate's README has an example, examples/embed.rs runs against any OpenAI-compatible endpoint, and ADR 0003 explains the design.

Stability

Only agent86_core::sdk is covered by semantic versioning. The crate's other modules are public because the agent86 binary is built on them; they are hidden from the documentation and may change in any release. The library and the CLI share one version number.

The CLI

Nothing changes for CLI users: the interface, run and run --json, the ACP server, the config files, and the session, trace, and keyring formats are as they were in 1.0.24. Under the hood the repository is now a Cargo workspace of two crates, the library and the binary built on it.

The minimum supported Rust version is still 1.94.

agent86 v1.0.24

Choose a tag to compare

@github-actions github-actions released this 17 Nov 21:32
6627c28

agent86 now runs on Google's Gemini models, on vLLM servers, and on LM Studio, each with its own provider, and /config model can add a vLLM or LM Studio server anywhere on your network without editing the config file.

Google (Gemini)

  • --model google:<model>. For example google:gemini-3.8-flash, or google:gemini-3.1-flash-lite for the cheapest current model that uses tools. The key comes from GEMINI_API_KEY or agent86 keys set google, and is sent only in a request header, never in the URL.
  • Tools work. Gemini 3 and 4 attach a "thought signature" to each step's tool calls and refuse the next request without it. agent86 sends it back as Gemini requires, which Gemini's OpenAI-compatible endpoint cannot do. A tool whose name Gemini does not accept (an MCP tool starting with a digit, say) is renamed for Gemini and mapped back.
  • Google keeps no copy. Every request asks Google not to store it. Since October 2026, new paid projects otherwise keep requests in AI Studio's logs for 55 days, and a request holds every file the agent read. [providers.google] store = true turns storage back on.
  • Thinking, models, and prices. Gemini's thought summaries are shown apart from the answer. /model lists Google's chat models, the context window comes from Google, and current Gemini models have built-in prices, including their cheaper cached input.
  • When Google stops a reply itself (a safety block, for example), agent86 says [google stopped the reply: SAFETY] once and does not ask the model again. A project whose prepaid credits ran out gets told so instead of retried.
  • agent86 sends Gemini no temperature: Google says its newest models ignore it and its earlier Gemini 3 models should keep the default.

vLLM

  • --model vllm:<model> reaches a vLLM server at localhost:8000. A key is sent when you set one (VLLM_API_KEY, or agent86 keys set vllm) and is not needed otherwise.
  • The server's own context window (max_model_len) is used, and vLLM is free in cost totals.
  • Errors that say what to do. vLLM's errors for a server started without --enable-auto-tool-choice and --tool-call-parser, for a conversation past its context length, for an unknown model, and for a missing key keep vLLM's text and add the fix. An error vLLM sends in the middle of a reply is now shown instead of ending in an empty answer.

LM Studio

  • --model lmstudio:<model> reaches LM Studio's server at localhost:1234. /model lists every chat model you have downloaded and marks the loaded ones and those not trained for tool use.
  • The length the model was loaded with. LM Studio loads a model with a context length you choose, often far below its maximum, and refuses requests past it. agent86 uses that loaded length, and learns it again once the first request has loaded the model, so it compacts the conversation before LM Studio would refuse it.
  • An API token, if you turned on LM Studio's "Require Authentication", is sent when set (LM_API_TOKEN, or agent86 keys set lmstudio).
  • A config that reaches LM Studio through llamacpp keeps working. Switch to lmstudio for the model list and the window.

Servers anywhere on your network

  • /config model → "add a vLLM or LM Studio server". Give the kind, a name, the address, and a key only if the server needs one. agent86 asks the server for its models with no key first and asks you for one only if the server refuses, tests a real reply, and saves the server to your own config file, never the project's.
  • Safe with keys. A key typed there goes into the OS keyring only after the test passes. Changing a server's address never sends its stored key to the new host unless you confirm it or type a new key, and a key that would cross the network over plain http:// gets a warning.
  • By hand, any [providers.<name>] section with adapter = "vllm" or adapter = "lmstudio" is such a server.

Also

  • agent86 no longer depends on chrono, which RustSec marked unmaintained; the times it prints are unchanged.

Google was checked against the live API, including tool calls on Gemini 3.1 Flash-Lite and Gemini 4 Hydrogen. vLLM and LM Studio were checked against recorded responses in their documented formats, not yet against live servers.

agent86 v1.0.23

Choose a tag to compare

@github-actions github-actions released this 16 Nov 22:36
177dd06

Clients built on agent86 can now take a secret from their user in their own masked entry and hand it straight to agent86, instead of sending the user to a terminal. As everywhere else, the model only ever sees the secret's name.

Secrets from clients

  • Hand a secret over. A client such as agent86-web can set a secret for an open session, list the names held, and forget one, through three new ACP extension requests. It is the terminal's /secret NAME: the model uses the secret as $NAME in commands and ${secret:NAME} in files, and anything that would show the value (a file it reads, its own reply, the saved session) shows ${secret:NAME} instead.
  • Remember it for the project. Asked to, agent86 keeps the secret in the OS keyring, in the same place as one remembered at the terminal, so later sessions in that folder, in the terminal or in a client, have it too. Setting a remembered secret again without remembering it takes it out of the keyring. With no keyring available, the secret is kept for the session and the client is told so.
  • When the agent asks. If a client says it has its own masked entry, the model can ask for a secret it needs (request_secret), and the client prompts its user for it. A decline, a cancelled turn, or anything the client cannot answer is a refusal, and the model is told.
  • Never repeated back. The value travels only over the local connection between the client and agent86. No reply, error message, or log line holds it.

Editors that have no masked entry, such as Zed, work as before: secrets come from the terminal (/secret NAME, remembered for the project), and request_secret is not offered.

For client authors

  • initialize now lists agentCapabilities._meta["com.maetek.agent86/secrets"] = {"version": 1}.
  • _com.maetek.agent86/secret/set (sessionId, name, value, remember), _com.maetek.agent86/secret/list, and _com.maetek.agent86/secret/forget are open to any client.
  • A client that adds "com.maetek.agent86/secrets": true to its own clientCapabilities._meta promises to draw a masked entry and to keep what is typed there out of its thread, history, and logs. Only such a client is sent _com.maetek.agent86/secret/request when the model calls request_secret, and answers with {"outcome": "entered", "value": ..., "remember": ...} or {"outcome": "declined"}.
  • The format is described in the ACP guide.

agent86 run, the terminal interface, and other clients behave as before, apart from the new key in initialize.

agent86 v1.0.22

Choose a tag to compare

@github-actions github-actions released this 16 Nov 20:54
f68608e

You can now see what agent86 has remembered, one fact or episode at a time, keep the ones that matter from ever being pruned, and delete the ones that are wrong, from the terminal or from an editor or client over ACP.

Memory you can list, pin, and forget

  • List. agent86 memory list shows the stored facts (what the agent keeps with remember), newest first, with their ids. --episodes lists episodes instead: one per finished turn, with its session, task, and outcome, which agent86 recalls into similar later tasks. --pinned shows only pinned entries, and -n sets how many to show (20 by default, negative for all).
  • Pin. agent86 memory pin <id> keeps a fact from ever being removed by agent86 memory prune or by the retention limits applied at startup, and unpin undoes it. Add --episode for an episode's id; facts and episodes are numbered separately. Pinned entries don't count toward --keep-last or [memory] retention_max_episodes.
  • Forget. agent86 memory forget <id> deletes a fact as before, and --episode now deletes an episode, so a bad outcome stops being recalled into later tasks.
  • Shared with Python. Pins are kept in a table of agent86's own in the memory database, and the facts, episodes, and sessions themselves are unchanged, so the Python implementation still reads the database. Python doesn't know about pins, though, so its own pruning still removes pinned entries.

Memory in editors and clients

  • Clients such as agent86-web can list, pin, unpin, and forget the same facts and episodes for an open session, through three new ACP extension methods. Text from the session's secret vault comes back as ${secret:NAME}, as everywhere else a client sees.

For client authors

  • initialize now lists agentCapabilities._meta["com.maetek.agent86/memory"] = {"version": 1}.
  • The methods are _com.maetek.agent86/memory/list (paged with limit and cursor), _com.maetek.agent86/memory/pin, and _com.maetek.agent86/memory/forget. They are requests the client makes when it wants to, so no client capability is needed, and other clients see no change apart from the advertisement. The format is described in the ACP guide.

agent86 run, the terminal interface, and the existing memory commands behave as before.

agent86 v1.0.21

Choose a tag to compare

@github-actions github-actions released this 16 Nov 17:28
359b902

Clients can now see which sub-agent is asking for approval and what is waiting behind it, a session survives agent86 being stopped partway through a turn, and editors can reopen a session without replaying it.

An approval inbox for parallel sub-agents

  • One question at a time, in order. When several specialist sub-agents run at once and each needs approval, their questions are asked one at a time, in the order they arrived. Before, the order was whatever thread got there first.
  • Who is asking. For a client that asks for agent86's state events (com.maetek.agent86/state), each permission request from a sub-agent says which sub-agent asks, the card it reports on, the git worktree it works in (if any), and what it has spent so far, alongside the turn's spend and the cost limit.
  • What is waiting. The same client gets a new questions event whenever the queue changes: the question being asked and those waiting behind it, so it can show them as a list.
  • Nothing changes for other clients or in the terminal interface, which already shows sub-agent approvals in its panel.

Sessions that survive a stopped agent

  • Saved after every step. agent86 now saves the session after each step of a turn, not only before and after it. If the process is killed or crashes mid-turn, the steps that finished are kept, and agent86 run --session <id>, agent86 --resume <id>, or reopening the thread in an editor goes on from them.
  • A session cut off this way is marked as still running (execute) until a later turn ends. The saved format is unchanged, so the Python implementation can still read it.
  • Continuing the interrupted turn itself without a new message is not part of this release.

Reopening a session without replaying it

  • session/resume. Editors and clients can now reopen a saved session with ACP's session/resume, which restores it without sending the conversation back. This suits a client that still shows the conversation, such as one reconnecting. The model sees the whole history either way, and session/load is unchanged.

For client authors

  • initialize now lists sessionCapabilities.resume.
  • The asker is sent as _meta["com.maetek.agent86/subagent"] on session/request_permission, and the queue as state events of kind questions; both only to a client with com.maetek.agent86/state. The format is described in the ACP guide.

agent86 run and the terminal interface behave as before, apart from the extra saves.

agent86 v1.0.20

Choose a tag to compare

@github-actions github-actions released this 16 Nov 04:00
22d3b59

Editors now show how full the context is and what a session has cost, and clients such as agent86-web can follow each model call, sub-agent, guardrail, and routing decision as it happens.

Context and cost in your editor

  • A context meter and a running cost. After each model call, agent86 tells the editor how much of the model's context window the last request used, how large the window is, and what the session has cost so far in US dollars. This uses ACP's standard usage_update, so an editor that shows context or cost needs nothing agent86-specific.
  • Unknown is not free. For a model agent86 has no price for, the cost is left out rather than shown as zero, as the terminal shows cost n/a.
  • Compactions in their place. When a long session is compacted into a summary, an editor that supports ACP's compaction updates shows it as one entry with the summary (or says why the summary could not be written). Other editors get the same one-line message as before.

agent86's state, for clients that ask

  • An opt-in extension. A client can ask for agent86's own state events (com.maetek.agent86/state). It then hears about every model call, the main agent's and each sub-agent's, with its cost, the turn's spend so far, and the cost limit. It also hears when each sub-agent starts and finishes, with what it cost and the card it reports on, about guardrail verdicts, and about which model triage routing chose.
  • Never more than the trace. These events are the flight recorder's own, redacted exactly as ~/.agent86/traces/trace.jsonl is: a secret appears as ${secret:NAME}. They are sent whether or not the trace file is written.
  • Nothing changes for other clients. Editors that do not ask see no new messages, apart from the extension being listed in initialize.
  • The format is described in the ACP guide.

For client authors

  • The marker for a session whose folder is unknown is now also sent as "com.maetek.agent86/cwdKnown": false in session/list. The older agent86.cwdKnown key is still sent and will be removed in a later release, so read the new one.

The terminal interface and agent86 run are unchanged.

agent86 v1.0.19

Choose a tag to compare

@github-actions github-actions released this 16 Nov 02:12
6e26de4

The agent can now search your project without running commands, and editors show its file edits as diffs you can review.

Search tools

  • search_files finds a regular expression in your files and returns the matching lines as path:line: text, grouped by file. It can be limited to a folder, a file, or a glob (src/**/*.rs), ignore case, and show lines of context around each match.
  • find_files finds files by glob: src/**/*.rs, or *.toml for every TOML file anywhere.
  • No approval needed. Both only read, so they are never asked about, and several can run at once. Until now the agent searched with grep, find, or rg through run_command, which needed your approval, depended on what was installed, and behaved differently on Windows.
  • They skip what you would skip. .gitignore, .ignore, and git's global excludes are respected, whether or not the folder is a git repository. Version-control folders (.git, .hg, .svn, .jj) and binary files are never searched. Hidden files and folders such as .github/ are searched, so keep secret files like .env in .gitignore.
  • They stay in your project. Searches cannot leave the workspace, and symlinks pointing outside it are not followed.
  • Stable, bounded output. Paths are relative to the project, with / on every OS, and always in the same order. Results stop at 200 by default (up to 2000), long lines are cut, files over 2 MiB are skipped, and a search stops after 20,000 files. Whenever something is cut, the result says so and how to narrow the search.
  • The built-in planner, researcher, and reviewer specialists can use both.

File edits as diffs in editors

  • Review the change, not a wall of text. When the agent writes or edits a file, editors that speak ACP now get the change as a diff of the whole file, before and after. That covers both the permission request and the finished tool call. The text shown until now is still sent beside it, for editors that do not show diffs. Files over 256 KiB are shown as text only.
  • Follow along. File reads and writes now tell the editor which file they touch and, for a write, the first changed line, so an editor can jump there. Searches are marked as searches.
  • Secrets stay hidden. A secret written into a file with ${secret:NAME} appears in every diff as ${secret:NAME}, never as its value.
  • A reopened editor thread shows earlier edits as text, without diffs.

The terminal interface and agent86 run are unchanged.

agent86 v1.0.18

Choose a tag to compare

@github-actions github-actions released this 14 Nov 21:08
941ee12

Specialist sub-agents: named helpers with their own instructions, tools, and model, which the agent or you can call by name. Sub-agents now follow routing and stop when you cancel.

Specialist sub-agents

  • Named, reusable sub-agents. A Markdown file with a short frontmatter defines a specialist: its instructions, and optionally the tools it may use, a stricter approval mode, tools that are always asked about, its own model, a step budget, and skills to preload. Put one in ~/.agent86/agents/<name>.md for yourself, or in a project's .agent86/agents/<name>.md. Three ship with agent86: researcher (reads files and the web, changes nothing), reviewer (reads, and runs commands only after asking you, even in auto mode), and planner (reads and writes a plan). A file of your own with the same name replaces a built-in.
  • The agent picks one. The agent sees the specialists' names and descriptions, and hands work to one with delegate's new agent argument. A specialist can only do less than the agent that called it, never more, including when it delegates further.
  • Or you do. /agent <name> <task> runs a specialist right away, with no main-agent call in between (/agent --with-context ... hands it a summary of the conversation so far). /agents lists them, and /agents <name> shows one in full. Typing #name in a prompt asks the agent to delegate to that specialist; the # menu completes the names. agent86 run --agent <name> "<goal>" makes a specialist the main agent of a one-shot run. All of this works in the terminal and in editors.
  • Project specialists are checked first. A specialist that comes with a repository is shown to you in full and approved before it first runs. agent86 remembers the approval for that exact file and asks again if the file changes. With nobody there to ask (a script, CI), it is refused unless you pass --trust-project. In an editor you get one option, Allow this version of .
  • Several at once. When the agent calls several specialists together, they run at the same time (up to three; [agents] max_parallel changes that, up to eight). Their questions to you come one at a time, and together they stay within the turn's cost limit.
  • Work in a separate copy. A specialist with isolation: worktree (or a delegation with isolate: true) works in a git worktree made from your last commit, not in your files. Its answer includes the diff of what it changed, and nothing is applied for you. A worktree with changes is kept, and its location is reported; one without changes is removed.
  • In editors, each delegation is one tool call card. It is named for the specialist and its task, lists the specialist's calls while it runs, and ends with its answer. A question from a specialist says which one is asking.

See docs/subagents.md for the file format and every option.

Fixes

  • Sub-agents follow routing. With triage routing on ([model] router = "triage"), a sub-agent ran on your default model while its trace named the routed one. It now runs on the model the turn was routed to.
  • Cancel stops sub-agents. Escape, Ctrl+C, or an editor's stop now stops a running sub-agent at its next safe point too, instead of letting it finish its work first. In an editor, closing the connection also stops the turn, and no new question is sent after you cancel.
  • Unique tool call ids in editors. Models that reuse call ids from one turn to the next (Ollama's ollama-0, ollama-1, ...) could make an editor confuse two calls. Each call now gets an id of its own.

agent86 v1.0.17

Choose a tag to compare

@github-actions github-actions released this 13 Nov 16:52
a470b4e

Session lists now show each session under the folder it ran in, and you can rename a session.

Session lists are right per folder

  • Every session records its folder. agent86 has always kept the folder of each editor session, so editors could list a project's sessions. Sessions started at a terminal (agent86, agent86 run) were not recorded, so a client that asked for one folder's sessions got every terminal session as well. Now every session records the folder it ran in: a terminal session once it has its first message, and any session again whenever it is resumed (agent86 --resume, /resume, or the session picker).
  • No more guessing. A session whose folder is not known is left out of a list for one folder, instead of being shown under whichever folder the listing started in. A list of all sessions still includes it, marked as having no known folder (_meta: {"agent86": {"cwdKnown": false}}, described in the ACP guide).
  • Safe with several windows open. Several agent86 processes can record folders at the same moment without losing each other's entries.

Sessions saved before 1.0.17 at a terminal, or by the Python agent86, have no recorded folder, and nothing in them says where they ran. They no longer appear in folder lists, such as an editor's or agent86-web's session list for a project. To bring one back, resume it once at a terminal from its project folder (agent86 --resume <id> there). From then on it is listed under that folder.

Rename a session

  • /rename <title> gives the current session a new name. /rename alone shows the current name. Before, a session was named once, from its first message, and could not be renamed.
  • Everywhere. It works in the interactive interface, the plain loop, and editors over ACP. In an editor it is answered without a model turn, and agent86 tells the editor the new title so its list updates straight away. The new name shows in /sessions, the /resume picker, and editors' session lists, and later turns keep it.
  • Tidy titles. Leading and trailing spaces are removed, only the first line is kept, control and text-direction characters are dropped, and the name is capped at 200 characters. A name with nothing left is refused.
  • The rename is not part of the conversation: the model never sees it.

agent86 v1.0.16

Choose a tag to compare

@github-actions github-actions released this 13 Nov 01:45
a8148d2

You can now run a skill yourself, instead of waiting for the model to pick it.

Run a skill directly

  • /<skill-name> [task] runs that skill now, with an optional task: for example /release-notes for 1.0.16. /skill <name> [task] does the same for any skill, including one whose name is taken by a built-in command (a skill called cost is run with /skill cost, and /cost stays the built-in).
  • Everywhere. It works in the interactive interface, the plain loop, and editors over ACP, and agent86 run --skill <name> <goal> does the same for one-shot runs. An unknown skill is refused before the model is called.
  • Listed where commands are. Skills show in the / menu and in /help, editors list them with their other commands, and /skills (now in editors too) says how to run each one.
  • What happens. The skill's instructions are sent with your task, and its allowed-tools apply from the first step, ending with the turn as before. The rest is an ordinary turn: approvals, guardrails, secrets, the session, and /cost work as usual.
  • Names. A skill gets a command of its own only when its name is plain letters, digits, -, and _. Others can still be run with /skill <name> (if the name has no space) or chosen by the model.

Fixes

  • /cost in editors. For a model on an OpenAI-compatible provider, such as OpenRouter, /cost in an editor said cost n/a (unpriced model) even when the model had a price. It now shows the same cost as the terminal.
  • SQLite. The bundled SQLite is updated (rusqlite 0.41) for RUSTSEC-2026-0459: older versions could return uninitialized memory when a database was opened next to a -wal file of a different page size.