eagent v0.10.0

Full Changelog: v0.9.0...v0.10.0

eagent v0.9.0

Full Changelog: v0.8.0...v0.9.0

v0.8.0

One reasoning-effort policy for every preset

Every preset, and the shipped defaults, now follow the same rule:

• Orchestrator: the model's highest effort below max (xhigh for GPT-6 Astra, GPT-5.6, Muse Spark, Qwen; high for GLM, Kimi, DeepSeek, Claude).
• Task worker: high for full-size workers (GLM-5.3, Sol, Terra, Opus 5, Muse), medium for flash-class ones (GLM-5.3-Flash, DeepSeek V4 Flash, Sonnet 5, Qwen); GPT-5.6 Luna always xhigh.
• Narrator: always low, never none.

Defaults (glm) are GLM-5.3 high, GLM-5.3-Flash medium, DeepSeek V4 Flash low. A project file that overlays a preset keeps its own values; run eagent config show to see what is effective, and set low on the task worker in the project file if speed on simple steps matters more than the extra thinking.

Muse Spark prices

Meta's own list: Muse Spark 1.3 is $1.25 / $0.15 / $4.25 per million (input, cached input, output); Muse Spark 1.3 Contributor is the same model at $0.10 / $0.002 / $0.20 in exchange for training on your inputs and outputs, rate-limited by tokens and available in select countries. Cost estimates for the muse preset now use these.

Upgrade

curl -fsSL https://github.com/ericflo/eagent/releases/download/v0.8.0/eagent-linux-amd64 -o ~/.local/bin/eagent && chmod +x ~/.local/bin/eagent

v0.7.0

Configure a session before it exists

Finalechat's new-session draft now opens the real settings editor, the same embedded page the thread panel shows, before the first message is sent. The connector publishes the project's settings website once for the settings resource itself (Finalechat's PUT /settings-resources/{resource}/website); a draft opens it, and a conversation opens it until its own page with session context is published. Requires the Finalechat build from 2026-09-09 or later.

Models

• muse preset: Muse Spark 1.3 Contributor on Meta's API for all three actors (eagent doctor --live --preset muse to prove it).
• tool_choice fallback: a model that only accepts the default tool choice (Muse Spark answers 400 to required) is asked again without one, and the client remembers that for the rest of the session instead of failing every narrator turn.

Narrator

• A user's message is always acknowledged. When the narrator had already looked at the message on a wake for something else (a running task's output, a tick) and held, the wake that should have said "got it" was dropped as "nothing new". Seen as a flaky race test; real in sessions with tasks running.

Upgrade

curl -fsSL https://github.com/ericflo/eagent/releases/download/v0.7.0/eagent-linux-amd64 -o ~/.local/bin/eagent && chmod +x ~/.local/bin/eagent

Restart eagent serve so the connector publishes the resource's settings website.

eagent v0.6.0

Start a session where you want it

session.start from Finalechat takes an optional cwd: the directory the session's commands start in, checked to exist by eagent and recorded as the session's first working-directory move, so the thread's folder chip shows it from the first message. The project connector publishes where a session may start (details.directories: the project root, directories recent sessions moved to, the project's subdirectories and its siblings), and Finalechat's New session is now a draft thread whose folder chip picks from those or any absolute path, whose Settings button edits the project's defaults, and whose first message is what actually starts the session, already configured.

From a terminal, eagent --cwd DIR "…" does the same.

Full changelog: v0.5.1...v0.6.0

eagent v0.5.1

A working directory that persists

Each actor now has a working directory. It starts at the project root, and a cd inside a command moves it for that actor's later commands: the shell reports where it ended up, the log records the move as a cwd.change event, the tool result says so, the steer names the directory while it differs from the project root, and the phone's thread chips (cwd, branch, and a new project key) and the web UI follow it. A worker starts where the orchestrator was when it delegated and keeps its own. File tools resolve relative paths against it and may write there.

A narrator that answers with the orchestrator, not ahead of it

The narrator's reply to a message you send is held until the orchestrator has reacted, or fifteen seconds have passed. For a message that asks a question, only the orchestrator's answer (a note with answer: true) or the end of its turn counts, and only from a turn that actually had your message in view. The steer then says which case applies: relay the answer faithfully, say what started, or one line that the message landed. Questions about the work or about eagent itself are answered by the orchestrator in a marked note that the narrator relays; every actor's prompt now carries the same short description of how eagent works (FACTS.md), so those answers are grounded rather than guessed. A narrator message that names the machinery (orchestrator, dossier, subsession, and so on) is sent back once to be rewritten as "I".

v0.5.0 was tagged with two stale test expectations and did not publish; this release is the same change with those fixed.

Full changelog: v0.4.0...v0.5.1

eagent v0.4.0

Reply to a finished session from your phone

A reply sent from Finalechat to a session that has ended now brings it back, the way writing to it in the web UI always did.

• eagent serve and eagent connector run follow the account's event stream and resume a session of theirs in-process when a user message from the app lands on its thread, with the message (text and files) as the next turn, or as the answer to the question the session stopped on.
• On connect and every minute they sweep for replies that arrived while nothing was watching, so a reply sent overnight is picked up when eagent starts.
• A session that is running anywhere keeps its own mirror and is left alone; the reply is not echoed back to the phone.

EAGENT_FINALECHAT=off disables this along with the rest of the integration. Details in docs/FINALECHAT-INTEGRATIONS.md.

Full changelog: v0.3.0...v0.4.0

eagent v0.3.0

Start a session from your phone

With Finalechat, the inbox now shows New session for every project where an eagent is running. Type the first message and the session starts on that machine, with that project's settings, and opens as a thread.

• eagent serve and eagent connector run host the new session in-process, so it stays interactive as long as they run and the web UI shows it.
• A plain terminal session starts it as a separate eagent -p process in its own session group, which survives the terminal session ending and can be resumed with eagent -c.
• Each request runs at most once: a redelivered command returns the original result, and a claim without a local journal is reported as unknown rather than started again.
• Connectors paired before this release gain the capability on their next reconnect without a second pairing.

The protocol addition (session.start) is in Finalechat as of the same day; the hosted service already has it. See docs/FINALECHAT-INTEGRATIONS.md.

Full changelog: v0.2.0...v0.3.0

eagent v0.2.0

First public release. eagent is a coding agent that runs as three cooperating actors (orchestrator, task worker, narrator) over one append-only event log, in a single binary with no runtime dependencies beyond bash.

Install

go install github.com/ericflo/eagent/cmd/eagent@v0.2.0

or download a binary below (SHA256SUMS covers all four), then export TOGETHER_API_KEY=... and eagent doctor --live.

Since v0.1.0

• Your phone. With a Finalechat token, every session gets a thread on your phone: the narrator's messages and questions with tappable options, replies that land in the session as if typed, files both ways (models that accept images see them), a live status line of what the session is doing, idempotent posts and honoured rate limits, and remote mode. A batch run with a question open waits for the phone instead of ending.
• Session archives and remote settings. eagent artifact export|publish|verify|restore produces portable, verifiable archives with an offline Go/WebAssembly replay viewer; eagent connector pair|run exposes the project's settings (and, per session, task concurrency and narrator timing) in Finalechat with conditional undo. All of it is opt-in; EAGENT_FINALECHAT=off is the kill switch.
• Web UI. A graphical configuration editor that saves overlays to .agents/eagent/config.json, shows where every value comes from, tests routes and measures reasoning effort per level; a design pass across chat, tasks and timeline; phone layouts.
• Providers and presets. Tiered presets for OpenAI, OpenRouter, Anthropic, DeepInfra, Fireworks, OpenCode Zen and Nous Portal; automatic fallback routes for every actor (billing failures are never retried); provider-aware cost estimates per session.
• Prefix caching. Per-call steers are recorded in the log so every prompt strictly extends the previous one; OpenAI cache hits recovered from 6% to the 85–93% range seen elsewhere.
• Harness behaviour. Repeat reads of unchanged files and repeat views of unchanged screenshots are curbed; an orchestrator doing the workers' job is told to delegate; the narrator acknowledges at once, wakes every 30 seconds while work continues, and names what is taking its time; a rewritten narrator persona with banned machine-prose habits.
• Seven adversarial review rounds of fixes across the scheduler, rollover, sandboxing, pricing and the phone mirror, each recorded in the commit history.
• Docs. The Breakout grid: six presets building the same game in parallel, measured, played and judged. The design specification eagent was built from, and what broke in four earlier implementations.
• Release plumbing. GitHub Actions CI on Go 1.24 and the current release; tag-driven binary releases; eagent version reports the module version on go install builds.

Full changelog: v0.1.0...v0.2.0

eagent v0.1.0

First release: three-actor, event-sourced coding agent in a single binary. Presets for GLM (default), Astra, Anthropic, DeepSeek, Qwen; named config bundles; web UI (eagent serve); dossier-based context rollover; asynchronous shell; crash-safe resume. See README.md and docs/.