Changelog

All notable changes are recorded here. The format follows Keep a Changelog, and newt follows semantic versioning from 1.0; what that covers is on the Stability page.

[Unreleased]

[1.0.0] - 2026-11-13

The first release.

Added

• Runtime. Turn loop with the frozen prefix, history and per-turn scratch layers, and retention classes (ephemeral, durable, outward) that decide what reaches history. Steering of a running turn by new events, a batch tool, and a crash-safe turn journal with exactly-once outward calls through idempotency keys. A Postgres runner with fenced leases, NOTIFY wakeups, a periodic sweep, retry backoff and dead-lettering. Events API with read receipts and a live SSE feed.
• Providers. Streaming clients for the Anthropic Messages, OpenAI Responses and OpenAI Chat Completions protocols (the last for vLLM, Ollama, OpenRouter and other compatible hosts), with per-route concurrency limits that reserve a slot for interactive turns, one retry of a retryable error before anything has streamed, fallback along a model alias’s route chain, and a 10 minute deadline per model call. Prompt cache keys shared across an agent’s sessions (runner.cache_key_buckets). By default ("auto") newt measures each agent’s model calls a minute and spreads its sessions over just enough keys to keep each under 12 a minute, with jump consistent hashing so a new key moves few sessions.
• Workspace. A reactive workspace of pages fed by a context provider: invalidation by key prefix, refetch on read, page data returned by tools, and lazy loading that runs the first model call while pages load in the background. Pinned turn context that joins the cached prefix.
• Context provider. Bootstrap per version, per-turn context (instructions, constraints, pinned) and page refetch over HTTP. Skills as a first-class feature, loaded on demand with load_skill, and visible to tools through newt/skills_loaded.
• MCP. Tools from MCP servers over Streamable HTTP, with the newt/* _meta fields for retention, invalidation, idempotency, summaries and page data. Speaks MCP 2026-07-28 with a fallback to 2025-11-25. Tools sorted by name per server so the cached prefix stays stable. Relists tools after notifications/tools/list_changed over subscriptions/listen. A call stays alive while it reports progress (90 seconds quiet, 10 minutes total) and is cancelled when abandoned. Each call carries the traceparent of its tool span, and its progress notifications reach the live feed as tool_progress. Skills served over MCP (SEP-2640): listed on connect as {server}/{skill path}, fetched only when loaded, checked against the listing’s digest, size and frontmatter, cached, with their supporting files readable through load_skill’s file. An agent can be one MCP server and nothing else ([agents.x] mcp = ...): its instructions are the server’s, its workspace pages are the session’s resources, and notifications/resources/updated over subscriptions/listen marks a page stale.
• Approvals and tasks. A tool that answers input_required with elicitations becomes a question to the person: the model asks, then calls the tool again with _input answers that newt sends as MCP input responses, with no state stored in between. Tools that run as MCP tasks are polled for up to an hour.
• Turn guards. max_turn_tokens in the bootstrap: past it the model is told to finish, and one more call that does not end the turn fails it. Recitation, experimental and off by default: with recite in the bootstrap, a <goal> note restates the turn’s events on long turns, in scratch only. An eval (examples/recitation_eval.rs) found no gain on a strong model and 1 to 12% more input tokens.
• Replay and fork. GET .../history and POST .../fork (a new session, under the same or another agent, with a copy of the history up to a turn). newt-replay sends a session’s events to a fork turn by turn and prints what each turn did then and now.
• Compaction. Checkpoints written by the agent’s own model, with commitments that cannot be dropped silently, a kept tail of recent turns, and raw history left in place. The built-in remember tool for durable facts.
• Observability. One typed event stream feeding a JSONL file, the live feed and an OTLP/HTTP sink (one trace per turn, with a Langfuse profile, an enricher and a redactor). newt-report summarises timing and flags from the JSONL file, and prints a cache report card: cached share, cost at --prices, and for every miss the cause (first call, model change, the first changed piece of the prefix with its offset, history rewritten from message n, compaction, idle past --ttl, or routing). Prefix and history fingerprints carry a hash per tool and per message for it.
• Load testing. newt-loadtest with a fake model that speaks the OpenAI Responses stream and simulates prompt caching, a mock context provider and MCP server, and a driver that reports read receipt, turn latency, model calls, cache rate and tool calls.
• Embedded Postgres. database = { embedded = "<dir>" } runs newt’s own Postgres (downloaded once, data in <dir>), so newt needs no database setup on one machine. On by default through the embedded-postgres feature.
• Profiling. Model call events carry their prompt cache key, and the cache report card names a session that moved to another key. Accepting an event, claiming a session and loading history report how long they waited for a database connection; history and compaction state each use one connection instead of two or three. The fake model writes a cache log (--cache-log) of where each request went and which of its blocks the machine held or could read.
• Turn start and cache keys. Starting a turn takes three connections from the pool instead of five: the next turn’s events are read on one, and the turn’s start is written and its history read on another. A session keeps its cache key while its prefix is still cached and the key is not crowded, so adding keys moves no one who is fine where they are.
• Benchmark. scripts/bench.sh runs the fake model, the mock app and newt and reports load, CPU, memory and the cache report card, with no API key, in a steady scenario paced like people and a burst worst case; method in Benchmark.
• Demo. newt-demo, a personal assistant that serves a context provider and MCP tools in one process. Its MCP server is also a complete agent on its own (instructions, resources with update notifications, a skill served over MCP), run as assistant-mcp. Its MCP server also dogfoods approvals (clear_tasks asks first) and tasks (weekly_review, polled until done). A Dockerfile with every binary and deploy/compose.yaml, which runs Postgres, the demo, the fake model and newt with no API key.
• Retention. [retention] prunes consumed events after inbox_days (30) and live feed frames after live_days (7), hourly and in batches. DELETE /v1/agents/{agent}/sessions/{key} deletes a session and everything stored for it, and answers 409 while a turn holds its lease. History is never deleted on its own.
• Several instances. A test runs two runners against one Postgres and checks that every event reaches history exactly once and every model call belongs to one committed turn.
• Releases. A v* tag builds newt, newt-report and newt-replay for Linux x86_64 and macOS arm64, pushes the image to ghcr.io/julianbouchard/newt, and publishes a GitHub release with this changelog’s section as notes.
• Workspace setup. Cargo workspace with newt-core, newt-server, newt-demo and newt-loadtest; dual Apache-2.0 OR MIT licensing; CI running format, clippy, tests, cargo deny, cargo machete and a boot smoke test; the newt logo.