Changelog

Voice works out of the box

Press the microphone in the composer, speak, and stop. Localfirst ships its own pinned whisper.cpp runtime and recommended speech model, so the first transcription works without an account, a network request, a model download, or a settings detour.

The transcript joins the draft you were already writing and is never sent automatically. Recordings are deleted after transcription, microphone permission is requested at the moment you press, and optional model downloads happen only when you explicitly choose one.

Build a team without crossing your review

Team proposals are more resilient across local models and coding CLIs. Localfirst constrains structured output where the runtime supports it, repairs known tool-name aliases, and retries malformed drafts without granting the setup run tools or a writable project boundary.

Edits save in order, runtime changes apply atomically, and approval creates exactly the reviewed teammates and Team Board. The finished setup opens an idle work thread with its origin attached; no teammate begins working until you ask.

Usage limits say only what the runtime knows

Claude Code and Codex teammates can now show the usage windows their own runtimes report. A limit blocks new work only after the vendor actually refuses a request, applies only to the affected runtime, and clears when its reset time passes.

Missing data stays unavailable instead of becoming a guessed percentage. Stale observations age while the app is open, so a teammate does not remain blocked merely because nothing else refreshed the screen.

Threads return you to the work

Conversations open on their latest messages while exact Run Trail links still land on the message they reference. If you scroll into history, Localfirst keeps your place rather than pulling you back down as replies arrive.

The Threads badge now counts unread replies only in the Space you are viewing, and setup, direct, and project threads share more reliable recovery when a runtime answers with nothing or a process ends unexpectedly.

Routines that work with the team

Describe a recurring job in one sentence, then review the schedule, trigger, team, and destination before it is enabled. A routine can start on a schedule, a file change, or a teammate finishing, and can run teammates in sequence or in parallel.

Results return to a shared thread or the Library with their history intact. A teammate can propose a routine during conversation, but only a person can approve it, leave it paused, or turn it on.

One session, wherever you look

An automation run joins the same shared thread, persistent Canvas card, participant list, and event stream as the rest of the work. Its result is an authored message, not a detached background notification.

You can join, steer, pause, or stop while it runs. Decisions wait without choosing a default, and a resumed run continues without repeating teammates who already finished.

Canvas shows living work

Canvas now projects the direction, active work, artifacts, decisions, and questions that need attention. Threads and runs remain the detail surfaces behind those cards instead of competing copies of the same state.

Cards change state in place as work advances, while Trails preserve how an outcome was produced and where a person intervened.

Find anything without sending a query away

Workspace-wide search uses a local SQLite index across Spaces, threads, messages, work, artifacts, teammates, runs, tool calls, routines, activity, and memory. Scope and type filters make broad searches manageable.

Every result opens the exact run, thread, artifact, or memory it came from. Tool arguments, tool output, and structured proposal envelopes are deliberately excluded from the index.

Take a team to another machine

Portable teammate and Team Board packages carry roles, board order, runtime requirements, and optional selected memory. Import shows every change first and lets you merge or duplicate deliberately.

Credentials, chats, sessions, machine paths, run history, and routines are never included. If a required model is unavailable, the imported teammate stays disabled instead of silently changing runtimes.

Models and effort match the task

Model choices now come from the runtime itself, with a thinking-effort control for each teammate. Automatic can route each request, the exact native value is recorded in the Run Trail, and a task-level override lasts for one send only.

Installed coding CLIs are discovered automatically as they appear or change. Localfirst keeps the security boundary explicit rather than implying that every runtime has the same privacy model.

Ask an agent to build the team

Use /team or ask naturally in a thread. A capable agent can propose the roles, models, instructions, tools, permissions, and Team Board needed for the work, without creating anything behind your back.

The complete setup arrives as a review card and editable proposal. Localfirst validates every runtime and permission, shows what will persist, and waits for final confirmation before creating an idle team.

Refine a setup without giving up control

Duplicate warnings catch repeated configurations, and an approved setup can become a reusable Space template. /team-update proposes field-level changes to existing agents and Team Boards with every before-and-after value visible.

Trusted-template automation is deliberately narrow: it requires reviewed history, local models, no standing permissions, one-at-a-time execution, and workspace controls with an emergency stop. Automatic creation never starts work.

Context that leaves room for the answer

Large file reads, logs, searches, JSON, and other tool results are now packed before they crowd out the response. The complete result stays in the Run Trail, and the agent can retrieve omitted evidence through a bounded, run-scoped context reference.

Conversation history and attachments use explicit token budgets. If the request cannot fit the selected runtime, Localfirst stops before dispatch and explains which input is consuming the window.

The Run Trail explains the run

Every new run records the exact message and actor that started it. Per-agent and batch usage, context sections, omissions, finish reasons, and local-compute timing are visible without storing prompt content inside the usage record.

Activity labels now follow observable events—Reading, Investigating, Creating, Reviewing results, and Responding—rather than presenting a generic spinner as evidence of progress.

Local models fit the machine more honestly

Ollama planning now reserves answer and tool-result headroom, responds to swap pressure, and prevents Fast mode from quietly running a model that is partly offloaded to the CPU. Automatic mode can still accept that tradeoff when quality matters more than latency.

Space memory recall now uses a bounded local SQLite index instead of scanning every memory before dispatch. No embedding service or hosted fallback was added.

Three workflows you can actually run

New examples cover a vendor decision, a private incident review, and a React refactor. Each one assigns distinct roles, orders the handoffs, and finishes with a concrete outcome instead of a pile of disconnected chat replies.

The website-vendor run moves from research to implementation review and a final recommendation. The incident workflow keeps sensitive log analysis on a local model before review. The refactor workflow adds a supervised localhost preview before the last code pass.

Artifacts keep their authors and their trail

Claude, Codex, provider models, and local models can now create documents through the same permission, versioning, and provenance path. Reports and implementation briefs keep the agent that authored them, the run that produced them, and the inputs they came from.

That turns an output into shared workspace material: another agent can review it, you can open it beside the canvas, and the final decision stays connected to the evidence.

Run Trail to report preview

Run Trail now makes the full sequence legible: each turn, tool, output, correction, and handoff is visible in order. You can move from the team-level run into the underlying thread without losing your place.

Agent-authored reports open in a dedicated preview with rendered Markdown, source view, and an expanded reading mode. Tables, headings, and emphasis survive the trip from the agent response into the finished document.

Local models use the machine honestly

Ollama runs now size context to available memory and recover more cleanly from model timeouts. PDF and image work can stay with a compatible local vision model, with no silent hosted-model fallback.

Cloud CLI agents still use their configured providers. Localfirst keeps the orchestration, workspace state, permissions, and audit trail on the machine while making that boundary explicit.

Your team, in your words

The Team page now reads like a living roster instead of a settings grid. Availability, current work, approvals, and failures are easier to scan, with visual identities that stay consistent across the workspace.

Call them Teammates, Agents, Sidekicks, or use your own singular and plural names. Localfirst carries that choice through the interface while keeping the Team page itself familiar.

Local AI setup that tells the truth

A new Local AI guide replaces the flat runtime list. It separates connected runtimes from the ones that need attention, explains the next useful action, and only calls a setup ready when a reachable runtime has a model it can actually use.

Agent creation now follows those same connection states, so an offline runtime is never selected just because it appeared first.

Learning stays local

Accepted corrections and liked retries can now become private learning examples for the agent that produced them. The records stay in the workspace SQLite database and remain scoped to the context that made the feedback meaningful.

Direct messages also stay focused on the direct request instead of inheriting unrelated project direction or memory.

goose joins the runtime lineup

Localfirst can now discover and run an existing goose CLI installation alongside Claude Code, Codex, and Gemini. It reports installation and sign-in state, resumes the right session, and keeps execution scoped to the Space working folder.

Chat that recovers

Retry is now a first-class action, thinking and working states are more accurate, and local models with strict chat templates get a safe fallback when they reject system-role messages.

Runtime failures and missing tool support are surfaced where they happen, so a stalled response is less likely to look like an agent that is still quietly working.

Persistent agents, visible work

Create agents with roles, instructions, model choices, and explicit permissions. Arrange them into Team Boards, follow their work through threads and Run Trails, and keep plans, artifacts, and handoffs attached to the project.

Your machine is the backend

Connect Ollama, LM Studio, or another OpenAI-compatible runtime on localhost or a private network. Localfirst stores workspace state in SQLite and does not add a hosted-model fallback.