Documentation Last reviewed 2026-11-09

Changelog

Dated releases, newest first.

Every release is listed, newest first, with the notes written for it when it shipped. A release is not finished here until its entry exists.

The dates need context. The work began in January 2026 as an internal build inside a working distillery and ran there four months before it was packaged. The name Smart Node and the first commit of the installable node both date from 2026-05-15; version numbers start 2026-08-02. Everything earlier is below, dated from the commit record.

Earlier releases have their own pages: August 2026 (1.0.1 to 1.12.22) and September 2026 (1.12.23 to 1.12.48).


[1.14.1] - 2026-11-09

Documentation only; nothing on a node changes.

  • The quick-start install command in the README and in docs/install-from-github.md now passes --node-fqdn, --node-domain and --no-vpn. Without a node domain Studio has no address, and a clean install that followed the old command ended with an error after every check passed.
  • The README says where questions and ideas go: GitHub Discussions.

[1.14.0] - 2026-11-08

Upgrade notes: docs/upgrade/1.14.0.md. A node installed as office is not moved by the update; move it by hand first, as that note shows.

  • Source is English only. Message and task search stem words with the English dictionary for every query (Russian stemming is gone), the failed-turn notice is always in English, and voice language aliases are the English and native Latin-script names.
  • The end-user app is called Studio everywhere, inside as well: the component is companions/studio (studio.sh, studio.manifest.json), the service smart-node-studio in /opt/smart-node/studio, logs in /var/log/smart-node/studio, Traefik files 70-studio.yml and 71-studio-internal.yml, and the voice setting SN_STUDIO_URL. The interface says Studio where it said Workspace. Data keys follow: studio_user in message metadata and the desk API, mesh sources studio, studio-upload, studio-gdrive, studio-chat, session reason studio_manual_clean, and the browser draft key sn-studio-drafts.
  • No compatibility with the office name is kept: office.<domain> no longer redirects, and a node installed under the old name is not migrated by an update. Reinstall such a node, or move it by hand.
  • Removed the unused office prototypes public/next/ and public/mock/, the old Studio shell (public/index.html, public/js/, public/css/), which the server had stopped serving, and the unlinked public/tasks.html. The tests that read the old shell now read the one that is served (public/next2/), and describe how it does things: tabs per agent, Start clean on the agent page, agent state read on live events, tool words from the registry. Studio has no button to start a voice conversation yet; /api/me still carries voiceUrl for one.
  • studio.sh --uninstall no longer ends on a helper that does not exist (stage_clear); a test checks that installers use only defined helpers.
  • Removed companions/screenbox/: a compose file for a desktop companion whose installer and images were never part of this repository.
  • companions/README.md lists the companions that exist, from their manifests. READMEs for core-api, hitl, hitl-upstream, tools, tracking and _shared. NOTICE lists the approvals service and adapter.
  • The memory demo GIF is half the size (3.3 MB).
  • The web installer installs what was chosen: Simple, Full or Custom reached the page but not the installer, which installed every module. A test now checks the arguments it gets.
  • Running the installer again over a container it created says how to continue the install in it (--provider existing --force), instead of only offering to delete it.
  • The source-install runbook says how to put a node on your own computer, WSL included.
  • Removed companions/mesh-image/ and companions/planner-image/: memory and tracking run as native services and load no image. The update runbook and planner's VENDORED no longer send you to copy them.
  • CONTRIBUTING says how to run the whole source suite without a node (Linux, PostgreSQL binaries, jq, two Python environments, the variables that point the tests at them); run that way, all of tests/run-source.sh passes. Studio's npm test runs on Node 22 as well as 20.
  • tools/revendor.sh no longer defaults to a machine-local source path; --from DIR is required.

[1.13.4] - 2026-11-08

  • A role library for the setup agent: 100 ready-made roles in 18 departments ship with the node, one file each, laid into /srv/smart-node/specialists on every install and update (root-owned, read-only to agents). The setup agent takes the roles it proposes from it, reads a role in full first and narrows it to the owner, offers two or three fitting departments when the owner does not know where to start, and names for each agent the reason in the owner's words and its first task. Before, it wrote every agent from scratch.
  • A Personal department: Personal Assistant, Legal Guide, Health Guide, Tech Helper, Wellbeing Companion, beside the Personal Growth coaches. Each says what it is not (not a lawyer, doctor or therapist) and when to see one.
  • core-api: GET /api/specialists/library lists the roles with their department and one line, without their text; GET /api/specialists/library/{slug} gives one role in full.
  • The setup agent raises a domain of the node's own only when the owner needs it (the node on a phone, away from home, mail from the agents' own addresses), and says what it gives and what takes a further step.
  • Studio: the list of steps under an answer follows the theme; it was a dark box on a light Studio.
  • Installer: the Documents checks look for its MCP server where the node's own override tells it to listen (/etc/smart-node/local/smart-node-doci-mcp.env); the update of a node that routes it to its VPN stopped there. The Tasks checks wait for the Planner after its restart instead of failing at once.

[1.13.3] - 2026-11-07

  • The install in a browser page (tools/web-install/server.py): one launch, a page opens within a second and asks how the AI will work (Claude subscription or API key), what to install (Simple, Full or Custom, the modules as tiles), then shows each step with the installer's own output beside it, can be stopped, and opens Studio's first-run page when it is done. The terminal installer asks the same one question instead of a module list (--ai), and Flint is on every node: an install with no module list used to leave it out.
  • Studio is the name of the place people work in (it was called the Workspace; it lives on studio.<domain>). The install steps and modules are named for what they are: Authentication, Routing, Secret store, Flint runtime, Claude Code runtime, System operations.
  • First run: the owner's password is made readable and shown once, with a copy button; before, the node made one nobody could ever see. The AI step offers only the ways this node has, with a sliding switch when there are several, and no choice of runtime. Looks that read as people come first among the avatars, the four steps are equal, screens change softly, and the theme can be switched on every step.
  • Signing in and out: Sign out from Studio and from the panel works (it was refused for everyone: no CSRF token). The password is changed on the sign-in settings page, which Studio's Settings now link. The password form shows on every node, a local one too, with "Forgot password?" under it. One form signs up the owner: the panel's own /setup page is gone. Studio, the panel and the sign-in pages share one theme.
  • The setup agent asks first whether the node is for a business, for the owner's own life (personal assistants), or both, and an assistant that gives medical, legal, financial or psychological advice says when a professional is needed and never presents itself as one.
  • The panel's agent page: Save and Discard stay where they are while a card is edited, and outcomes show as a toast.
  • Module order: Documents is installed after core-api (it needs it); Tasks no longer brings Documents along.
  • ChatGPT subscription as an AI provider, built but not working yet: in the first-run page (and through core-api) the owner signs in with their own ChatGPT plan, and Flint agents are sent to it through the gateway. Tried on a real account on 2026-11-07: the sign-in and the consent go through, then OpenAI refuses the code exchange (invalid_grant, no reason given), also when the code is exchanged at once. The request is the one OpenAI documents. Not supported by the plan even when it works: hosted MCP tools, image generation.
  • New chat in the Workspace: the people to talk to lie in a grid of faces (on a phone as well), and the agent picker uses up to four columns and scrolls. The composer no longer collapses to zero height when it grows past the screen.
  • Chat reads only what is new, and draws an answer relayed during a turn while the turn is still running.
  • The admin panel's AI page has a tab beside Active sessions with the model requests: the tokens each step of a turn sends and gets back, newest first, and a session's own requests from its detail row.
  • The agent card: MCP servers and tools can be switched off what the model is offered, Channels lists only the channels this node runs, and Tools is one tree with Read, Write and Delete on one line instead of chips and a grants table.
  • Limits: Notify is a switch.
  • The admin panel's menu no longer grows on every page load.
  • An agent can set a repeating task for itself and it starts without approval (self-alarm).
  • Module manifests carry no internal product names in the text people read.
  • The panel pages now name their script and style files with a fresh version, and the panel version is raised (0.8.14). Before, the panel image was rebuilt only when its version changed, and a browser kept the old script for four hours against the new page, so a new tab showed but could not be selected.

[1.13.2] - 2026-11-05

  • A message sent twice is answered once. The Workspace remembers the answer to a chat send for a minute, by the turn id the page gives it, so a double tap or a retry after a dropped connection gets the first answer back instead of creating a second inbound message. Only a successful answer is remembered; a failed send can be retried.
  • A reply that comes back with an empty body is read from the stored history before the page gives up waiting.
  • A turn that used tools and ended without any text no longer ends as an empty answer: the chat shows one service line saying the turn ended without a reply.
  • When the gateway refuses a send because the session is not open (it stores nothing), the person is told it was not sent. It is no longer shown as a turn that is still working. A refusal because a turn is already running is still answered as working.

[1.13.1] - 2026-11-04

  • The admin panel's menu on a phone shows its items again. The page blurred and no menu appeared: the frosted top bar was the frame of the fixed drawer inside it, which was cut to the bar's own height, and the dimmer sat over the bar and the drawer. The blur is now a layer behind the bar and the dimmer is under it.
  • An install or update no longer takes the agents' own folders (logs/, state/, work/) away from the agents. The core-api stage chowned the whole agents root to the service user, and nothing handed the folders back, so after every update an agent could not write its own work/ (on a node that had been updated, every agent was refused). The stage now gives each agent's three folders back to it. Found by the e2e permissions check on a stand.
  • The admin panel is an installable app too (Add to Home screen): manifest, icons (the mark dark on light, so it is told apart from the Office icon), a service worker that keeps only an offline page, and a route of its own so the browser can fetch those files before it has signed in. Panel 0.8.11.
  • Work Map on a phone: pressing Direction, Tasks, Agents or 24h/7d brings the board into view (it sits below the title and cards, so the press looked like it did nothing), and the top bar is one row that stays in place.
  • Calendar: the picked day is a soft rounded tile instead of a square frame.
  • The sidebar no longer has a "Projects" section: it had no backend and was always empty.
  • Loading looks finished: the word "Loading..." is gone from the Work Map, the task overview, the task list, task detail, Settings, Documents (tree, recent, reader, preview), the agent page and its tabs, the chat side panel and the avatar picker. Each shows the shape of what is coming, shimmering, so nothing jumps when the data lands. The Agents page used to stay blank until every agent's channels had been fetched; its cards now appear at once and each agent's contacts fill in as they arrive (and are kept between visits).
  • Pull down from the top of a screen to refresh the app (the screen follows the finger down, and a thin line at the very top of the display fills as you pull and runs while the app reloads its data): it reloads the page when a newer build is out, and otherwise opens a new live connection and reads everything again. The installed app has no reload button, and the browser's own pull-to-refresh does not fire because the screens scroll inside the page.
  • Work Map on a phone: the top bar wraps, and the chips and signal cards fit the screen instead of running past the right edge.
  • Work Map follows the light and dark themes (it was dark only), and opens in about 1.5 s instead of 37 s: the map no longer reads and decodes the permission checks, planner reads and cron events that components and the system write, the planner's task list and task logs are read in parallel, and the event reads run beside the planner reads. The event count, the last event time and the raw tail are still about the whole log.
  • Workflows on a phone: the workflow cards no longer run past the right edge of the screen.
  • Settings has an About card with the node release and the interface build (and says when the open tab is older than the server). /api/version returns release beside build.
  • Chat: a live socket that died quietly (a phone app put to sleep) is replaced. The server sends a tick every 25 s; the page opens a new socket after 70 s without one, and when it returns into view with a stale one. Before, "Waiting for ... to start" and "Thinking" counters could stay on screen for half an hour after the answer had arrived.

[1.13.0] - 2026-11-01

  • Modular core: choose modules at install (install-on.sh --components, or a question at a terminal); the core is always installed. Modules are read from companions/*.manifest.json, and the Workspace, Settings and agents' instructions show what the node has. Adding a module to a running node is a re-run of the installer. There is no install button in the panel yet.
  • Flint is the default agent runtime for a chosen install; Claude Code is ticked at install. Running with no --components and no terminal still installs every module except Flint.
  • New Workspace shell, one live event stream, first-run page at /welcome/ with 17 avatar packs. On a local (*.localhost) node the owner has no password: smart-node-signin prints a one-time link.
  • Reminders are in the core (remind_me, Calendar), no Tasks module needed.
  • John, the configurator, can create agents (create_agent, update_agent, delete_agent).
  • A failed wake gives its messages back: a provider outage no longer marks them unhandled for good.
  • A wake's answer is its final text, never the working notes. A blank result is not a blank reply.
  • An HTML preview in a reply loads nothing from outside.
  • A new node whose Workspace does not answer is a failed install. Downloads are tried again.
  • Still broken: agents in a chain do not stop on their own and can invent decisions, so do not rely on teams of agents yet. A chat keeps "Waiting to start" for up to 24 hours when an agent cannot start. A person with role user can see and cancel others' reminders.
  • Authum 1.0.7: the image is built on php:8.3.36-fpm-alpine, pinned, instead of the floating php:8.3-fpm-alpine. 8.3.36 fixes CVE-2026-109618 and CVE-2026-109619 (unauthenticated remote code execution). The floating tag could not deliver the fix: B05 builds the image once per Authum version and docker build reuses a cached base, so nodes on 1.0.6 kept PHP 8.3.33. The version bump makes B05 rebuild on the next update.
  • sn-op 0.6.0, the sysadmin wrapper: a verb table in a root-owned file (run, verbs), dropin-install (a validated systemd drop-in for an existing smart-node unit), route-install (an internal Traefik route under an allowlist: one Host on the node's internal domain, websecure, tls, an access middleware, an upstream on the host at a port from 1024) and ufw-allow-docker (one TCP port, inside a range the node sets, opened to the node's Docker network only). The last two read the node's own settings from root-owned files, /etc/smart-node/sn-op-route-domain and /etc/smart-node/sn-op-app-ports; without them they refuse. All three install verbs are Tier B: sha256-bound where a file is involved and an approval task is required.
  • Planner MCP: an agent can file a recurring task and manage the series. planner_file takes recur_interval and next_run, and the new planner_recur changes the interval, moves the next run or ends the series; both describe the whole mechanism themselves (reminders, who is woken, the approval rule, the one-off reminder recipe), so an agent learns it from the tool.
  • The Runner no longer marks an agent broken after failed wakes. A wake that did not run (provider limit, timeout, upstream error, or a request the gateway refused) is retried with a doubling pause, 60 seconds up to RUNNER_WAKE_RETRY_MAX_BACKOFF (300), and the agent stays claimable; every try is an agent.wake_failed event with the reason and the pause. A failed wake no longer counts as a reminder for an unread message. The wake harness (companions/brin/tests/e2e_wake_resilience.py) checks all of it and fails on the old Runner.
  • Planner MCP: planner_next_task no longer hands a reviewer the work in flight of someone else. An in_progress task and a new one are the assignee's to start; a review waiting on you is yours as the reviewer. A stalled task with no assignee used to be handed to its reviewer as the next thing to do. planner_my_tasks still lists what you hold in either role.
  • Source tests: tests/run-source.sh picks a Python that has what the tests import (fastapi, httpx, psycopg2, requests, pytest) instead of failing on a bare system python3, and three tests whose stubs had fallen behind the code (httpx classes the door builds on, openai_relay, the names _complete_turn_async takes from its module) load again.
  • Gateway: a 429 from the Anthropic account no longer stops every agent. With SN_ANTHROPIC_FALLBACK_MODEL set, the first 429 opens one breaker for the node and the request that met it is sent again through OpenRouter (the Anthropic-format endpoint, key from the secret store) with only the model changed; the next requests go there directly until SN_ANTHROPIC_FALLBACK_COOLDOWN_SECONDS (five hours) or the limit retry-after has passed. Only the node's own Claude requests are rerouted. No model configured, nothing changes. The raw capture keeps what Anthropic said apart from the answer used.
  • Gateway: optional raw capture of model requests, for diagnosing what an agent sent and what it got back. With SN_MODEL_CAPTURE_ENABLED=true every metered request that passes the door, through either entrance or the gateway own providers, is written to its own directory under SN_MODEL_CAPTURE_DIR (default /var/log/smart-node/gateway/model-capture): request.body, response.body and meta.json. It is a diagnostic with a clock, not a log: it runs for SN_MODEL_CAPTURE_WINDOW_SECONDS (a day) from the first request, survives a restart inside the window and sweeps what is older. Directory 0700, files 0600, no credential is written. Off by default.
  • Flows: the import door publishes a node's own flow again. flow-lint.py re-executed into the engine venv only when PyYAML was missing; a Debian system python has python3-yaml and no jsonschema, so S0 refused every flow the door was given ("jsonschema is not installed"). It now also hands over when jsonschema is missing. Test: tests/flow-lint-engine-python.test.sh.
  • Planner: recurring tasks. A task carries recur_interval and next_run; a sweep every five minutes (tracking 0.5.12 installs the cron line) reopens a completed cycle, keeps the owner's approval and wakes the assignee. A person gets "Recurring task due" when a cycle comes due while the previous one is still open (core-api notify event recurring_due).
  • The planner text an agent reads says to write with the planner tools (planner_comment, planner_advance, planner_file) and keeps curl for reads. A curl with a body is refused in a run with no operator attached, so the comments and moves agents sent that way were lost. A new agent gets the corrected text; an existing agent gets it when its instructions are regenerated.
  • HITL: a request whose recipient was rebound after it was asked is replaced by a fresh one, not returned for ever with an actor the delivery worker refuses. The bridge can check whether a request was delivered (it traverses delivered/, mode 2710, and still cannot list or write it).
  • The gateway checks every model request: an agent stopped or a budget spent in the middle of a long turn ends it at the next request. /api/v1/chat is held to the budgets for the first time. A key the gateway did not issue is no longer forwarded by /anthropic.
  • Every model request on the node is in one record: the gateway's own requests (/api/v1/chat, the HTTP session backends) are now written to sn_core.model_calls per request, beside the agents' own.
  • Flint reaches the model through the gateway, like Claude Code: it holds a gateway token instead of the provider key, its requests go to the gateway's new OpenAI-format route (/openai/v1) and each one is recorded in sn_core.model_calls. The key stays in the gateway. Needs a Flint build that reads FLINT_BASE_URL.
  • The node speaks the planner's three statuses everywhere. Since planner migration 0010 a task is queued (with a wait_reason), in_progress or closed (with a close_outcome), but the wire still answered in the eleven old words unless a reader asked, so agents were told and shown the old ones: their planner tools described a transition table that no longer exists, a flow's description told the filer to "file with status open", and an agent diagnosing a stuck task wrote that "legal transitions from awaiting_approval do not include open". Now tracking.sh sets PLANNER_STATUS_COMPAT=new, the agents' planner tools (mcp_planner.py, the planner_advance API tool) and the planner usage text speak queued / in_progress / closed with the reasons and outcomes and the guards the planner actually applies, planner_advance takes wait_reason and close_outcome, and planner_my_tasks / planner_next_task leave out tasks queued for someone else's move (approval, a person, a date). Every reader in the release that compared the wire status with an old word is moved: the Runner, the TaskWatcher, the project card (waiting for the owner, closed per goal), onboarding-seed, the release scope gate, the office task list, the hitl guards and srv-skeleton task-list.sh. The shipped flows say status: queued, wait_reason: review and stop on error as queued, wait_reason: error; flow-lint warns on an old word and names the new one. The old words stay accepted on input and readable as stage.

[1.12.52] - 2026-10-16

  • Nothing about one particular owner is left in the product. The daily event digest was addressed to a named person, fell back to sending as a named agent, and counted its day in a pinned operator zone; it could not be delivered on any node (every attempt ended in "no enabled 'email' mailbox for agent 'admin'", because the caller authenticated as the admin account whatever sender it named). It now queues through the new POST /api/owner-alert, the same letter the budget and turn guards send: from the node's own sender to the owner's email channel as Settings has it, 409 when either is missing, and the digest then takes its existing fallback. Its day and its 09:00 are the host's local time. configure-host.sh no longer sets every host to one zone on every install and update; it sets one only with the new --timezone (install-on.sh passes it through), and the documents service and the skeleton log helpers use the host zone too (host_zone in lib.sh). tests/node-agnostic.test.sh refuses a zone name or an owner's name in runtime code from now on.
  • A node declares the state directories it adds itself in /etc/smart-node/permissions.local.list, same format as bootstrap/permissions.list. Before, a group-writable directory a node created for its own flow stopped every update at the permissions step, and the release had no place to declare it. The node list is held to three rules: root-owned and writable by root only, or it is refused whole; entries only under /var/lib/smart-node or /srv; and it can only add, so a line for a path the release declares is ignored and the release mode still applies. tests/permissions-local-list.test.sh runs the stage against a scratch tree inside a user namespace.
  • The HITL bridge now starts on a node where /run/smart-node/hitl does not exist yet. Its unit listed that directory in ReadWritePaths and created it from an ExecStartPre, but systemd builds the mount namespace first, so the unit stopped with 226/NAMESPACE and the legacy HITL adoption rolled back. The directory is now declared in /etc/tmpfiles.d/smart-node-hitl.conf and created before the units start.
  • A full install or update applies the permission surface once, at the end, and no longer after every companion. The pass after each of the 13 companions cost about a minute apiece on a node with large agent homes and repeated what the closing pass before validate already enforces, fatally. The closing pass is unchanged.
  • An update no longer reinstalls a companion whose version and source are unchanged. The installer already meant to do this (it compares STAGE_VERSION with the node's record and runs --contracts-only on a match), but it read companions.d as the admin user, the directory is root:smart-node 2750, the read failed without a word and every update ran all 13 companions in full. The record is now read as root, and the skip also needs the same source hash (script, sidecars, environment string), written to /var/lib/smart-node/install-src/<name>.sha256 after an install that succeeded, so a companion changed under the same STAGE_VERSION is still installed in full. The first update after this release has no hashes and runs in full; the ones after it skip what did not change.

[1.12.51] - 2026-10-16

  • The node's sysadmin and foreman store credentials and grant secret refs themselves. The secrets MCP server offers set_secret(ref, value) and grant_secret_ref(agent, ref) next to resolve_secret; a grant is a merge that adds the ref and the read-only secrets tool and leaves the rest of the colleague's grants alone. Policy stays in core-api: writing the store or a secrets grant admits only capability sysadmin or configurator (or an operator), the grant also needs agents.grants.write, and any other agent gets an audited 403. The seeded secrets contract says so, and the server no longer raises at shutdown on MCP SDK 1.x.
  • A planner task holds files. POST /api/planner/api/v1/tasks/{id}/attachments stores one (raw bytes, X-Filename, Content-Type, as the office chat upload) under /srv/data/attachments/tasks/<id>/, through the scan stage; GET on the same path lists them, and /api/attachments/{id}/content serves one to whoever the planner serves the task to. The same file on the same task again returns the row already there, so a delivery job can retry. B02 adds task_id to sn_core.message_attachments with an index, and the one-parent check now counts a message, a desk or a task; an installed node's two-parent check is replaced on update.
  • The office task card has a comment box. A stuck task can be asked about from the office: @name in the comment tells that actor through the planner's mention notice (the name is lower-cased, as actor ids are), the comments are newest first and follow live while the card is open, and each has Reply.
  • An agent can open a file mailed to it. The email ingest announced an attachment in a shape brin does not rewrite into the fetch command, and stored every mailed file as received, which the attachment API refuses. The body line is now the dispatcher marker ([attachment: name, mime, N bytes, id UUID]), and each file passes the scan stage before its row is written: a sender the contact gate trusts gets approved, anyone else received, and the journal gets attachment.stored.
  • Office installs as an app (PWA) on a phone or a computer. Its manifest, icons, service worker and offline page are served without sign-in; nothing else changes behind smart-node-auth. A phone needs to trust the node's certificate (on a node with its own CA, install the CA on the phone first).
  • Documents run natively. doci is served by Apache with mod_php from the distribution's packages (smart-node-doci.service, as www-data on :8060, reached by Traefik over the Docker subnet only) and doci-mcp from a venv (smart-node-doci-mcp.service, 127.0.0.1:8200), instead of two images of 801 MB and 261 MB. The documents stage takes about 32 s instead of about 100 s, and a node uses about 510 MB less. An update moves an existing node over on the same files, database and secrets (about 3 s without documents) and removes the images. The release no longer builds, pushes or documents doci images: tools/build-images.sh and companions/IMAGE_DIGESTS are gone and release.sh --publish needs no assets.
  • An agent can answer a message with silence. A final answer of exactly NO_REPLY (case, brackets and a full stop forgiven) completes the turn and delivers nothing; before, any closing text was mailed to the whole thread and an empty answer failed the turn, so agents copied on one thread kept answering each other.
  • A clean install no longer comes up without its first agent. admin-runner kept its database connections across the cluster restart the documents stage makes, and the next request, the one creating the setup agent, failed on a dead connection. A pooled connection is now checked and replaced when dead. Whether an install hit it depended on a timer firing before that restart.
  • The panel has the pages it lacked. Planner edits the task-status dictionaries (moved out of the office Settings), Memory searches the node's memory by meaning (super-admin only, core-api /api/memory), Workflows is read only and shows each flow's steps as text, and Settings shows the node, its policies, who can sign in and what each role may do (core-api /api/node/about, /api/node/access). The owner switches a workflow off and chooses which agents may start it; the Runner starts no new run of a flow that is off. Errors read in words instead of [object Object] or a bare status. scripts/panel-smoke.mjs loads every page read only and fails one that throws, calls an /api that fails, or stays on Loading. The panel image is 0.6.9 and is built on the node during the update.
  • Secrets and policies created from the panel are stored. A new secret was a 500 (its note was NOT NULL and the store passed none), creating a policy was a 422 and editing one a 405, and a policy created switched off went live in every prompt.
  • A task has three statuses, queued, in_progress and closed, with why a queued task waits and how a closed one ended as two dictionaries the owner edits (planner migration 0010). The Runner starts an approved workflow task on the planner's own approved_at instead of a tag set by hand, and an agent can list the tasks of a status across every holder (planner_list).
  • An office chat message is answered however long the turn runs. A turn past fast-dispatch's 120 s wait was marked failed while the agent went on working, and its answer had nowhere to go; one slow agent also held every other chat. Messages a person writes while the agent works are read together in its next turn.
  • The turn limit ends the turn, not the session: the next message continues where the work stopped instead of starting over. Stop and resume hold under load, the process cap refuses a turn instead of failing it, and a live process says what it waits on.
  • Office chats look and work like a messenger on a desktop and on a phone, with authors, replies, quotes, unread counts and @mentions: an @name in a chat wakes that agent, and its answer comes back into the chat as "Answer from <agent>". Tasks are cards on a phone and filter by assignee with chips; a task link opens the task without an empty chat column. Admins find the node panel from the office Settings.
  • The source carries no OpenRouter key, and code nothing calls on the agent path is gone.
  • An agent is no longer left busy for half an hour after the Runner restarts during one of its wakes. The Runner kept its claims in memory, so a restart forgot them and the agent stayed deaf until the lease ran out. On start it now takes back every claim a previous Runner left and releases it as soon as the gateway says that turn is over.
  • When the Runner gives up waking an agent for a message (every wake ended with it unread, for instance cut by the turn limit), the colleague who wrote it is told, once, and the journal has message.unhandled. The message stays open. Until now only agent.wake_exhausted recorded it, and whoever was waiting heard nothing.
  • A turn that failed is no longer taken for an answer. When the provider kept refusing (529 on every retry) the gateway said the turn failed, but brin passed it on as a reply: the Runner logged the wake as done and nothing reached the journal. It is now a failed wake, retried on the usual backoff and recorded as agent.wake_failed.
  • A message to a stopped agent waits for it instead of disappearing. It used to be routed as "no agent" and closed: after the agent was started again nobody answered it, and nobody had been told. Now it stays queued and is answered once the agent is started; an agent that wrote it gets a note that its colleague is stopped, and a person on Telegram or email is told once that the assistant is paused (message.held in the journal).
  • A database stop no longer leaves the node half down. core-api, the planner, mesh and the mesh MCP sidecar are stopped with the cluster they require, and until now nothing started them again when it came back: the node stayed without its API until someone noticed. Each is now also wanted by what it requires, so starting the cluster starts them. The update re-enables the units, nothing to do by hand.
  • An answer is no longer lost when its channel is briefly down. A send that fails for a reason that passes (Telegram or Slack answering 5xx or 429, a timeout, a dropped SMTP connection, an SMTP 4xx) is tried again after 30 s, 1, 2, 4 and 8 minutes, each try a message.send_retry event; only then is it failed and the agent told. A refusal (bad address, 4xx, a guard) still fails at once. Until now every failed send was final on the first try.
  • A CLI provider row that runs the Claude Code binary is a backend of its own: an agent can be put on a second Anthropic-compatible upstream (a local model server on a test node, another account) with a row, a catalog entry and the agent's model, and the gateway routes that agent's model calls there. No code, no second relay.
  • The node has one secret store. The gateway's provider keys and the integrations agents use live in one encrypted table under one key; the Secrets page shows every credential with where it is used, who may read it, who set it and who read it last, and lists the reads it refused with a Grant button. After the update, the old sops file is imported once and no longer read. Do not delete it: the secrets stage recreates it and classes-verify expects it. To drop the old values, replace it with an empty encrypted file (see docs/upgrade/1.12.51.md). sn_config.gateway_secrets stays one release as gateway_secrets_migrated.
  • Any agent can be stopped from the panel, and the Agents page says what each one is doing right now. The Now row on a card comes from the runtime's own process table (a turn in flight and its current tool, or idle for how long, and the last model call); Stop ends the agent's processes at once and disables it, so nothing wakes it or answers in its chats until Enable. A disabled agent now runs no turn at all.
  • The gateway is two processes: the door (smart-node-gateway.service), the one address for every model call of the node, and the runtime (smart-node-runtime.service), which owns the agent CLI processes behind it. Callers keep the door's address; the door forwards session and CLI traffic to the runtime. A gateway restart no longer ends agents' turns, and the door runs without the right to gain privileges. The agents' model tokens live in sn_core.model_tokens as digests.
  • Every model call of an agent's Claude Code process now passes through the gateway and is recorded per agent and session (sn_core.model_calls). The process receives a token of the gateway instead of the node credential, so the credential no longer enters any agent's process, and the gateway holds each process to the model its session was created with. The wrapper's stdin frame carries the token; MODEL_RELAY=false in the gateway's environment restores the direct path.
  • Settings a node sets for itself survive an update. Every smart-node-*.service now loads /etc/smart-node/local/<unit>.env after its own environment files, so a value there wins over the release's, and the installer never writes, rewrites or deletes anything in that directory. Before, a value set by hand in a release-generated file (fast-channels.env, a companion's .env, hitl.env) was gone after the next update without a word. bootstrap/local-layer.sh adds the drop-in zz-local.conf to each unit (before the permissions stage, every install and update) and touches no other drop-in; --verify reports a unit without it. The runbook says where a node's own settings go (docs/runbook-update.md).

[1.12.50] - 2026-10-12

  • Office chat while an agent works. The reply shows the agent's text and one line under it with what the agent is doing now; that line opens a console of the commands the turn has run and closes it again. A long command no longer reads as "Reconnecting", commands are no longer listed twice, and the empty space between the agent's phrases is gone. Every message can be copied as text or as Markdown from a control shown beside it on hover.
  • A workflow moves its own task. The Runner starts a workflow and steps it, and no longer writes the task's status or assignee for it. Each block's hand-off is written by the workflow's own hook (logic/planner_effect.py), the first block takes the task, and the last block says how it ends: a content or development workflow ends by handing the task to a person for review. A block that fails is handled by the workflow's on_error: the task goes to blocked, with the error as the reason, to the person the workflow names. Before, the Runner applied the workflow's planner.on_block map itself and kept its own record of what it had applied; on a waiting block that record was a new entry every tick, and one hand-off was written every few seconds for three hours.

If you wrote workflows of your own: a workflow that declares planner.on_block and has no post: logic/planner_effect.py on its blocks will run and never move its task. flow-lint now refuses such a workflow (rule S12) and names each block. Copy logic/planner_effect.py and logic/on_error.py from a shipped workflow, add the post line to every block that declares a hand-off and on_error: logic/on_error.py at the top, declare a status on the blocks the workflow ends in, and publish the workflow again.

  • An agent is woken for a task by a message that names the task. An assignment, a new reviewer or a change of status used to raise one mark per agent, which said neither which task nor why, and several of them raised while the agent was busy became one. Now each puts a message from the node in the agent's inbox: which task, and the reason. One open message per agent and task.
  • A message an agent left unread is delivered again: up to three times, a minute after the agent's turn ended each time, and then the node says so with the event agent.wake_exhausted and stops. Before, a message the agent did not get to was never delivered again unless something newer arrived.
  • A comment that mentions somebody tells them. Write @name in a task comment: an agent gets a message that the comment is addressed to it, a person gets mail and chat. A name inside code or a quoted line is not a mention, and the author is not told of their own comment. A workflow's work order now mentions its agent, so a second order to the agent that already holds the task reaches it.
  • Workflows can have time budgets. A workflow that declares schema version 3.4.0 may set time_budget on a block and on the whole run. A block that waits for an agent who never answers runs out of its budget, the workflow's on_error runs, and the task ends in front of a person with the reason. A new timer, smart-node-flow-sweep, checks the clock once a minute, and every check is in the event log: flow.sweep_started, flow.sweep_finished, flow.time_budget_exceeded, flow.sweep_failed. No shipped workflow sets a budget yet; a workflow without one waits as long as it is left to. Two runs started in the same second get a directory each.
  • A request between agents can now require an answer. An agent that asks a colleague for something sets needs_reply on the message (send_message in the messaging tool, --needs-reply in comm.sh send). If the colleague ends its turn without answering, the request stays open as awaiting_reply instead of being closed. The node reminds the colleague with a message in its inbox every 10 minutes while it is free, and leaves it alone while it is in the middle of a run. After 3 wakes without an answer the asker is told that the colleague did not answer, the request is closed with the tag obligation:unanswered, and the journal gets message.reply_overdue. A reply, a message back to the asker, or the colleague dismissing the request closes it. The interval and the number of wakes are SN_REPLY_WAKE_WINDOW_SECONDS and SN_REPLY_MAX_ATTEMPTS in the core-api unit. A reply that only promises an answer later closes the request too: the node does not track promised deadlines.
  • A person can be asked to decide, and the answer is signed. The optional HITL companion installs a decision service on the node: an agent or a workflow asks a question with ask_human, the task goes to the person, the person answers in the browser and signs with a passkey, and the task comes back with the answer in its log. It is installed only when the installer is given --hitl-origin https://<name>; passkeys bind to that exact origin, so choose it once. Three services run it: smart-node-hitl, smart-node-hitl-bridge and smart-node-hitl-delivery. A node that already runs the earlier Docker build of the service is not touched until the installer is also given --hitl-adopt-legacy; the adoption backs up the database and both caller states first, and hitl.sh --rollback-legacy returns to the container. A workflow that waits for signed answers gets its poller and its cron entry from the installer when both the workflow and the service are on the node.
  • Flint can run an agent. It is an optional runtime beside Claude for v2 sessions, off until the gateway is installed with SMART_NODE_FLINT_ENABLED=true, and an agent uses it only when its model is flint-cli/<model>. The provider key is passed to the process at spawn and is never written to the agent's environment file. companions/gateway/FLINT.md has the steps. Nothing changes for an agent that stays on Claude.
  • A turn in progress can be steered. A message sent to an agent while it works reaches the running turn instead of waiting for the next one, and the desk shows the reply as it is written.
  • A message waiting in the desk queue can be cancelled before the agent takes it. This is new in this release and has run in tests only.
  • The planner asks about a task nobody is working. A task left in_progress with no activity gets a reminder to the agent that holds it, and one notice to the owner if the reminders change nothing. A reminder wakes an agent and never messages a person: a person holding a task is not written to on every scan.
  • The owner is no longer sent the same approval notice on every step of a workflow run. A workflow's write between two of its blocks is not a request to the owner.
  • An agent called into a long task can read what it was called for: a task log can be read one comment by id, the newest few, or by text.
  • A model call follows the turn limit, and a turn that died is written to the journal instead of leaving the agent marked busy.
  • The owner gets one mail a day listing the hard failures in the event log.
  • The sysadmin agent can install and enable a systemd unit through sn-op (unit-install, unit-enable), and its default prompt says what the node gives it, so a monitor timer no longer needs a person at the shell.
  • Workflows in the Office: the graph runs top to bottom, the workflow page is a studio with the graph, the run history and the block detail, and a workflow waiting for its reviewer reads as awaiting review, not as running. The reviewer's Close button shows when the task names the owner by handle.
  • Fixed: publishing a workflow through core-api dropped kind, phase, depends_on, parallel and max_runs from its steps. A user with the work view enabled was refused it because the user role lacked work.read. A service MCP that reads its own credential over the unix socket was refused by the role check before its own rule was asked; an OS account listed in SN_SECRETS_OPERATOR_USERS now passes for secrets.read and for nothing else. A specialist written by slug is refused when two active rows share the slug. The messaging tool's contract says that ok: true means queued, not delivered.
  • The workflow engine is Rein 3.4.1. In step mode a block whose script ran longer than five minutes was started a second time next to the first; a step now waits for the script or stops it. A time budget that runs out stops the script and everything the script started.
  • Known: core-api reads SN_DOCKER_CIDR and the installer does not set it, so the Docker network is trusted only where SN_TRUSTED_CIDRS names it. That is the behaviour of earlier releases too.

[1.12.49] - 2026-10-04

  • Every action on the node now passes a role check. An account or an agent holds one of three roles: super-admin (the owner), admin, or user. Agents whose capability is configurator or sysadmin are admin; everyone else is user. Every core-api route and every admin-runner operation declares the permission it needs, and core-api refuses to start if a route declares none. The configurator can create and configure agents without the owner. Publishing a process needs admin. An agent's contacts are edited by the owner only. Writing secrets and reading snapshots are open to admin.
  • A request that changes something is refused when its only identity is a Remote-User header sent over TCP. There is no switch for this. The node's own services prove themselves with a service credential, the installer and host maintenance use the unix socket, and a browser session is proved by the proxy. A script that wrote to core-api by naming the owner in a header stops working: use the unix socket as root or an operator token.
  • The owner can register a remote operator and issue it a bearer token. The token is shown once and stored as a digest. See docs/operator-actor-credential.md.
  • The configurator builds, registers and runs a process from the node flows directory without root. A process is published through core-api, and publishing from another agent's directory is refused.
  • Office shows where work is going: who is working on what now, and the hand-offs between agents. Agents read the same view through the work_now tool.
  • An agent is woken either for one named task or for the single most important one by priority and ETA, not for its whole list.
  • The messaging tools carry the email fields core-api already supported: subject, cc and reply-to-sender-only.
  • The panel names AI providers by a display name and keeps their ids as keys.
  • A turn in flight is no longer idle to the session reaper. The reaper judges idleness by the session's last activity, and a turn wrote none until it ended, so a turn longer than fifteen minutes was killed while it worked. Every reclaim of an agent process now leaves a session.reclaimed event naming the agent, the reason and how long the turn had run.
  • Business-specific integration files no longer ship in the core repository. The existing node-local MCP registration, wrapper and agent grants are left in place on update.
  • One limits registry now supplies agent spending, unattended wake caps and turn length. The panel shows node defaults, agent overrides and a node pause; a cut turn leaves a chat line, journal event and owner alert.
  • Limit actions in the panel and API now match enforcement: turn length accepts pause or refuse, and ask owner is unavailable until its HITL flow exists.
  • Agent roster changes reach every colleague's Team section, and saved Knowledge reaches the agent prompt. Unknown tool grants are refused with an audit event; registered MCP servers gain grantable catalogue rows, and secrets retains its prompt contract through grant edits. Agent budgets are disabled on archive.
  • Install fixes: seed-manifest budgets now apply instead of ending in a warning, and the planner key probe retries on a slow host instead of failing the install on one four-second attempt.
  • Still open. The default turn ceiling is 600 seconds; an agent whose turns run longer is cut at ten minutes until the owner raises its limit. An admin who is not a participant of a desk cannot join it yet. Gateway notices name the owner by a fixed account name and are refused on a node whose owner is called something else. A background command that an agent leaves running when its turn ends is killed with the idle process fifteen minutes later. Approval by a person (HITL) is not in this release.

Earlier releases


Before 1.0

No version numbers on any of this, and no alpha or beta releases to list, so none are invented here. Dated from the commit record.

Packaging it · 2026-05 to 2026-08

The point at which an internal build became something that could be installed somewhere else.

  • 2026-08-01 An external mail server becomes a first-class channel, so a node uses the mail you already have.
  • 2026-07-29 v0.1.0, the first tagged release of the installer itself: one repository, one command, a node that comes up working.
  • 2026-07-28 Agents send messages to each other and relay the answer back to whoever asked.
  • 2026-07-24 Node versioning, and the catalogue of what a node can do is assembled into the agents' prompts from one list.
  • 2026-07-23 First-run setup: the owner creates their own account from a one-time link. No preset login ships.
  • 2026-07-16 golden-0.5.0: a node deployed from a prepared image in minutes, and a public demo node behind it.
  • 2026-07-14 A node ships with a configurator agent that interviews the owner and builds from the answers.
  • 2026-06-16 First tests.
  • 2026-05-22 The components move into repositories of their own: gateway, messaging, voice, documents.
  • 2026-05-16 The rest of the base install, then the companion installers in one run: gateway, memory, tasks, documents, workflows, messaging, mail, agent runtimes, voice.
  • 2026-05-15 First commit under the name Smart Node. Installer and the first base stages.

Building the parts · 2026-02 to 2026-04

Each was written to solve a problem in the office it was running in, and each later became a companion service a node installs.

  • 2026-04-20 Tasks and objectives.
  • 2026-03-11 Virtual desktops, so an agent can work software that has no interface for it.
  • 2026-02-23 Semantic memory.

Where it came from · 2025-12 to 2026-01

  • 2026-01-23 The first agents put on real work, and a touch interface for the production floor.
  • 2026-01-22 Agents get a home on disk and a set of shared tools, and one gateway in front of the models.
  • 2026-01-16 The base is standing: containers, routing, internal DNS, HTTPS, a secret store.
  • 2026-01-15 The first architecture document. Everything above follows from it.
  • 2026-01-01 The earliest code in the project: an experiment in getting several agents to work together.
  • 2025-12 The idea, worked out over the Christmas break. No code, and nothing to show for it yet.

What is not in this history

Other commits from 2025 exist in the estate and belong to unrelated business software. They are not part of this project and are not listed here.

Reviewed 2026-11-09. Older than 90 days counts as broken. Something here wrong? Tell me