One Download, No Docker, No API Key: Two Weeks of Agentic-Nets

The last two weeks gave Agentic-Nets a desktop body. One installer now puts persistent memory, a real scheduler, and a pair of hands underneath the AI assistant you already pay for: no Docker daemon, no API key, no server-side model. Around it landed the work that makes a local runtime something you can trust: schedules that fail closed instead of lying, Windows updates that are proven safe in CI before every release, cryptographically signed downloads, and a manual that teaches any MCP client how to build real agents on nets. Here is what shipped in releases 2.37.0 through 2.41.0, told through what it lets you do.

New here? Agentic-Nets is a workflow OS where AI agents and deterministic steps live in one executable Petri net: places hold JSON tokens, transitions do the work (transform, call an API, run a shell command, or think with an LLM), and everything is event-sourced and observable. The guided tour is the best first read, and the previous roundup covers how we got here; this post is about what is new.

The Release Map: 2.37 to 2.41 in One Page

The sequence reads as one story. First we made failure honest. Then we shipped the desktop runtime. Then three releases in a row made that runtime trustworthy: for schedules, for AI lanes without a server model, and for updates. The last release wrote the missing manual.

Install the Whole Platform Like an App

The use case: you wanted to try Agentic-Nets, but “clone a repository and bring a Docker daemon” is an afternoon, and you had a coffee break. Desktop Lite is the answer: download one package for macOS (a dmg), Windows (an msi), or Linux (deb and rpm, both architectures), open it, and a small tray app starts and supervises the full stack as native child processes on bundled Java and Node runtimes. Nothing else to install: no Docker, no Java, no Node, no Ollama, no API key.

What the tray is actually running is the real platform, not a toy build: the event-sourced node, the deterministic master, the OAuth2 gateway, a command executor, an MCP endpoint, and a credential vault that no longer needs OpenBao: on desktop it stores secrets as AES-256-GCM encrypted local files with a key generated on first run. Studio, the visual editor, is served at localhost:4200, and “Open Studio” signs you in automatically: a single-use link exchanges the admin secret server-side, so the secret never reaches the browser or your clipboard.

Two honest boundaries, stated up front. Everything binds to 127.0.0.1, deliberately: there is no switch to expose Desktop Lite to the network, because that is what the Docker and server deployment is for. And Desktop Lite is a local creator and operator environment, not the recommended production setup. It is the fastest way from zero to a running net; production stays on the server stack with monitoring, clustering, and remote access.

Your Client Stays the Brain

The decision that makes Desktop Lite different from “the server, but smaller” is who does the thinking. You already have something that can think: Claude Code, Codex, Cursor, or another MCP client you pay for anyway. What it does not have is a memory that outlives the session, a clock that fires while you sleep, and somewhere to put work so it can be picked up again tomorrow. Desktop Lite is that missing half. As its own manual puts it: your client stays the brain. Desktop Lite is the memory, the hands, and the clock.

Connecting takes one tray click. “Connect Claude Code” copies a ready command, “Connect Codex” copies a config.toml block, and “Copy MCP URL + Token” covers everything else; each comes pre-filled with the installation’s own bearer token. Start a fresh client session and open with the prompt the manual teaches: “Run readiness and tell me what I can do.” The answer walks the whole dependency chain, and from there the first useful thing is one sentence away: deploy the working-memory template and store a decision, and you have persistent, queryable memory that a scheduled net can process while you are gone. That round trip is the whole product in miniature.

The bundled master remains for a reason worth spelling out: it is the deterministic control plane. It binds and consumes tokens, applies inscriptions, runs schedules, records events, enforces execution policy, and completes externally executed AI fires. It simply does not call an LLM in the default profile. The intelligence is pluggable; the bookkeeping is not.

AI Lanes Wait for a Brain Instead of Failing Without One

Release 2.40.0 settled the semantics that make a model-free runtime livable, and the headline is what you do not have to do: nothing. Build a net the normal way. The AI lanes in it simply wait for something that can think. If you fire one by hand on a provider-less master, you get a plain refusal saying no model is configured, and your input token stays exactly where it was. Nothing is lost by being offline: the tokens sit in their input places and the work is pending. That is the whole reason work is stored as tokens rather than held in a conversation: an interrupted pipeline is paused, not failed.

Under the hood this is a semantic cleanup with teeth. The external marker now means one thing only: “I chose client-only execution for this lane,” and only an explicit set_external sets it. A master without a provider no longer marks anything; it skips its llm and agent lanes, which keep their normal lifecycle and stay discoverable. The previous behavior was quietly expensive: a provider-less master would fire the lane anyway, fail, retry on backoff forever, and, for any lane carrying the standard error-routing branch, consume real input tokens into error tokens on every cycle. That failure mode is gone.

Discovery got equally honest. When a client connects, readiness tells it that this session is the runtime for those lanes and how many are holding bound tokens, so a well-behaved assistant opens with “there are three AI fires waiting, shall I work them?”. scheduler_status marks lanes that will not fire unattended instead of letting a cron look armed and lively. A new roster endpoint lists every AI lane with a servable verdict and a named reason (master owns it, no tokens bound, capacity full, and so on), so “can I run this?” is a lookup, not a guess. And the CLI became a first-class lane worker: agenticos transition lanes lists them, agenticos transition serve runs one with the CLI’s own provider, all through the external-fire protocol, so the master still owns binding, emit rules, consumption, and usage accounting no matter whose model answered.

The Overnight Option

When you do want AI lanes running while you sleep, the tray’s LLM Settings opens a Studio card: pick a provider (disabled, Ollama, or Claude), set the tier models, paste a key that is stored with owner-only file permissions and always returned masked. Saving restarts just the master child in about ten seconds; no file editing, no full-stack restart. The trade is stated plainly in the manual: leave it disabled and your assistant does the thinking, which costs nothing extra and keeps everything local, but AI lanes only advance while you are there. Configure a provider and they run overnight, billed to that provider. Deterministic and command lanes need neither choice; they always run. One hard requirement either way: the machine has to be awake with the app running. Desktop Lite is a local runtime, not a cloud service.

Update (2.42): there is now a third path. An agent transition can run its reasoning through a headless Claude Code or Codex session on the same machine (llmMode “bash”), so a persona keeps working unattended with no server provider and no API key, billed to the CLI account you already have. The app probes whether the CLI is actually reachable before claiming this works.

Schedules You Can Trust

Release 2.39.0 exists because of a field report: an MCP client built a real scheduled data pipeline on Desktop Lite and documented every place the platform could mislead unattended work. The fixes are the kind you feel at 3 a.m. A malformed schedule now fails closed: an invalid cron expression, an unknown type, or a bad timezone never fires and never pretends; the lane reports an invalid-schedule state with the reason attached. Scheduler telemetry became honest: armed-at, last-fired-at, and last-success-at are separate timestamps, so “armed since Tuesday, fired zero times” is visible instead of deniable. Cron schedules accept an explicit IANA timezone, ending the daylight-saving guessing game. And the smoke-test tool no longer knocks over a running lane to test it: fire_once preserves running state by default.

The same wave made bulk work practical: add_transitions authors a batch of similar lanes with per-item results, delete_tokens requires a query and caps itself at 100 tokens per run (cleanup with brakes), and FOREACH lanes fan out per token with a bounded batch size in both master and executor. Desktop Lite’s MCP surface is also curated by default now: a first session sees the focused product tools instead of the entire native catalog, and one environment variable opts power users back in.

Windows, Done Carefully

Desktop Lite ships a Windows MSI, and 2.40.1 is the release where its update path earned trust the hard way. The failure it fixes was ugly: the updater launched the installer while background services were still shutting down, Windows Restart Manager cannot close windowless Java and Node children, and a cancelled half-done upgrade could roll back into no installation at all. The repair has two principles worth quoting. First, positive identification before killing anything: every spawned child is recorded with its process id and start instant (process ids get reused; start instants do not lie), backed by an evidence scan for executables under the install root carrying a shipped image name. A process that cannot be positively identified as ours is never killed; the update aborts and names it. Second, prove the upgrade in CI before shipping: every release now installs the previous published version on a Windows runner, runs it until Studio answers, seeds a canary file in the data directory, upgrades in place, and asserts the canary survived and the upgraded app serves. And a line that holds on every platform: updates never replace ~/.agenticos/, failed ones included.

Trust the Download

The tray checks GitHub for new releases daily, but GitHub is only transport. Every release publishes a checksum manifest with a detached Ed25519 signature, and the verifying key is pinned inside the launcher: unsigned or tampered releases are refused, full stop. A build-provenance file ties every asset to the exact tagged commits it was built from. On macOS the update stages the new app and swaps it transactionally after quit, with rollback if the new version fails to relaunch. None of this asks anything of you; it is the invisible kind of trust work.

The Boring Reliability Work, Continued

Release 2.37.0 opened the fortnight with the unglamorous fixes that everything above stands on. The master stopped storming the credential vault: peak vault connections fell from a measured 394 to 20, and a memory climb toward restart became a flat line. Six fixes closed cases where a lane could fail while its light stayed green: duplicate token consumption that could execute the same shell command twice, fires that moved nothing being logged as success, transport failures bypassing the error place, non-JSON HTTP responses losing their body, stopped transitions keeping token locks, and ArcQL comparing numbers as strings (a token with 9 points no longer satisfies “more than 100”). Honest failure is a feature; it is also the prerequisite for everything Desktop Lite promises about unattended work.

The Missing Manual, Written Twice

Two manuals shipped, for the two audiences that matter. For you: the tray gained “Manual (Start Here)”, a self-contained guide written for people who have never seen a Petri net, served by the launcher itself at localhost:4200/manual so it stays readable even while services are still starting. It covers the five-term vocabulary, seven things worth building on day one, copy-paste starter prompts, an honest table of what does and does not run while no client is connected, and a symptom-to-tool troubleshooting table.

For your AI client: release 2.41.0 added a real-agents doc to the knowledge pack every MCP client can read and search. Its core claim: a real agent is a net, not a chat loop. A persona lives in a charter place, work arrives as tokens in an inbox, a schedule makes it act unattended, every reasoning step is one bounded and auditable fire, and results land in places other nets consume. It maps the four possible executors for a reasoning step, is honest about which run unattended, and lands the consequence that matters most on a provider-less install: a command lane spawning headless Claude Code is the fully unattended reasoning path, so even with no provider and no client connected, your nets can fetch, compute, and reason. The same release fixed the agent-spawn recipe our own docs taught (the prompt now travels via stdin, immune to shell quoting) and documented the real Windows command-lane setup. The platform now teaches its clients to build on it correctly, which is its own kind of feature.

Try It in Ten Minutes

Release 2.41.0 is live. Grab the installer for your OS from the releases page, verify it against the signed checksum manifest if you like ceremony, and let the tray do the rest.

# 1. Download from https://github.com/alexejsailer/agentic-nets/releases
#    macOS:   AgenticNetOS-2.41.0-macos-arm64.dmg   (drag to Applications,
#             right-click Open on first launch: builds are unsigned for now)
#    Windows: AgenticNetOS-2.41.0-windows-x64.msi
#    Linux:   sudo apt install ./AgenticNetOS-2.41.0-linux-amd64.deb
#             (or the matching .rpm)

# 2. Start it. A tray icon appears; services come up on 127.0.0.1.

# 3. Tray menu -> "Connect Claude Code (copy command)" and paste it,
#    or "Connect Codex (copy config)" for a ready config.toml block.
#    The command arrives pre-filled with your installation's own token.

# 4. Open a NEW client session (MCP servers attach at startup) and ask:
#    "Run readiness and tell me what I can do."

Good first hours: deploy the working-memory template and store a decision, schedule a zero-LLM watcher on a URL you care about, and open Studio from the tray to watch tokens move through your first net as a live graph. Studio is optional; you can run everything through your client and never open it. But seeing your first net drawn is usually the moment the model clicks. When exploration turns into operations, the Docker and server deployment is the same platform with remote access, clustering, and the full monitoring floor.

Written from the release notes for 2.37.0 through 2.41.0 and a live Desktop Lite installation: the same tray app, manual, and MCP surface described above, running this blog author’s own nets.

Related: The Previous Two Weeks: BYOM and Agent Hub • AgenticNetOS Now Speaks MCP • The Guided Tour