Skip to content

v0.10.11

Choose a tag to compare

@github-actions github-actions released this 09 Nov 20:47
· 5 commits to master since this release
v0.10.11
34c4a10

Provider v0.10.11 (Swift CLI)

Source: 34c4a10
Build and SDK qualification: https://github.com/Layr-Labs/d-inference/actions/runs/42693869770
Signing: https://github.com/Layr-Labs/d-inference/actions/runs/42693869770
Binary SHA-256: a846c196a227fb1df98e6b0c5c07179e6f334beefd1725c1d412c7e13e31e9e3
CodeDirectory SHA-256: 6588ad9efb6d2d706ad299c808eaba79824d4f33fbb1d3adf581f638621c0560
Bundle SHA-256: c2fe882df1606c2475726a12e5cda25d98021765c532afd68568c99499217766
Metallib SHA-256: 5b97893cc20e6e9651edf3284d970488af9a9bdd64820231e95fee760eec70ac
Signed and notarized: yes
macOS deployment target: 14.0 (build, tests and signed runtime smoke: macOS 27)

Install

curl -fsSL https://api.darkbloom.dev/install.sh | bash

What's new in v0.10.11

Upgrade and rollout notes

  • 0.10.11 is a large release: use your Mac yourself, first (local-first), faster two-Mac pairs, longer answers on one Mac, and many pair fixes. The toolchain (Xcode 27.2, macOS 27.2 SDK) is 0.10.10's; libs/mlx and libs/mlx-swift are unchanged, libs/mlx-swift-lm moves (Swift model code only).
  • Behaviour changes to read first:
    • Macs serving with --local-endpoint, including the desktop app's "Alongside the network", now pause Darkbloom while you use their local API, and take Darkbloom requests again 2 minutes after your last one (me_first_idle_minutes, 1 to 120). To keep sharing the Mac as before, add me_first = false under [local] in ~/.config/darkbloom/provider.toml, then run darkbloom restart.
    • A pair paused for its owner keeps its base reward on the coordinator that ships with 0.10.11 (darkbloom-platform#709 onwards), as a single Mac paused for you does; both stay connected and take no Darkbloom requests while paused. On coordinators before #709, both Macs of a paused pair lose it for the pause plus the idle minutes.
    • An unknown reasoning_effort is now refused with a typed 400 (invalid_reasoning_effort, the field in param, the accepted names) on every model that reasons, including Qwen 3.5/3.6, Bonsai 2, Gemma 4, GPT-OSS and Nemotron Lightning, which used to accept it. Every standard value is accepted everywhere: none, minimal, low, medium, high, xhigh and max, each mapped to the model's nearest level. GPT-OSS reasons at every level, through OpenRouter too, once the Mac runs 0.10.11; a Mac still on 0.10.10 renders high as medium until it updates.
    • Cut, don't refuse: on one Mac, a max_tokens larger than the prompt leaves is cut to the model's window, and the answer ends with finish_reason: length if it gets there. A request with no max_tokens may now write up to 32,768 tokens (it stopped at 8,192, or 4,096 on MiMo V2.6, Nemotron Super and GLM-5.3-Flash). Network requests change only where the coordinator undercounts the prompt: OpenRouter requests that the coordinator undercounts on GLM-5.3-Flash, MiMo V2.6 and Nemotron Super are now served, cut to the window, instead of refused.
    • A request this Mac's memory can't hold gets a 503 before any SSE header, streamed or not, with a plain message ("This Mac's memory can't hold this request right now. Lower max_tokens or shorten the prompt …"), instead of HTTP 200 followed by an error.
    • One local API port and one key per Mac. Every way of serving locally on a Mac uses the same saved port, so your tools' address never moves. A Mac updated from 0.10.10 whose local API serves on 8000 keeps 8000; a Mac with no local API takes the first free port from 8001. The key stays in ~/.darkbloom/local_token.
  • Use your Mac yourself, first.
    • The first darkbloom start in a terminal asks how this Mac serves: Only me, on this Mac, Darkbloom network, or Both, me first (pre-selected). The answer is saved; darkbloom start --choose asks again. Starts without a terminal (the login service, the app, scripts) never ask: without a saved choice they keep today's behaviour exactly.
    • Only me now runs as a background service, like the other choices: it starts at login, restarts after a crash, updates itself, and keeps serving after you close Terminal. The app's "Local only" saves Only me, and "Alongside the network" saves Both, me first.
    • Me first gives way: while you use the Mac, Darkbloom requests still queued on it go back to the network instead of making yours wait; requests already running finish.
    • darkbloom --opencode and darkbloom --hermes (also darkbloom start --opencode / --hermes) set OpenCode 2 or Hermes Agent up to use your Mac, the way ollama launch does: the tool's config (never the key), a backup first, and a one-line undo. Hermes needs v0.20.2 or later. The installer now ends with darkbloom --opencode as the next command.
    • Routing: this Mac first, then your Macs. darkbloom route this-mac, my-macs or my-macs-first saves where your requests go when this Mac can't take them. Your other Macs are free; the paid Darkbloom network is used only if you opt in with my-macs-first and an account key saved by darkbloom route key. Answers say who served them.
    • Pairs: darkbloom cluster asks the same three questions for a pair. With Both, me first, every Mac of the pair has its own local address, and the whole pair pauses Darkbloom while you use it.
    • darkbloom cluster leave leaves a pair in one command, from either Mac.
    • darkbloom doctor opens with how this Mac serves you: the local API's address and port, whether it answers, and whether OpenCode and Hermes point at it. On a Mac set to Only me, it skips the checks Darkbloom serving needs.
    • darkbloom status says in one line how the Mac or pair serves and whether Darkbloom is paused for you. No screen shows the local key or a speed.
  • Pairs: faster, and fewer surprises.
    • Qwen 3.8 27B pairs decode with their speculative assistant through Darkbloom, and with the assistant they now prefill as fast as pairs without it. A Qwen pair takes max_tokens up to 65,536 and tells Darkbloom the requests it can serve, so larger ones go to single Macs instead of to a refusal. Qwen and Gemma 4 tensor-parallel decode and prefill are faster with unchanged output (Gemma 4 prefill nearly twice as fast).
    • Gemma 4 pairs: in tensor parallel a pair serves the model's whole context (262,144 tokens: prompts up to 262,143, answers up to 32,768), with one Mac's max_tokens cut, its context_length_exceeded words and the memory 503 before any header (#1923, proven on real Macs at 64K and 128K and a full-window answer). In pipeline it serves 65,536 with prompts up to 32,768, as every model's pipeline does, and refuses a longer request at once with a typed 400 (prompt_too_long or context_length_exceeded); an oversized max_tokens is cut (#1930, proven on real Macs). Pipeline's whole context waits for 0.10.12.
    • Pair fixes: a pair comes back by itself after an update; a memory re-plan keeps a stopped pair stopped; the Mac that follows no longer says a serving pair hasn't served; on a paired Mac darkbloom start starts the pair and start --solo serves the Mac alone; darkbloom restart on a stopped pair starts nothing; the app on a paired Mac offers Start serving; Apple's check during a start reads as progress, and both Macs show the pause.
    • DevNet and production no longer share a pair on a Mac with both apps; production wins the GPU.
  • Other fixes: a video (and a MiMo V2.6 audio track) whose reader fails once is read again instead of refused, and a second hardware fault is a retryable 503; a Nemotron Super video that decodes too slowly on one Mac is retried elsewhere; chunked file reads and update hashes no longer hold everything in memory; the update check asks again instead of waiting a minute; a pair's local API ends a failed stream with the single-Mac error chunk; Gemma 4 thinks when asked to, and GPT-OSS reasons at the nearest of its three levels.
  • Known issues in 0.10.11, fixed in 0.10.12 (none blocks this release):
    • When a pair's leading Mac is away, the first local request to the other Mac gets a 503 without an error code, and the later typed 503 doesn't mention darkbloom start --solo.
    • After darkbloom cluster leave on the leading Mac, the other Mac's status and screen can say things that are no longer true until it leaves too.
    • On the Mac that follows in a pair, darkbloom doctor can say the pair is "loading" while it serves.
    • A Gemma 4 pair refuses an image with "Media input is not supported." but without an error code.
    • An unknown reasoning_effort sent through the Darkbloom network comes back as an untyped error (the coordinator's, not the Mac's).
    • A pair, in tensor parallel or pipeline mode, can restart once (about 1 minute; requests in flight fail) if one of its Macs runs out of memory partway through a long request. It is rare and has existed since October. Gemma's pipeline is now capped (#1930), which makes it rarer there; Gemma tensor parallel's whole context makes it possible on long Gemma requests, as it already was on Qwen tensor parallel.
    • darkbloom start --solo --local saves Only me as this Mac's choice, so later starts without a flag serve Only me too.
    • After an update, the pair setup's question about how a Gemma 4 pair splits the model can pre-select Pipeline ("faster here") without saying that Pipeline serves 65,536 tokens and tensor parallel 262,144.
  • Pair owners: both Macs of a pair must run the same version; a pair on 0.10.10 updates itself at its slot, or at once with darkbloom update on each Mac. darkbloom update --rollback puts back 0.10.10.
  • Pairs still on 0.10.9 stop serving through Darkbloom once 0.10.11 registers, until they update (0.10.11 and 0.10.10 hold 24 pair approvals each, the coordinator keeps 64).
  • The registration keeps 0.10.10's fields; its cluster runtime facts now carry each mode's request limits and the Qwen assistant's evidence, and the leader's heartbeat adds request_limits. A Mac or pair paused for its owner reports draining with busy_reason: "owner", which the coordinator treats as a plain drain.
  • The 66 entries below are the pending fragments rendered verbatim; CI-only entries change no provider behaviour.

The app on a paired Mac offers Start serving, and its lines say what happened

  • On a Mac in a two-Mac pair, the app's Autopilot was a dead end. Onboarding's Start serving with Autopilot first downloaded a model, then showed three lines meant for the command line, and Retry showed them again. Autopilot chooses the models of one Mac, so on a paired Mac it is now refused before anything downloads, in words the app shows: the pair's state and what works there, for example "This Mac is in a pair, which is stopped; Autopilot isn't available for pairs yet. Use Start serving." The Autopilot page's model refresh is refused the same way.
  • The app now offers Start serving on a paired Mac, which starts the pair. Its onboarding says the pair's state and what Start serving does there, for example "This Mac is in a pair, which is stopped. Start serving starts it with ." ("This Mac serves in a pair …" only while it serves), and it starts the pair without naming a model or a local API of its own. When the pair has no model yet, the page offers no Start serving: it says to choose one with “darkbloom cluster” in Terminal on the Mac that leads the pair. The Mac tells the app it is in a pair, so even an app from before this offers the plain start there.
  • After the app's Start on a paired Mac, its last lines say what happened. When the app named another model, the pair "serves" its own model, or "was asked to start" with it and "isn't serving" when it doesn't serve yet. Before, it said "serves in a pair: started the pair" in both cases, and also for a pair that was already running. When the app asked for a local API that the pair doesn't give this Mac, it now says "No local API was added on this Mac", with where to change how the pair serves.
  • When the app's runtime refuses an action, the app's notice now shows only the refusal's own words, without "Error invoking remote method …" in front of them.
  • When a pair's other Mac isn't answering and this Mac's part was given up after 15 minutes, a start's Next: line and cluster status --json's next now also name darkbloom start --solo to serve this Mac alone.

A MiMo V2.6 video whose audio reader fails once is decoded again, not refused

  • When the reader of the audio track (LPCM or AAC) of a MiMo V2.6 video fails after the metadata checks passed, the provider reads the track once more with a new reader over the same bytes. A valid clip that met one audio reader failure is now served with the same samples. Before, the provider refused it as invalid_media (400), and the coordinator did not send it to another provider.
  • When the audio reader fails again with a decoder, hardware or interruption fault, the provider refuses the request as a retryable 503, and the coordinator can send it to another provider. Any other second failure is still the deterministic invalid_media (400).
  • Each failed audio reader pass logs a WARN engine_health event audio_reader_failed with the reader status and the domain and code of its errors. It carries no media or prompt content.

Chunked file reads release each chunk

  • Before, a file read in chunks kept every chunk in memory until the thread that read it went idle. On macOS each chunk read returns an autoreleased buffer, and a Swift task or a Dispatch block does not release these buffers between chunks. Thus memory grew with the size of the file.
  • Now each chunk read releases its buffer before the next read. This applies to the model manifest hash in darkbloom-publish, the speculative-decoding store's artifact hash, the binary and file hashes, the metallib snapshot copy, the streamed SSD KV cache read, the cluster worker hash, the MTP benchmark weight hash and the App Attest worker's executable hash. It also applies to the output readers of desktop commands and sandbox commands.
  • The output readers of desktop commands and sandbox commands keep only the last 32 KiB of output. Before, the buffer that held these 32 KiB also kept all the earlier output. The stderr tail that the provider keeps for a failed helper process had the same problem, and it is fixed the same way. Its stderr reads also release each buffer.
  • The digests and the copied bytes do not change.

Provider CI: build once, test on small Macs

  • Each lane builds its debug test products once, on a 12 vCPU Blacksmith Mac: Build cluster test products and Build provider test products. The test jobs download the products and run them with swift test --skip-build; they compile no package. A test job refuses products of another commit or of another Swift, Xcode or SDK version, and warns when only their builds differ.
  • The jobs that build or run the products work at one fixed path, /private/tmp/dinf, because SwiftPM's products hold absolute paths and Blacksmith and Darkbloom check out to different paths.
  • The cluster tests start as soon as the cluster products are up. The worker capability and prefill schedule checks, which compile a release build, run in Cluster Release Build Checks on a 12 vCPU Blacksmith Mac. The Provider Tests gate requires it.
  • Refresh build caches is gone: a push whose tree a pull request run already tested runs the build jobs of the components it changed, without an upload.
  • Cluster Runtime Tests runs in 3 shards: the Gemma 4 base suites (592 of the base tests' 970 s) run in their own process on shard 3. Cluster Focused Checks runs in 2 shards: the runner scripts, and the stage metadata, provisioning and onboarding runners.
  • The provider shard weights are measured again, so the last selection no longer runs every suite the old weights missed. The last shard's audit warns when a serial suite has no weight.
  • Only the 7 blocking test shards ask Darkbloom for a Mac; the build jobs, Cluster Release Build Checks and Cluster GPU Tests use Blacksmith directly.
  • Every macOS job samples its memory and CPU use and prints the peaks; the samples upload as resource-samples-*. The sampler never fails a job. The products hand-off prints the archive size and the upload and download times.

Provider CI: the prompt parity fixtures come from a verified cache

  • Provider shard 1 restores the prompt artifacts that both Prompt Parity steps read (tokenizers, templates and configs of the 7 v1 contracts and the Nemotron contract, 104 MB) from an Actions cache keyed by the hash of their manifests. Pushes to dev and master save it after both parity steps pass; pull requests restore it and save nothing.
  • scripts/prepare-prompt-fixtures.py --download-cache (PROMPT_PARITY_DOWNLOAD_CACHE in both parity scripts) uses a cache entry only if it is a regular file with the pinned size and SHA-256. Any other entry is downloaded and replaced. A cache that cannot store an entry never fails the run. Contracts that share a tokenizer download it once.
  • A contract's download deadline is now 120 s plus its missing bytes at 128 KiB/s, at most 900 s, instead of a flat 120 s. The 17 MB Nemotron contract that timed out at under 142 KB/s in run 42330647893 now has 256 s.
  • For each contract the script prints how many artifacts came from the cache and how many bytes it downloaded, and how long that took.

Provider CI: the diagnostics and placement flow runners compile, and CI runs them

  • provider-swift/Tests/ClusterDiagnosticsChecks/run.sh and provider-swift/Tests/ClusterPlacementChecks/run-flow.sh
    compile again. Since 2026-11-04 both stopped at cannot find 'GLM5NextGPULimitEligibility' in scope, and CI ran
    neither, so nothing noticed.
  • Shard 1 of Cluster Focused Checks now runs both, after the pairing runner, which adds about a minute (49 s and 18 s
    on CI). A change that breaks either fails that shard.
  • A change to GLM5NextGPULimitEligibility.swift alone now runs the cluster jobs too, as the other provider files
    that the cluster runners compile do: the console, diagnostics and placement flow runners compile it.

CI runs every test of dev every hour

  • .github/workflows/ci-dev-hourly.yml runs from master's schedule at minute 7 of every hour. It dispatches CI (dev) on dev, unless a dispatched run is still queued or in progress.
  • A dispatched CI (dev) run selects every component and never skips a tested tree: every provider and cluster shard, the focused and release build checks and the non-blocking GPU shards. It uses the lanes, sizes and caches of a push to dev, and saves caches as that push does, so the 1.87 GB MiMo audio codec stays cached on dev. Dispatched runs share one concurrency group: a new dispatch never cancels a running one.
  • When a job of a dispatched run fails, Report hourly failures comments on the open issue Hourly full dev CI failures (and opens it when none is open) with the run, the commit and the failed jobs.

Provider CI: per-job macOS sizes for Darkbloom Sandboxes

  • Each macOS CI lane can ask the Darkbloom plane for a size, <vCPUs>x<GiB>. The route job checks each size against this grammar and fails on a bad value before it sends a request.
  • Sizes are sent only when the repository variable DARKBLOOM_JOB_SHAPES is exactly on. While it is off, the route request is byte for byte the request without sizes, and every job keeps the runner it has today.
  • Each size comes from the job's sampled memory: the smallest signed size that holds 1.25 times its used memory (app + wired + compressed) without making the job more than 5% slower. While sizes are on, the 7 blocking test jobs ask for 4x16 (provider shard 1, cluster runtime shard 1, both Cluster Focused Checks shards), 4x24 (provider shard 2, cluster runtime shard 3) or 12x32 (cluster runtime shard 2, 29.3 GiB). Build cluster test products and Cluster Release Build Checks ask for 8x16 and Build provider test products for 12x32, on the required lanes build-cluster, build-provider and cluster-release-checks. A run that tests every component then asks for 10 macOS jobs. While sizes are off, the required jobs use blacksmith-12vcpu-macos-27 without asking.
  • The 2 Cluster GPU Tests shards are not routed. Shard 2 uses 42 GiB, which no signed size holds, so both shards run on blacksmith-12vcpu-macos-27.
  • A sized lane uses a grant only when its labels end in the qualified label, such as darkbloom-macos-arm64-4x24. Otherwise it keeps blacksmith-12vcpu-macos-27.
  • For each lane, the route job's log and summary show the size asked, the runner, and the decision with its reason, such as shape_not_signed, unavailable, unsupported_runner_class, image_not_available or lane_not_enabled.
  • The DARKBLOOM_MACOS_LANES cap still keeps the critical-path test lanes first. The required lanes come after them.

Provider CI: smaller test products hand-off

  • The test products archive leaves out what no test step reads: every .dSYM bundle (the test bundle's own included), the host tools (the -tool macro and Modules-tool) and SwiftPM's bare clones in .build/repositories. The coverage report reads the coverage maps in the binaries, not DWARF, so it does not change. A stalled-test sample now names each frame's function and offset, but not its file and line.
  • zstd packs the archive at level 9 with a 2 GiB long-distance window, which stores repeated content such as the test bundle's metallib copies once. On the provider products of run 42318853015 the archive goes from 1,065 to 265 MiB. Unpacking needs the same window and about 2 GiB of memory.
  • The pack step also prints the size of the archived files.

Provider CI: the real-geometry rows check runs in two halves

  • Cluster GPU Tests shard 1 ran one test, rowsEqualTheirSoloStepsAndWindowPositionsAtRealWidths, for 18 to 19 min. It ended at 22 to 23 min of every run, after the Provider Tests gate, so it set the run's wall time.
  • QwenTensorParallelRowsCheck.run takes the halves of the check to run (parts, default both). The rows half checks the rows of 100 to 4,090 tokens: alone on a one- and an eight-lane host, beside rows that join and leave, while an assistant observes the cohort, and at every verify-window position. The segments half checks the rows of 4,000 to 4,600 tokens across KV segments. Each half compares only against the solo runs it makes itself and keeps its refusals: non-finite logits, reference logits that are not all distinct, a blind comparison (rows half), and rows within one KV segment (segments half). No row, width, step or window position is dropped.
  • QwenTensorParallelRealGeometryRowsTests runs each half as a test: rowsEqualTheirSoloStepsAndWindowPositionsAtRealWidths (rows) and the new rowsAcrossKVSegmentsEqualTheirSoloStepsAtRealWidths (segments). Each test checks its half's digest count on both ranks (200 and 136, the whole check's 336). darkbloom-cluster-tp-check qwen-rows run still runs the whole check.
  • Cluster GPU Tests has 3 shards. Shard 1 runs the rows half alone, the new shard 3 runs the segments half alone, and shard 2 does not change. All three run on blacksmith-12vcpu-macos-27 and are not routed. A run that tests the cluster uses one more macOS job.

Provider CI: shorter cluster runtime shards

  • Cluster Runtime Tests runs in 5 shards instead of 3. The batch-session suite (672 s in one process) runs in two processes: its warm and SSD prefix tier tests in base-batch-session-prefix-tiers, its other tests in base-batch-session. Each runs beside one half of the Qwen GPU chain, on shards 2 and 3. The Gemma 4 base suites (610 s) run in two processes, each alone on its own shard: Gemma4TensorParallelTests on shard 4 and the other Gemma suites on shard 5. Every test still runs in exactly one selection.
  • The two new shards ask for no new lane: shards 2 and 3 share the lane test-cluster-2, and shards 4 and 5 share test-cluster-3, each requested for 2 jobs. A run that tests every component asks Darkbloom for 9 macOS jobs while job sizes are off (7 before).
  • The cluster plan audit checks that each Gemma suite runs whole in exactly one base selection of Gemma suites, and that each test of a split suite runs in exactly one of its selections.
  • The CI plan checks run in their own job, Check the CI plans, beside the test jobs. The Provider Tests gate requires that job and no longer runs the checks after the last test job.

Provider updates hash bundles in bounded memory; CI samples memory by class

  • An install, a verify or a rollback of the provider no longer keeps every byte it hashes in memory. Each 1 MiB read of the bundle hash and the file hash now releases its buffer before the next read. Before, a rollback test of the debug CLI held 15 GiB until its test process ended. The hashes are unchanged.
  • The CI resource sampler now records memory by class: app (with Metal buffers), wired, file cache, compressed and swap. It also records the physical footprint of each process, which includes Metal memory, the test selection each large process runs, and busy vCPUs from the host's CPU ticks. Each job's report and summary.json show the peaks, the three largest processes and the time the job would take on 4 and 8 vCPUs. The sampler stays report-only.

DevNet and production no longer share a pair

  • On a Mac with both the production app (darkbloom) and the DevNet app (darkbloom-dev), each app now keeps its own pairing, cluster setup, logs, cluster service and login job, each in its own folder (~/.darkbloom and ~/.darkbloom-dev), and each app's pair uses its own ports on the cable. The DevNet app no longer reads the production app's pair, restarts its cluster service or removes its login job: darkbloom-dev cluster pair --forget, darkbloom-dev cluster stop --service and darkbloom-dev uninstall act on the DevNet app's pair only, and the production app's commands on its own only. This ends the 0.10.9 known limitation about the two apps on one Mac.
  • Only one app's pair runs on a Mac at a time. Both apps take one device lock (~/Library/Application Support/io.darkbloom.cluster/native-device.lock, an empty file in a folder neither app owns) while a pair's part, a member's preparation or a GLM model check uses the GPU. The other app's pair then waits: its status says which app holds the Mac's GPU, and it starts by itself within seconds of that app's pair stopping. A wait never counts as a failing pair, so production never falls back to serving on its local API because DevNet held the Mac. A DevNet pair can no longer push a production pair out of memory.
  • Production wins on a Mac both apps serve from. Production 0.10.10 and earlier take no lock, so the DevNet app also waits while a production serving process runs on that Mac (darkbloom start, a pair's part or its worker, read from the process list) or production's cluster service says its pair serves there (its published status, read only), and a running DevNet pair releases the GPU at once and stops once production starts serving there (say both start at login). So a waiting DevNet pair never takes the GPU while production's pair restarts, for example for its update. If production's status was written in the last two minutes but can't be read, the DevNet app waits too and says why. The DevNet app's single-Mac serving loads no model while production serves on that Mac either, so its requests go to other providers meanwhile. A cluster member run with the developer route --always-on waits for the other app's hold on the GPU without spending its restart budget. DevNet never tells you to stop production: production serves there, and its owner decides.
  • Providers with the production app alone see no other change: its files, its login job and its ports are the same as before, and its pair takes the device lock, which nothing else holds there.
  • After this update the DevNet app starts unpaired, even on a Mac where it had paired, and copies nothing from the production app: update the DevNet app on both Macs, then run darkbloom-dev cluster on both to pair it again. If the DevNet app was the last to pair on a Mac before this update, the production app's darkbloom cluster may say the Secure Enclave key changed: choose Pair again there.
  • The two apps still share the models and the cable port setup (one cable, one network setup). Uninstalling one app keeps the cable port setup while the other app is installed, so it asks for no password, and removes only its own pairing, cluster setup and cluster service; the other app's uninstall undoes the cable port setup later. cluster link --remove in one app now names the other app when that app still uses the port and asks first, even with --yes; without a terminal it changes nothing.
  • A model copy between the two Macs stages in the shared model store under its own app's name (production's .darkbloom-incoming-… as before, DevNet's .darkbloom-incoming-dev-…). A copy short of disk space frees only its own app's abandoned copies, never the other app's copy under way.

A pair's leader can take its owner's local requests beside Darkbloom

  • The member that hosts a pair's slot can now run the local OpenAI-compatible API while the pair serves through Darkbloom. Local and Darkbloom requests share the pair's one engine and its lanes: no second process or engine, and no extra copy of the stream. darkbloom cluster starts it when you choose Both, me first for the pair.
  • Only that member runs it, and always with a key. Any other member still refuses a local API.
  • While the pair isn't serving (it is forming, re-forming or stopped), a local request gets 503, as darkbloom cluster local answers, instead of a 500. A model the pair doesn't serve gets 404.
  • When every lane is busy, a local request waits its turn in a bounded queue, as on darkbloom cluster local (DARKBLOOM_CLUSTER_QUEUE_WAITING, default 64): 429 when the queue is full, 503 when it waited too long. A waiting request is woken when a lane frees and is never polled; Darkbloom requests never wait for it.
  • A local request that arrives while the pair runs its first test request waits until the pair opens, and gets 503 if the pair stops instead.

darkbloom cluster leave: leave a pair in one command

  • darkbloom cluster leave, on either Mac of a pair, stops this Mac's part (the pair stops on both Macs while the other Mac answers, then this Mac's cluster service leaves login) and forgets this Mac's pairing, the same steps darkbloom uninstall, Start over and darkbloom cluster pair --forget take. Leaving no longer takes four steps: cluster pair --status, reading a pin, cluster pair --forget <pin>, then start.
  • In a terminal it says what leaving does and asks Leave the pair? [y/N] (No by default); without a terminal it needs --yes. A part that doesn't stop leaves the Mac paired, and the command says so.
  • It ends with this Mac's next steps (darkbloom start serves it alone, or darkbloom cluster pairs it again), what the stop did to the other Mac and that it keeps its pairing until you run darkbloom cluster leave there, and how the two Macs pair again (darkbloom cluster on each, Start over on the other Mac).
  • It says only what happened to the other Mac: "stopped serving the pair too" only when it did, "wasn't asked to stop" when nobody asked it, and, when it didn't answer, that it may have left the pair already.
  • On the leading Mac, the forget step no longer says the other Mac's pair cache stays until darkbloom cluster pair --forget <its 64-digit pin> there, which was false once that Mac had left. When it isn't reached, it says "If that Mac is still paired, run darkbloom cluster leave there." cluster pair --forget and uninstall say the same.
  • While leaving, and in darkbloom uninstall, the stop no longer says "Run darkbloom cluster to serve again", "to start it again", or to stop the other Mac's service with cluster stop --service: the last lines say what to do next. uninstall's summary says when the other Mac didn't answer.
  • The Mac left behind can't tell the other Mac having left from it being off: its status, cluster status and a start's result now end "If the other Mac left the pair, darkbloom cluster leave here unpairs this Mac too." instead of saying start on either Mac starts the pair, and darkbloom cluster there offers Start over or darkbloom cluster leave for a Mac that left.

Both, me first for a pair, in darkbloom cluster

  • In a terminal, darkbloom cluster now asks how a pair serves, with the single-Mac start's three choices: Only me
    (this pair, local)
    , which is darkbloom cluster local's way, Darkbloom network, or Both, me first, which
    is preselected. On a set-up pair, the list's Change how the pair serves asks again. The answer is saved in
    [local] mode once the start goes ahead. darkbloom cluster local is unchanged and asks nothing.
  • With Both, me first, the Mac that runs the pair's first part also runs the pair's local API beside Darkbloom,
    with the pair's key, on every network of that Mac. Its port is the first one from 8001 to 8020 free on both Macs,
    never 8000 or the pair ports 47420–47423. Darkbloom pauses for the whole pair while you use it and comes back 2
    minutes after your last request. The other Macs run no local API.
  • Without a terminal nothing is asked or saved. The login service and scripts keep serving each pair as its setup
    says, and a pair set up before this build serves through Darkbloom with no local API, as before.
  • The question says that the pair's pause, route and account key are the leading Mac's. Serve locally only at the
    login check after Both, me first saves no answer: the pair serves locally only, and Only me isn't saved.
  • darkbloom status and darkbloom cluster status say whether Darkbloom is paused for you, the pair's local address
    (never its key), and that the other Macs are part of the pair. On the other Mac they say that darkbloom local on
    the leading Mac shows the address and key. No line shows a speed.
  • Requests from other machines never use the paid network; they can use this Mac and your other Macs. A local API that
    other machines reach (a pair's, or one started with --bind) passes their requests to your Macs only, even with
    route = "my-macs-first", and lists no network model to them. Programs on the Mac itself keep the route.
  • darkbloom start --cluster-member takes --local-endpoint --port --bind from the cluster service, never with
    --no-auth.
  • A pair's local API without a cluster approval (its leader registered with the coordinator, or serving locally because
    the coordinator couldn't take it) no longer asks the coordinator whether your other Macs serve a model before passing
    your request on to them, as cluster local already didn't. The coordinator's count never includes that leader, so
    with exactly one other Mac serving the model the request was refused as this_mac_only instead of going to that Mac.
  • With Only me saved, by darkbloom cluster for the pair or by darkbloom start, a darkbloom start --solo
    without a terminal (a script) on a Mac whose pair doesn't run here is refused in one line, as on one Mac. This Mac's
    part of the pair keeps running, and its saved start stays.

Every Mac of a pair answers locally in Both, me first

  • With Both, me first, every Mac of the pair now has its own local API address, as with Only me
    (darkbloom cluster local), not only the Mac that runs the pair's API: each other Mac passes its own port to it over
    the cable. darkbloom local there prints http://127.0.0.1:<port>/v1 and the key to use, darkbloom status names
    that address instead of pointing at the leading Mac, the setup's ✓ block prints this Mac's own address once its port
    is up, and darkbloom start --opencode or --hermes there sets the tools up for it.
  • Each Mac's tools use that Mac's own key (local_token), with Only me and with Both, me first. The pair's API
    takes its own Mac's key and the pair's key (cluster_local_token), which tools set up before keep working with; the
    other Mac's port passes requests on with the pair's key.
  • A pair's local API now takes each Mac's own saved [local] port, as every other local API on that Mac does, with
    Only me and with Both, me first: the Mac that runs the pair's API listens on its port, and each other Mac's
    port passes requests to it, so the ports can differ, and each Mac keeps its own whichever Mac runs the pair's API.
    Before, the pair's API took a port free on both Macs (Only me 8000 when free) and the other Mac took the same one. A
    Mac with no saved port keeps the one its local API already uses, else takes the first free one from 8001, never 8000
    or the pair ports 47420–47423, and saves it; a Mac updated from 0.10.10 keeps 8000. With the pair's API kept on its
    own Mac (--bind loopback or one address), the other Mac passes nothing on, as before.
  • A saved port is never moved, a pair's included: when another program holds it, darkbloom status on that Mac names
    the port and says to free it, or set another [local] port in provider.toml, then run darkbloom restart. For the
    pair's API this replaces "darkbloom restart starts the pair's API on a free port".
  • While Darkbloom doesn't have a Both, me first pair (no approval yet), the pair answers on the leading Mac only,
    and the other Mac passes nothing on: its darkbloom status says so, and never shows an address that resets every
    connection.
  • While the Mac that runs the pair's API is away (unplugged, asleep), the other Mac's own port answers every request at
    once with a 503 (code pair_mac_unreachable) that says so: "Your pair's other Mac (…) isn't reachable; this Mac
    relays to it. Requests resume when it's back, or run darkbloom stop, then darkbloom start --solo, to serve this
    Mac alone." That Mac counts as away once it hasn't answered over the cable for 12 seconds. Only a request with this
    Mac's key or the pair's gets those words; any other gets the local API's usual 401, or a 503 without names where
    the API needs no key. With Only me, that port used to close each connection unanswered then, for up to 15 minutes.
    darkbloom status and darkbloom local now say the same, and relaying resumes by itself within seconds of that Mac
    answering again. A request while that Mac's API doesn't listen gets a 503 with code pair_api_unavailable.
  • On the other Mac, darkbloom local and darkbloom start --opencode say why it has no address for the pair (Darkbloom
    doesn't have the pair yet, its port is held, or the leading Mac is away), as darkbloom status does: local no
    longer prints the pair's key there, and --opencode says it at once instead of after a 30-second wait. While that
    address is still starting, local says so beside the pair's key, instead of "No local server running."
  • The app's Start serving on the other Mac no longer says "No local API was added on this Mac" when the pair's API
    is on every address: that Mac's relay gives it one. While the relay can't answer (the leading Mac away, Darkbloom not
    having the pair, its port held), the app says status's Local API: line instead. With the pair's API kept on the
    leading Mac, Only me included, the line stands.
  • The solo server a pair falls back to when one Mac is away for 10 minutes takes that Mac's own saved [local] port
    too, instead of 8000, so its tools keep their address.
  • A request on the other Mac's port pauses Darkbloom for the pair, as one on the leading Mac does, and never uses the
    paid network: the pair's API sees it come from that Mac.
  • darkbloom start --opencode on a paired Mac waits up to 30 seconds for that Mac's local API after the pair starts,
    and says at once when the pair serves only the Darkbloom network.

Me first for a pair: Darkbloom pauses while you use the pair

  • While you use a pair through its leader's local API, the pair takes no new Darkbloom requests. It takes them again
    two minutes after your last request ends ([local] me_first_idle_minutes). [local] me_first = false keeps today's
    shared serving.
  • Darkbloom requests already running finish, and nothing is cut. A request that races the pause goes to another Mac.
    The pair keeps its session and its loaded model.
  • The leader decides for the pair: its heartbeat says draining with busy_reason: "owner", which takes the whole
    pair out of routing, your own self and prefer requests included. The other members don't change, and nothing
    assumes two Macs.
  • The pair's base reward while it is paused depends on the coordinator. From
    darkbloom-platform#709 on, the pair keeps it, as a single
    Mac does. On coordinators before #709, both Macs lose it for the pause plus the idle minutes, as for any pair drain.
  • It costs next to nothing: one heartbeat when the pause begins and one when it ends, an O(1) update per local
    request, and an idle check on the member's existing 5-second beat.
  • darkbloom cluster starts the leader's local API when you choose Both, me first for the pair.

A pair takes the long requests it can serve and reports its speed

  • A Qwen 3.8 27B pair in tensor parallel now accepts max_tokens up to 65,536, the catalog's output limit and the value the coordinator gives a request that omits max_tokens. It accepted at most 32,768 before. In production, five 18,774-token prompts that asked for 65,536 were refused with 503 request_exceeds_context, although single Macs served requests of the same size. Prompts up to 262,143 tokens and the 262,144-token context are unchanged. Each Mac's memory gate still decides, request by request, whether a long request fits.
  • The leader's heartbeat now tells the coordinator which requests the cluster serves, for every Mac in it (request_limits on its slot): the prompt, output and context limits of the mode it runs, and the context that every Mac's memory admits now. A pipeline reports the 32,768 + 32,768-token request its Macs accept, and its leader refuses a longer request itself before asking either Mac.
  • The release's public envelope for each mode now carries those limits instead of 1,048,576 for prompt and output. For a model whose clusters serve the public, larger requests go to single Macs instead of to a refusal.
  • A pair's slot now reports measured prefill and decode speeds from the requests it serves, as a single Mac's slot does. A prompt is measured as it ran, up to its first token, so a prompt that ran alone counts as isolated even when another request joins its answer. Before, it reported none, so the coordinator could not predict a pair's first-token time and a free single Mac always took the request first. The warmup request a pair runs before it opens is not counted.
  • Providers no longer log an error every 30 seconds while connected. The coordinator's round-trip probe is a WebSocket ping that carries a counter, and the provider tried to read it as a message. On a pair leader, this showed up in the system log as an error of category coordinator with a hidden (<private>) message. It never affected serving.

The cluster setup quotes no speeds, and its recommendation follows the pair's measurements after an update

  • darkbloom cluster's model list no longer shows tokens per second. It named each mode with the speed the pair
    served it at ("Gemma 4 26B · tensor parallel 96 tok/s or pipeline (not measured on these Macs yet)"); it now
    names the modes only ("Gemma 4 26B · 15.6 GB · tensor parallel or pipeline"), the one the mode question recommends
    first. A model named on the command line (darkbloom cluster local <model>) starts in that mode too. The mode
    question already quoted no speed.
  • After a Darkbloom update, until one of a model's modes has served with the new build, the mode question ranks the
    modes by what the two Macs served with an earlier build that recorded how it served (through Darkbloom or locally,
    with or without Qwen's tensor assistant). Builds record this from 0.10.11 on, so it first applies at the update
    after 0.10.11: updating from 0.10.10, whose records don't say how they were served, the question still recommends
    from the planner's prediction until a mode has served with 0.10.11. Once a mode has served with the new build, that
    build's measurement decides, as before. On one DevNet pair the question said "Pipeline, faster here" for Gemma 4 26B
    right after an update, although the pair had served tensor parallel faster before; from its earlier
    tensor-parallel measurement it now recommends tensor parallel.
  • The developer setup wizard (darkbloom cluster --wizard) no longer shows predicted speeds on its model step or its
    help, or a speed on its check's result. A test prompt sent from its last step still reports that request's speed.

A two-Mac pair's local API no longer cuts a failed stream short

  • When the provider rejects a streamed chat completion's output mid-generation on a pair (for example a named or required tool_choice the model answers with text, or a streamed tool call that fails validation), the leader's local API now ends the stream with the same error chunk (finish_reason: "error") as one Mac. Before, the client could get HTTP 200 and the chunks already sent, then the connection closed with no error chunk. Some clients took that cut-short stream for a complete answer.

A pair comes back by itself after an update

  • After both Macs of a pair restart into an update, the leading Mac stops the pair once to set it up again for the new release, and again to save the release's cluster approval. When that stop failed (the other Mac didn't answer in time, or refused it because it had taken the lead for a moment while the leading Mac restarted), the pair stayed stopped on both Macs ("Stopped; last model …") until someone ran darkbloom cluster. Now a failed stop keeps the pair started, and the leading Mac tries again: the setup 10 minutes later, the approval at its next check, a minute later.
  • The leading Mac now sets the pair up after an update, and changes its cluster approval, only once the other Mac has confirmed that it leads (or hasn't answered for 30 seconds), as darkbloom cluster already did for a person's commands. While the other Mac doesn't answer, it doesn't stop the pair to change its approval, which needs both Macs; it changes it once the other Mac answers again.
  • A stop you make during these steps holds: neither step starts the pair again. darkbloom stop and darkbloom start --solo on a Mac where the pair doesn't run now wait, up to 10 minutes, for a cluster command that is running, as darkbloom cluster stop does. They say so at once, and if the command is still running after those 10 minutes, they say so and stop or start nothing.

darkbloom --opencode and darkbloom --hermes

  • darkbloom --opencode is darkbloom start --opencode, and darkbloom --hermes is darkbloom start --hermes;
    both together work too. Any other start option goes with them, in any order (darkbloom --opencode --me-first,
    darkbloom --me-first --opencode), and start's errors and refusals apply. darkbloom start --opencode keeps
    working; --help, --version, plain darkbloom and every subcommand are unchanged, and a mistyped flag
    (darkbloom --opencod) gets the usual unknown-option error.
  • darkbloom --help shows the two shortcuts, one line each.
  • The lines that name the command say the short form: darkbloom local's tools: line, the line --port prints
    when it replaces a saved port, the refusals, the tool step's lines, the installer's closing lines, and the comment
    above the darkbloom block in OpenCode's and Hermes' configs (a config set up before keeps its line).

Darkbloom watchdog reads any listing size and rescues partial strands

  • .github/workflows/darkbloom-watchdog.yml is now darkbloom-sandbox's template at d6d257c2, copied unchanged. The old copy passed the day's run and job listings to jq as command-line arguments. When the repository was busy they were larger than Linux allows for one argument, and the watchdog failed with Argument list too long (exit 126) before it checked any run. It now passes listings to jq through files and stdin.
  • A job's wait is timed from its own creation. Only a Darkbloom job of the run that got a runner within the wait holds the rescue back, so a run with one shard stranded while other shards ran is rescued too.
  • The watchdog sees only GitHub: a job that waits at the payer's concurrency or resource limit looks stranded to it. Set DARKBLOOM_WATCHDOG_MINUTES above such waits. The repository variables are unchanged.

darkbloom doctor knows how this Mac serves you

  • The report opens with a LOCAL API section: how this Mac serves (Only me, Darkbloom network or Both, me first; what runs now, else your saved choice), its local API's address, whether it answers and on which port, whether its key file is there (the key is never shown), and whether OpenCode and Hermes point at it, or somewhere else. Every problem names the next command: darkbloom start, or darkbloom restart for a stopped background service (it starts again as saved), the free port to use, or darkbloom --opencode / --hermes to point a tool here again.
  • A local API that stops answering is started again the way it serves now, never another way: Only me in a terminal with Ctrl-C there, then darkbloom start --local --here (restart never stops it, and would serve your saved choice); the background service with darkbloom restart; a service serving another way than your saved choice with darkbloom start and that way's flag.
  • On a Mac set to Only me, doctor no longer checks what Darkbloom serving needs: the account link, MDM, coordinator health and trust, App Attest, attestation readiness, coordinator traffic and billing are skipped, with one line that says they aren't needed. This holds while Only me loads its models too, which the section says ("starting"). --coordinator <url> still runs them. darkbloom verify is unchanged.
  • On a Mac in a two-Mac cluster, the section names the pair's way of serving and the Mac that runs the pair's API, or says the pair hasn't chosen yet. A paired Mac serving alone (start --solo) is described by what it serves, with --solo in its commands. A Mac whose own port passes the pair's API on, and can't now, says why in status's words: with the other Mac away, its port answers 503 for now, and it says to wait, or to serve this Mac alone, never to restart.
  • OpenCode and Hermes are read and judged as darkbloom start judges them: localhost is this Mac, and another file holding the same key is the same key.

Gemma 4 thinks when asked to, and GPT-OSS reasons at the effort you send

  • Gemma 4 thinks for every reasoning effort but none, as reasoning_effort or reasoning.effort (it ignored the effort before, and its template doesn't think by default). An explicit thinking switch still wins.
  • GPT-OSS renders each effort at the nearest Harmony level: none, minimal and low as low; medium as medium; high, xhigh and max as high. high rendered medium before, and minimal, xhigh and max reached the template as sent. Every level works for GPT-OSS, through OpenRouter too, once the Mac runs this release; a Mac still on 0.10.10 renders high as medium until it updates.
  • Rollout: Darkbloom's coordinator with darkbloom-platform#721 (the same effort mapping and the typed 400 for an unknown effort) is deployed before this release is tagged; no auto-update hold is needed.
  • Darkbloom's coordinator maps every effort the way this provider does, and both check the same 446 cases and the same lists of model types (fixtures/prompt-contract/v1/reasoning_effort_vectors.json), so a model type added to one side only fails a test.

A Gemma 4 pair serves the model's whole context and answers a long request as one Mac does

  • A Gemma 4 26B pair now accepts prompts up to 262,143 tokens and up to 32,768 output tokens within 262,144, the model's declared context, in tensor parallel, as one Mac serving it does. Its pipeline keeps the 32,768 + 32,768-token request, as every model's pipeline does, so a longer request goes to tensor parallel or to one Mac. Before, it served 65,536. The pair is still loaded and planned for the 32,768 + 32,768-token request; each Mac's memory gate decides, request by request, whether a longer one fits now.
  • On any pair, a max_tokens above the output limit the pair serves, or above what the prompt leaves of its context, is cut to fit, as on one Mac, and the answer ends with finish_reason: length if it gets there. Before, it was refused with 400 output_too_long.
  • A prompt that fills the context a pair serves is refused with one Mac's 400, context_length_exceeded, and the words that name the window. A request both Macs' memory can't hold now gets one Mac's 503, "This Mac's memory can't hold this request right now. …". Both arrive before any SSE header. Before, a streamed request to the leader's local API in "Both, me first" got HTTP 200 and then "Response generation failed" (Gemma 4 26B on pair-2: prompts of about 40,600 and 58,000 tokens).
  • /v1/models on the leader and darkbloom cluster local list the context and output the pair serves, and default an omitted max_tokens within them.

Gemma tensor parallel prepares the next token while reading the last

  • For requests without sampling (temperature 0, no logprobs, no logit bias or penalties), a Gemma 4 pair now starts the next token's work on the GPU before it reads the token it just made, as GLM's pair already does. On GLM this took a token from 13.4 to 12.0 ms on two M5 Ultras; Gemma's gain has not been measured yet. The output is unchanged.

Gemma tensor parallel prepares the next token ahead for sampled requests too

  • Requests that sample (temperature above 0, with or without logprobs), and greedy requests with logit bias or penalties, now also start the next token's work on the GPU before the last token is read. Each token is still the exact draw for its position and seed, so the output is unchanged (except that a request that already fails because one Mac stopped on its own may stream one extra token first, as on GLM). Greedy requests that ask for logprobs keep the old order.

Gemma 4 tensor-parallel prefill can overlap its link traffic with compute (off by default)

  • A Gemma 4 pair in tensor parallel can now split each prompt chunk's work after attention into parts, so one part's results cross the cable while the next part computes. On a two-Mac pair's GPUs the results are bit-identical to the whole chunk (not on the CPU backend, and not with more than two Macs); since nothing enforces that at full size, it stays off. On two M5 Ultras, 4 parts prefilled a 9,651-token prompt at 1,196–1,208 tok/s instead of 1,064 (+13 %), with identical output. It stays off by default; the bench tool takes --prompt-parts.

Gemma 4 tensor-parallel prefill is nearly twice as fast

  • A Gemma 4 pair in tensor parallel computed each prompt chunk's experts one token at a time on each Mac. Each chunk's experts now run together, with every value unchanged. On two M5 Ultras a 9,651-token prompt prefilled at 1,066 tok/s instead of 569, with identical output.

The installer ends with darkbloom --opencode

  • The installer's last lines say that darkbloom --opencode asks how this Mac serves (Only me, Darkbloom network, or
    Both, me first), then sets OpenCode up (/models → Darkbloom; darkbloom --hermes for Hermes), and that two Macs
    pair with darkbloom cluster on each. The last line is the command to run next, with its full path so it works
    before the shell picks up the new PATH line: Next: ~/.darkbloom/bin/darkbloom --opencode. Before, it listed
    doctor, models catalog, models download, login and start.
  • curl … | bash prints these lines once the platform's copy of the installer is updated.

Link control reports the end of a superseded session

  • The listener did not report the end of a session that a newer session superseded. When the connector's record budget ran out, it said goodbye with rekey and dialed again at once. If its next session arrived before the listener's reader read the goodbye, the old session ended with no disconnected event. testRecordBudgetRollsOverToFreshKeys failed on master push run 42258366869 for this reason. Now a superseded session gives exactly one disconnected event, after the newer session's connected. The listener shuts down only the sending side of the superseded session, so its reader can still read the goodbye. The reason is rekey when the session ended as a rollover, and superseded for all other ends. Neither reason is a peer loss. When the edge stops, it also ends each superseded session that is still reading.
  • testRecordBudgetRollsOverToFreshKeys waits again for the listener's .rekey disconnect, and also for the connector's. A new test parks the listener's first reader until the connector's next session supersedes it, and requires exactly one .rekey for that session, after the second connected. Another new test requires one .superseded for a superseded session with no goodbye when the edge stops.
  • testReconnectResumesExactlyOnceInOrder waits for the client's resumed .connected event instead of reading the client log at once after a wait on the server log.

This Mac serves its model's whole window and holds every request to it

  • A request to this Mac's own API that names no max_tokens (curl, the OpenAI SDKs, any client that leaves it out) may now write up to 32,768 tokens, as on a pair. Before, it stopped at 8,192 tokens, or 4,096 on MiMo V2.6, Nemotron Super and GLM-5.3-Flash, which could cut a thinking model off before its answer. Diffusion Gemma keeps its generation config's own default. That default is cut to the context window the prompt leaves, so a long prompt without max_tokens is served until the window is full instead of being refused.
  • Every model is held to its window on this Mac: the context it advertises (GLM-5.3-Flash, MiMo V2.6, Nemotron Super), else its model's own (Gemma 4, Qwen 3.5, 3.6 and 3.8, GPT-OSS, Nemotron Lightning). A max_tokens larger than what the prompt leaves is cut to fit, on every model, and the answer ends with finish_reason: length if it gets there; before, a model that advertises a context refused it, so OpenCode and Hermes, which name a max_tokens on every request, were refused 32K to 65K tokens before GLM's, MiMo's or Super's window was full. Only a prompt that leaves no room is refused, with 400 context_length_exceeded and a message naming the window; before, on a model that advertises no context, it ran past the window.
  • This Mac's /v1/models lists each of its models' window as both context_length and max_output_length, so darkbloom start --opencode and --hermes write the model's own output limit instead of the catalog's. A pair's leader lists the context and output the pair serves, which it holds every request to.
  • This Mac's API now says which bound a request met. A request this Mac's memory can't hold now (on a paged slot, the default, one that can never fit; the rest queue) gets 503 before any SSE header, streamed or not, "This Mac's memory can't hold this request right now. Lower max_tokens or shorten the prompt (or send less media), or retry when this Mac's other requests finish."; before, a non-streamed one got "Provider capacity is temporarily unavailable.", and a streamed one HTTP 200 and then "Response generation failed".
  • Network requests (OpenRouter's included) change only where the coordinator's estimate undercounts the prompt, as it can for dense text: the coordinator refuses an estimated prompt plus max_tokens past the catalog's context (413) before any provider sees it, so only an undercounted request reaches a Mac with an oversized total. Such a request is now served, cut to the window and ending with finish_reason: length, instead of being refused with 400 on GLM-5.3-Flash, MiMo V2.6 and Nemotron Super, or running past the window on the other models; one whose prompt alone fills the window is refused with 400, as before on the first three.

Your own requests pause Darkbloom on your Mac

  • With the local API beside Darkbloom (darkbloom start --local-endpoint), the Mac stops taking Darkbloom requests
    while one of your requests uses a model on it, and takes them again once none of your requests has run for 2 minutes
    ([local] me_first_idle_minutes, 1 to 120). Before, your requests and Darkbloom's shared the Mac.
  • This starts with this update on every Mac already serving with --local-endpoint, including the desktop app's
    "Alongside the network": it pauses Darkbloom while you use its local API. Darkbloom requests already running finish.
  • To keep sharing the Mac, set me_first = false under [local] in provider.toml
    (~/.config/darkbloom/provider.toml), then restart serving (darkbloom restart).
  • Listing models, health checks, /metrics and the tokenizer utilities don't count, and neither do requests refused
    before they hold a model (a model the Mac doesn't serve, a load that doesn't fit, a drain).
  • darkbloom start --local never connects to Darkbloom, so it has nothing to pause.

Me first: Darkbloom pauses while you use your Mac

  • The provider can pause Darkbloom requests while you use this Mac through its local API, and take them again once
    none of your requests has run for the idle time ([local] me_first_idle_minutes, 2 minutes by default).
  • While paused the Mac stays connected, keeps its models loaded and keeps its uptime. Darkbloom requests already
    running finish, and new ones go to other Macs. Heartbeats say draining with busy_reason: "owner", which
    coordinators treat as a plain drain.
  • It is event-driven: a heartbeat only when the pause begins or ends, one timer only while your idle time counts down,
    and nothing at all when it is off.

Local-first settings in provider.toml

  • provider.toml takes a new [local] section for using your Mac yourself, beside or instead of Darkbloom: mode,
    me_first, me_first_idle_minutes (default 2, from 1 to 120), route, port and bind. The provider reads and
    checks it. Serving uses mode, me_first and me_first_idle_minutes for the local API beside Darkbloom; it does
    not use route, port or bind yet.
  • Without [local], nothing changes, except on a Mac serving with --local-endpoint: it now pauses Darkbloom while
    you use its local API ("Your own requests pause Darkbloom on your Mac"). A value the section can't take stops the
    provider at startup with one plain line that names the key, for example
    [local] me_first_idle_minutes must be a whole number of minutes from 1 to 120, not 0.

One start screen: only me, the Darkbloom network, or both with me first

  • In a terminal, the first darkbloom start asks how this Mac serves: Only me, on this Mac, Darkbloom
    network
    , or Both, me first (pre-selected: Darkbloom pauses while you use this Mac and comes back after 2 idle
    minutes). With an account key saved, it also asks where your requests go when this Mac can't take them. The answer
    is saved in [local] once the start goes ahead; later starts don't ask again, and darkbloom start --choose asks
    again. See Use your Mac yourself, first.
  • Starts without a terminal (the login service, the app, scripts) never ask. Without a saved choice, a plain start
    keeps today's behaviour exactly: the Darkbloom network, no local port, nothing written. Changed:
    --local-endpoint, which the desktop app's "Alongside the network" passes, now pauses Darkbloom while you use the
    local API (below).
  • A saved Only me serves in a terminal. A start without one, such as the app's Start, is refused in one line
    before anything stops or starts, naming --local, --network and --me-first.
  • New flags, for one start: --network, --me-first; saved settings: --no-me-first, --me-first-idle <min>,
    --route this-mac|my-macs|my-macs-first. Contradicting flags such as --local --me-first are refused before
    anything runs. On a paired Mac they need --solo, like the other single-Mac options.
  • Changed: --local-endpoint now means Both, me first: Darkbloom pauses while you use the local API.
    --local-endpoint --no-me-first keeps the old shared serving. Its LaunchAgent arguments are unchanged.
  • A new local API takes the first free port from 8000 up, never 8000 itself (other local AI apps use it) or the
    pair ports 47420–47423, saves it and says which; --port still picks one.
  • darkbloom status says how this Mac serves in one line (for example Serving: you first — Darkbloom paused since 14:02 …) and where your requests go, with whether an account key is saved. darkbloom local adds the same, and
    names start --me-first beside start --local. With --no-auth, start and status say your requests stay on
    this Mac. No start screen prints the local key (except --local's own banner, as before), and no screen shows a
    speed.
  • darkbloom start's lines, such as its banner and Listening on …, now show at once when its output goes to a log
    or a pipe (start … > log). Before, a start that serves held them until it stopped.

A streamed local request that can't get this Mac's memory is a 503 before any header

  • A streamed request to this Mac's API sends its response head once the engine admits it. One the engine queued for
    memory and then couldn't admit, because its 120 s admission lease ran out or a full paged pool outlasted its
    requeues, now gets HTTP 503 with "This Mac's memory can't hold this request right now. Lower max_tokens or shorten
    the prompt (or send less media), or retry when this Mac's other requests finish.", before any SSE header. Before,
    it got HTTP 200 and then "Response generation failed".
  • A request that isn't streamed and outlasts the admission lease gets the same words (they were "Provider capacity is
    temporarily unavailable.").
  • The prompt progress comments start when the engine admits the request, so a queued request says nothing until then:
    while the engine keeps it queued, its client gets no bytes, headers included, for up to the 120 s lease before its
    503. Before, it got its head at once and a : prefill in progress comment every 5 seconds. A request the engine
    admits at once gets its head within a few milliseconds.
  • A pair's API, Darkbloom's requests and a Nemotron Super request that asks for logprobs (its entries are spliced as
    the stream is read) are unchanged. A request admitted and later preempted, and never admitted again, still ends a
    streamed answer with an error event.

This Mac's model list says what each model takes, and a long prompt shows progress

  • This Mac's /v1/models lists each model's input_modalities: ["text", "image"] for a model it serves with vision, and on a pair's leader the media the pair takes (["text", "image", "video"] for GLM-5.3-Flash and Qwen 3.8 27B in tensor parallel, ["text", "image"] on the GLM and MiMo image candidates, ["text"] on the other pairs). For a model this Mac or its pair serves, darkbloom start --opencode and --hermes give image input exactly when the list does, whatever Darkbloom's catalog says: MiMo V2.6, which the catalog lists as text only, gets it, also when the catalog can't be reached, and a Gemma 4 pair, which serves text alone, no longer gets image input its requests would be refused for (400). Your other Macs' and the network's models keep the catalog's. Reasoning still comes from the catalog.
  • A streamed request to this Mac's API, or to a pair's, gets an SSE comment every 5 seconds from the moment the engine admits it (on a pair's API, accepts it) until its first token: : prefill in progress, <total> prompt tokens, which OpenAI clients ignore. Before, a long prompt streamed nothing after its first chunk until its answer began (9 minutes for a 255K-token prompt on an M3 Ultra). <total> is the prompt's tokens as the engine counts them. Once an engine reports how much of the prompt it has computed, the comment gives that count instead (: prefill <done>/<total> tokens); today's engines report it only when the prompt is done. A prompt done within 5 seconds gets no comment. A request that isn't streamed gets nothing new: give its client a timeout of minutes for a long prompt.

This Mac's model list says which models reason

  • This Mac's /v1/models, and a pair's, lists "supported_features": ["reasoning"] for each model it serves that reasons, loaded or not, and [] for one that doesn't, by the model's type: the same table that takes every reasoning effort for a model and refuses one that is none of the names. Your other Macs' and the network's models keep the coordinator's supported_features, the catalog's.
  • darkbloom start --opencode offers reasoning for a model this Mac or its pair serves exactly when the list says so, whatever Darkbloom's catalog says, also when the catalog can't be reached. Qwen 3.8 27B, which the catalog lists without reasoning, now gets it; a model whose effort would be ignored no longer does. Hermes has no per-model reasoning setting in a provider's block and sends your effort to every model; the ones that reason take it and the others ignore it.

One local API port per Mac, and a local API that can't listen says why

  • Every local API this Mac serves takes the same port: Only me and Both, me first from the start question, a saved choice, --me-first, --local, --local-endpoint and the Darkbloom app's starts, its local mode included. The first one saves it as [local] port, and every later start uses it, so the address your tools were given (http://127.0.0.1:<port>/v1, with the key in ~/.darkbloom/local_token) never moves. Before, --local, --local-endpoint and the app took 8000 while the start question took 8001.
  • A Mac whose local API already serves keeps that port and saves it: the running API's port, else the one its installed background service serves on. A Mac updated from 0.10.10, whose local API serves on 8000 (the app's setup, "Alongside the network", "Local only", --local-endpoint, --local), keeps 8000: Local API port: 8000 (saved; this Mac's local API already uses it). Only a Mac with no local API at all takes the first free port from 8001, never 8000 or 47420–47423.
  • A saved port always wins, and is never moved. --port <n> replaces it and is saved too: Local API port: 8007 (saved, instead of 8005: tools set up for 8005 need `darkbloom --opencode` or `--hermes` again).
  • A Mac without [local] started without a terminal still serves exactly as before: the Darkbloom network, with no local API and no port.
  • When the local API of Both, me first can't listen, darkbloom status no longer reads "Darkbloom network only": it says Serving: Darkbloom and you, me first — the local API isn't up: port 8001 is in use (`darkbloom start --port 8002`), and darkbloom local says the same. Only me names the next free port the same way. On a Mac in a two-Mac cluster these lines name darkbloom start --solo --port <n>, or darkbloom restart for the pair's own API.
  • The app's local mode runs as launchd's --foreground service on that port, saves a new port only once the service started, and its log no longer shows the local key.

Local API: this Mac first, then your Macs

  • The local API (start --local, --local-endpoint and a pair's local API) now routes like the iPhone app. A request
    this Mac can't take (it doesn't serve the model, its queue is full, or it is draining) goes on to your other Macs
    (free) with [local] route = "my-macs". With "my-macs-first" it goes to your Macs first and then the Darkbloom
    network (billed), without waiting on a busy Mac of yours while another Mac can take it. When the network refuses it
    for money (no balance, or the key's spend cap), it goes to your Macs only, free. Nothing leaves this Mac without a
    saved account key, with route = "this-mac", or with --no-auth.
  • darkbloom route key saves the account API key in this Mac's Keychain after one check with Darkbloom
    (--stdin to pipe it in, --remove to remove it). The key is never printed, logged, or written to a file. ^C at
    its hidden prompt gives the terminal its echo back.
  • The local API reads the key once and keeps it in memory; route key tells it when the key changes. It never waits on
    a Keychain dialog to read the key: when the Keychain won't hand it over without asking (a locked keychain, or a new
    local build), it says so once in its log and keeps requests on this Mac.
  • Tools keep one local URL and the local key. Their own route header is ignored. Answers say who served them
    (X-Darkbloom-Served-By: this-mac or darkbloom), and the coordinator's errors come back as sent. A refusal on the
    network route says why: no balance, or Darkbloom's own reason (a key's spend cap, for one). A client that disconnects
    mid-stream stops the request at the coordinator too.
  • /v1/models lists this Mac's models, then your Macs' (and the network's with "My Macs first"), each once, with
    owned_by and, when known, context_length and max_output_length. This Mac's models now say
    owned_by: "this-mac" instead of "local". A model this Mac serves is listed once, under its own id, even when your
    Macs list it under its public alias, and a request for that alias is answered by this Mac.
  • A chat request that names only max_completion_tokens is served with that limit, as max_tokens is.
  • A request this Mac serves takes the same path as before, plus a few microseconds.

Me first: queued Darkbloom requests make room for yours

  • On a Mac that serves both with me first on, a request of yours that has to wait for this Mac's memory, or its room
    for requests, no longer waits behind Darkbloom requests still queued here. Those go back to the network: they end
    with the typed capacity / 503 / draining refusal, which doesn't count against this Mac. Each is served by another
    Mac, or gets a retryable "busy" error (429) if the whole network is full. Darkbloom requests this Mac has started,
    in their prompt or answering, still finish.
  • Your request then waits only for requests this Mac has started, Darkbloom's or your own, up to the engine's 120 s
    admission lease, as before.
  • Nothing changes with --no-me-first, or on a pair.

The memory re-plan keeps a stopped pair stopped and a started one started

  • When a Mac's part of a pair is refused at load twice because its memory moved, the leading Mac plans the model again on the memory now. That re-plan could come due right after you stopped the pair with darkbloom stop, and then started it again. It now does nothing once the pair is stopped, as the leading Mac's steps after an update already do.
  • When that re-plan's own stop of the pair failed (the other Mac didn't answer, or a part didn't release in time), the pair stayed stopped on both Macs until someone ran darkbloom cluster. Now the pair stays started, and the re-plan can come due again.

metal-cpp from the Darkbloom sandbox image

  • scripts/fetch-metallib.sh uses the metal-cpp archive that Darkbloom's macOS sandbox images carry, when it is the archive the nested MLX core names and its SHA-256 matches the pin. The metallib build then makes no download from developer.apple.com, where downloads through the sandbox's egress ended early (transfer closed with … bytes remaining). Elsewhere, MLX's configure downloads the archive as before.
  • Changing the script changes the metallib cache key once: the first CI runs after this change rebuild the metallib.

MiMo image fixture downloads stay on their host

scripts/prepare-mimo-image-http-fixtures.py now follows a redirect only to
the scheme, host and port of the requested URL, for at most 10 redirects. curl
no longer follows redirects itself, so the script never requests another
origin. A redirect to another HTTPS host, another port or plain HTTP fails at
once and is not retried. The provider test gate now runs the script's offline
self-test on every run.

MiMo prompt fixture downloads follow only allowed redirects

scripts/prepare-mimo-prompt-fixtures.py now follows a redirect only when the
target keeps the scheme, host and port of the URL that redirected, or when
https://huggingface.co redirects over HTTPS to a Hugging Face CDN host
(hf.co or a name that ends in .hf.co), where the Hub serves
tokenizer.json. Any other redirect (another host, another port or plain HTTP)
fails at once, is not retried, and its target is never requested. Before, the
script followed any redirect and refused only a final plain-HTTP URL. The
prompt fixture downloaders now share this rule in scripts/fixture_redirects.py.

A Nemotron Super video that decodes too slowly on a provider is retried elsewhere

  • When the wait on the video decoder outlasts its decode allowance (5 s, then 2 ms a frame and 4 ns a coded pixel, at most 120 s of wall time), as on a slow or loaded Mac, Nemotron Super now refuses the request as a retryable 503 (failure code capacity), and the coordinator can send it to another provider. Before, the provider refused the valid video as invalid_media (400).
  • The video's own limits (frame size, frame grid, source frames, control markers, decoded pixels) are still invalid_media (400).

Only me serves in the background, and the background service always serves your saved choice

  • Only me now serves in the background, as Darkbloom network and Both, me first do: the provider LaunchAgent the Darkbloom app's local mode uses, on this Mac's one port. It starts again at login, the watchdog restarts it after a crash, and it updates itself (a check 5 minutes after it starts, then every 30 minutes; it lets your requests finish first). Closing the Terminal window no longer stops it; darkbloom stop does. darkbloom start --local --here serves in the Terminal window instead, for that session.
  • Only me gets the same model list, downloads included, and the same memory question as the other choices, and models idle past that setting are unloaded. When Darkbloom's catalog can't be reached, it serves the models already on the Mac. A Mac with no model it can serve ends with No model to serve yet. See them: `darkbloom models catalog`. Get one: `darkbloom models download <id>`, then `darkbloom start`.
  • A start without a terminal (the app's Start, a script) now serves a saved Only me in the background, instead of refusing, and asks nothing: the models you last chose that are still on the Mac, else every one it can serve.
  • The Darkbloom app's choices are saved too: "Local only" saves Only me, and "Alongside the network" and the app's setup save Both, me first, so the app's Start, Restart and Update keep serving the last choice, as login and the watchdog do. A Mac whose app ran "Local only" before now updates itself there and unloads models idle past idle_timeout_mins (60 by default).
  • Only me reports itself alive from the start, while it loads its models, as Darkbloom network does: the watchdog never takes a first load longer than 5 minutes after an update for a failed start (three of which would roll the update back), darkbloom stop and restart during it drain it, and darkbloom status says Serving: only you, on this Mac — starting: its local API opens once its models are loaded.
  • A mode flag saves the choice (--local, --network, --me-first, --local-endpoint), as the start question does. The background service, darkbloom restart and darkbloom update always serve the saved choice: a service an earlier version or start left serving another way restarts as saved, and says so. Before, start --me-first on a Mac set to the Darkbloom network kept serving Both, me first after restart while the config said network.
  • restart and update wait for Only me's local API, never for coordinator authorization, and never stop Only me running in a terminal (--here): they say to press Ctrl-C there first.
  • Starting Only me where Darkbloom served says so: Darkbloom network serving stops: this Mac serves only you from now on (`darkbloom start --me-first` serves Darkbloom and you). start --local --here says what it stops, and on the way out that nothing serves now and how to serve again.

OpenCode and Hermes: the config writers for --opencode and --hermes

  • The writers that make OpenCode 2 and Hermes Agent ready to use Darkbloom as a provider, called by
    darkbloom --opencode / --hermes.
  • OpenCode gets a providers.darkbloom block in its global opencode.jsonc (or an existing opencode.json): the
    local endpoint at its live port from local.json, the models with their names, context and output limits and
    capabilities, and max_tokens as the output-cap field (OpenCode otherwise sends max_completion_tokens, which the
    engine ignores, so a long answer would stop at its 4,096-token default). Its default model is set only when no
    global config file sets one: with both files, the owner's default in opencode.json stays in effect.
  • Hermes gets providers.darkbloom (key_cmd, extra_body.max_tokens, each model's context and vision) and
    Darkbloom as its main model in $HERMES_HOME/config.yaml (~/.hermes/config.yaml by default), as ollama launch
    and omlx launch make theirs. Models under Hermes' 64,000-token floor are left out, and none at or above it
    refuses. A file in PyYAML's style, with lists at their key's indent as oMLX writes it, is edited and its lists kept.
  • Hermes needs v0.20.2 or later, which added key_cmd (an older Hermes sends no key); the start flag warns in one
    line when the installed Hermes is older. An open Hermes bug (#124289) can drop max_tokens after a /model … --provider <bare name> switch, so
    those turns get the engine's 4,096-token default.
  • Neither file ever holds the key: OpenCode reads it with {file:~/.darkbloom/local_token}, Hermes with
    key_cmd: /bin/cat …. Every comment and key outside the darkbloom block stays (the block itself is rewritten
    whole); a second run with the same models writes nothing; a change first backs the file up to
    ~/.darkbloom/integrations/backups/ (five kept per file name), replaces it atomically and comes with an exact undo
    command. A file Darkbloom can't edit safely (invalid, YAML anchors, several documents) is refused, unchanged.
  • scripts/integrations/opencode-smoke.sh runs the real OpenCode on the written config in a throwaway home against a
    fake server.

The Mac that follows no longer says a serving pair hasn't served

  • On the Mac that follows in a two-Mac pair serving through Darkbloom, darkbloom status and darkbloom cluster status said The pair hasn't served for N min since it started (the other Mac answers). Run … from 15 minutes after every start, while the pair served, before the leading Mac's ✓ Serving …. That Mac looked for the pair's serving line in its own log, but only the leading Mac's part writes it.
  • Because of that line, that Mac also treated the pair as not running there. darkbloom start --solo was allowed and stopped its part of a serving pair. The leading Mac's next lease then started the part again, and it waited behind single-Mac serving.
  • Now the Mac that follows counts its part as serving while it runs and the leading Mac answers, as the other parts do, and leaves whether the pair serves to the leading Mac's lines. It still says the pair hasn't served when its own part never ran in the first 15 minutes, and it still gives its part up when the leading Mac hasn't answered for 15 minutes.

A paired start says what it does, Apple's check reads as progress, and both Macs show the pause

  • A script's darkbloom start on a pair that already serves now says …: the pair already serves., shows the result block and exits 0, without asking either Mac to start again. Before, it said "starting the pair".
  • darkbloom start in a terminal no longer says "starting the pair" before a screen where nothing starts until you choose. On the leading Mac of a stopped pair it says "Press Enter to start it with Qwen 3.8 27B (last used), or choose another model." (or "Choose its model to start it."), and otherwise "opening the pair's screen".
  • During a normal pair start, each Mac's new part waits about a minute for Apple's check (App Attest). Status and a script's start now say … is not serving yet: checking both Macs with Apple., read as loading. Before, every healthy start said "This Mac isn't verified by Apple yet; … Don't restart either Mac until then." for both Macs. That warning now comes only once a Mac's part has run 2 minutes without the check, or its key-generation safeguard holds it back.
  • While a pair that serves Both, me first is paused for you, darkbloom status and darkbloom cluster status on the Mac that follows now say so under the pair's line too, with how long and when it comes back. Before, that Mac said only "✓ Serving … through Darkbloom". The leading Mac's status carries the pause, which the other Mac already asks for, so nothing new crosses the cable.
  • A pair with no model yet: a script's darkbloom start, and the app, now say to choose one with darkbloom cluster in a terminal on the Mac that leads the pair, which has the model list: No model was chosen for the pair yet: choose one with `darkbloom cluster` in a terminal on this Mac. Before, they said to run darkbloom start in a terminal, which on the Mac that follows opens a screen that can't choose one.
  • Pause times are said from now: "paused for 10 minutes", "back in about 2 minutes if you stay idle". Before, they were clock times in the Mac's own time zone, which no line named, such as "since 21:41" read over SSH at 05:41 UTC. This applies to one Mac's Serving: line and to the pair's Pair: line.

On a paired Mac, darkbloom start starts the pair and start --solo serves the Mac alone; no start asks without a terminal

  • On a Mac in a two-Mac cluster, plain darkbloom start now starts the pair whatever its state: in a terminal it opens the darkbloom cluster screen, and without one it starts the pair's saved model and waits until it serves. That includes a pair stopped with darkbloom stop and one whose other Mac isn't answering, as darkbloom stop and darkbloom cluster status already said. Since 0.10.9, a start without a terminal there (a script, or an agent following cluster status) served the Mac alone instead, and one in a terminal asked first.
  • darkbloom start --solo is the way to serve a paired Mac alone. It works whenever the pair doesn't run on that Mac, and is refused while it does (stop the pair first). Single-Mac options need --solo in every state of the pair: without it, darkbloom start --model <id> in a terminal and darkbloom autopilot enable start nothing and exit 64 at once with the reason, as they already did while the pair ran. They no longer serve the Mac alone while the pair is stopped.
  • The desktop app's Start serving has no --solo, so on a paired Mac it now starts the pair, as a plain darkbloom start does, in every state of the pair. It never serves that Mac alone and never waits for an answer. The pair serves its own model: when the app named another, the start ends with This Mac serves in a pair: started the pair with <the pair's model>; `darkbloom cluster` changes its model., which the app shows. Since 0.10.9 it served the Mac alone while the pair didn't run there, and was refused while the pair ran.
  • The lines that name the way back now say darkbloom start for the pair and darkbloom start --solo for serving alone: darkbloom status for a part that stopped because the other Mac stopped answering, the Next: line of cluster status, restart on a Mac where nothing serves, and the line start --solo prints. They no longer send you to darkbloom cluster to start the pair.
  • darkbloom start --solo, restart and update on a Mac with a leftover part of the pair now say that its saved start is cleared only once it is. They first say that they are stopping the leftover part. If a cluster command is running, they wait for it; when it is still running after 10 minutes, nothing is stopped or cleared, and they no longer say it was.
  • No start asks a question without a terminal. On pair-2, a start with --opencode that got no answer waited forever on "Serve on this Mac alone / Start the pair"; that question is gone. On a paired Mac, a start without a terminal, with or without --opencode or --hermes, starts the pair and reads nothing. Where a start can't go on without asking, it says in one line what to add.
  • A start for Darkbloom network or Both, me first that names no models (--model <id>, --all) can't pick them without a terminal. On any Mac it now says so in one line and stops (exit 64), before anything is stopped or started, instead of printing the numbered model list and waiting for an answer that may never come. Only me serves the models already on the Mac and is unchanged.
  • darkbloom status on a paired Mac now says plainly when the Mac serves alone instead of the pair: a line under the pair's block names single-Mac serving and its process, and its own Daemon:, Serving: and Trust: lines follow. Before, it said only "Single-Mac serving: running beside the pair" at the end, and the Serving: line needed status --solo.

Qwen 3.8 27B pairs with the assistant now prefill as fast as pairs without it

  • A Qwen pair in tensor parallel that decodes with its speculative assistant processed each 512-token prompt chunk one at a time, waiting for its link traffic after each. It now processes up to eight chunks together, as a pair without the assistant already did, so one chunk's link traffic overlaps the next chunk's compute, and assisted pairs prefill at the same rate as pairs without the assistant. Measured gains: about 1.25× on an M3 Ultra + M5 Max pair serving real requests through DevNet, and about 1.85× on two M5 Ultras with the bench tool (synthetic prompt tokens, real weights); the gain depends on the Macs and the prompt. The prompt's results and the assistant's state are unchanged.

Qwen3.8-27B pairs decode with their speculative assistant through Darkbloom

  • Two-Mac pairs that serve Qwen3.8-27B in tensor parallel through Darkbloom
    now decode with the model's speculative assistant (depth 3), as local
    clusters and single Macs already do. The guided setup plans it under the
    default mtp_mode = "auto". mtp_mode = "off" still plans the pair
    without it. If the assistant cannot be planned, the pair is planned plain,
    as before, and the setup screen and darkbloom cluster status say why in
    one line.
  • On one pair, the same requests decoded with the assistant and without it
    gave identical greedy, sampled and tool answers. Requests that ask for
    logprobs, use penalties or a logit bias, or carry images decode one token a
    step, as before. The evidence is in
    docs/reports/2026-11-05-qwen27-public-assistant.md.
  • The release's cluster runtime facts name the assistant: the model's
    serial-prefill tensor-parallel qualification rests on that report, and its
    resource policy digest carries the build's declared assistant settings. A pair whose Macs run another
    assistant is refused before any part stops.
  • Speed records from served requests now say whether the request came through
    Darkbloom or the local API and whether the assistant decoded it. A plan uses
    only the records served the way it will serve, so a local pair's assisted
    speed no longer stands for the same pair through Darkbloom.

Every model that reasons takes every reasoning effort a client sends

  • reasoning_effort and reasoning.effort take none, minimal, low, medium, high, xhigh and max on every model that reasons, on one Mac, on a pair and through the coordinator. Each becomes the model's nearest level, the higher one between two: minimal its lowest, max its highest, none thinking off where the model can.
  • Qwen 3.8 27B (and the owned Flash-Next build) answered high and max with a 400 "Invalid inference request.", so Hermes, which sends the user's max, fell back to the user's other, paid provider. They now render xhigh, the template's highest level, and minimal renders low.
  • MiMo V2.6 thinks for every effort but none (it refused them all), Nemotron 3.5 Super renders minimal and low at its medium depth and xhigh and max at its default (it refused them), and DiffusionGemma and Flint take max.
  • An effort that is none of the names is refused on every model that reasons, also on Qwen 3.5 and 3.6, Bonsai 2, Gemma 4, GPT-OSS and Nemotron 3.5 Lightning, which rendered it. The local API answers 400 with code invalid_reasoning_effort, the field in param, and the accepted names. A model that doesn't reason ignores any effort.
  • Nemotron 3.5 Super reads both reasoning_effort and reasoning.effort, and refuses two that differ, even two names such as high and max. Its local API now answers that with the same 400 as an unknown name (code invalid_reasoning_effort, param naming both fields, and the accepted names), where it gave an untyped "Invalid inference request." Send one of them, or the same effort in both.

darkbloom restart on a stopped pair starts nothing

  • On a Mac in a two-Mac cluster whose pair is stopped, or doesn't run on that Mac, darkbloom restart and the app's Restart no longer start single-Mac serving that was stopped. Since 0.10.9 they started it whenever its launchd file was still on disk, and darkbloom stop keeps that file. So a Mac that served alone before it was paired began serving alone again with its old models, registered with the coordinator and held the Mac's serving lock, and the pair couldn't start until single-Mac serving was stopped again. Now a plain restart there restarts single-Mac serving only while it runs. With none running it changes nothing, exits 1, and says that darkbloom start starts the pair and darkbloom start --solo serves the Mac alone. restart --solo still starts single-Mac serving that is set up but stopped.
  • After a restart of single-Mac serving on such a Mac, restart no longer says "darkbloom restart restarts both Macs", which a restart there doesn't do. It says that darkbloom start starts the pair. Where the pair is started but its other Mac is gone, restart says the pair isn't running there instead of "This Mac serves in a two-Mac cluster".

darkbloom route this-mac, my-macs or my-macs-first

  • darkbloom route this-mac, darkbloom route my-macs and darkbloom route my-macs-first save where your requests go when this Mac's local API can't take them ([local] route), so the route no longer needs a hand edit of provider.toml or a whole darkbloom start --route. Each says what it means: my-macs sends them to your other Macs, free, and never to the network; my-macs-first sends them to your other Macs, then to the Darkbloom network, billed, and requests from other machines (your LAN or tailnet) never use the paid network.
  • my-macs and my-macs-first need your account API key: without one they save nothing, exit 1 and name darkbloom route key. They only ask whether a key is saved; no line shows a key.
  • A running local API uses a saved route from its next request, with no restart and no model reload: its router reads [local] route again when provider.toml changes (one stat by a request this Mac can't take or a model list; none for a request this Mac serves). The command says "Saved. Your local API uses it now.", or "It applies when your local API starts." with none running. A malformed edit keeps the last good route and is said once in the local API's log, with nothing from the file. So does a read that catches an editor saving the file in place (it empties the file before it writes it): only a whole file counts, so a saved this-mac never passes a request on while the file is saved.
  • darkbloom route key says the same when it saves or removes the key, which a running local API already read again from its next request. A key removed while the route passes requests on says that the next request this Mac can't take gets this Mac's own answer.
  • That answer now says why. A request this Mac can't take, with my-macs or my-macs-first saved and no account key, or after darkbloom route key --remove removed the key a running local API used, keeps this Mac's 404, 429 or 503. Its message says that this Mac doesn't serve the model (or can't take the request now), and that reaching your other Macs needs an account key (darkbloom route key), with code account_key_needed. The local API's log says it once, never with the key. Before, it was this Mac's plain "Requested model is unavailable." with nothing in the log.
  • In a two-Mac cluster, both commands say plainly that the leading Mac's route and key apply: the pair's local API runs there, and requests from the other Mac reach it from another machine, so with my-macs-first they never use the paid network, which both Macs now say. Their words are now true for each Mac. On the leading Mac, a removed key says that the pair passes nothing on until a key is saved there again, route this-mac says that the pair's local API passes nothing on, and the summary and --no-auth lines name this pair, not this Mac. The other Mac says only that the leading Mac's route decides what the pair passes on, and names darkbloom route key, or darkbloom route key --remove, to run on the leading Mac; refused for want of a key, it names the leading Mac first. A pair's local API without a local key (--no-auth) never claims to pass requests on.
  • darkbloom route key, with [local] route = "this-mac", now names darkbloom route my-macs to use the key.

A simpler start: Autopilot only for the network, a picker that opens on what fits, no key on screen

  • The experimental Autopilot is for the Darkbloom network, so darkbloom start asks about it only when this Mac serves the Darkbloom network. Both, me first never asks and keeps your saved answer; darkbloom autopilot enable, --autopilot and --no-autopilot change it. Only me has no Autopilot: there, darkbloom autopilot enable says Autopilot requires a network provider. Nothing was saved.
  • The model picker opens with your last selection still on this Mac selected, else one downloaded model that fits with room to spare, else the smallest one that fits. It never pre-selects a model it would have to download, and no longer the biggest one that fits (it pre-selected a 176 GiB model on a test Mac).
  • No start screen prints the local key: darkbloom start --local --here now says API key: `darkbloom local` shows it, and where your requests go, instead of the key and export OPENAI_API_KEY=… lines.

One flag sets OpenCode or Hermes up: --opencode and --hermes

  • One flag sets OpenCode 2 or Hermes Agent up to use Darkbloom, as ollama launch and omlx launch do:
    darkbloom --opencode, darkbloom --hermes, or both. If this Mac's local API already runs, nothing restarts;
    otherwise start runs as usual and the tools are set up once its local API answers.
  • It prints the file it changed, the backup and a one-line undo, then where your requests go and the two variables
    other OpenAI clients need (naming the key file, never the key). No line, and no tool file, holds the key.
  • A Hermes older than v0.20.2 is set up with one warning line: it can't read the key until hermes update.
  • A tool that isn't installed, OpenCode 1, Hermes without a 64K-context model, or a start that serves only the
    Darkbloom network: a plain ✗ line, nothing written, and Darkbloom keeps serving. Refused with --network and
    --no-auth (and with --distributed). Beside a running --no-auth local API, it says so and starts nothing.
  • Without Darkbloom's catalog (offline, or the coordinator down), a run again keeps each model's name, image support
    and limits as they were set up, changes nothing, and says the catalog wasn't reachable. A model set up for the first
    time then gets its ID and text input only, and one line says to run the start again online for its name and image
    support.
  • A model that isn't loaded yet gets one line: run the start again once it is, to pick up its limits. See
    Use it from OpenCode or Hermes, which also
    covers OPENCODE_CONFIG_DIR and Hermes profiles.

Qwen tensor-parallel decode wastes less time per token

  • A Qwen pair now hands each token's work to the GPU every eight layers instead of after every layer, so the GPU spends less time waking up and waiting. On two M5 Ultras a token took about 15 % less time for one request and about 13 % less for four at once. The output is unchanged.

darkbloom --opencode and --hermes say what happened to your default model, and where the models run

  • OpenCode: Darkbloom's model becomes OpenCode's default only when OpenCode has none: neither of its global config files sets one (opencode.json, opencode.jsonc; OpenCode 2 doesn't read OpenCode 1's config.json), and its TUI remembers no model you picked with /models (~/.local/state/opencode/model.json). Its own line says so, and how to go back for good: New OpenCode sessions now use Darkbloom's Qwen 3.8 27B. To go back, remove "model" from ~/.config/opencode/opencode.jsonc or run the Undo below. When a file sets one, nothing is written for it, and the line names it: Your default stays exo/llama-3.3-70b; pick Darkbloom with /models. When OpenCode remembers a pick: Pick Darkbloom once with /models; OpenCode remembers it. The Undo: line stays.
  • Hermes: Darkbloom still becomes the main model, and the line names the one it replaced: New Hermes chats now use Darkbloom's Qwen 3.8 27B (before: gpt-6-astra via opencodex). Switch back: hermes model. Its headline matches OpenCode's (✓ Hermes can use Darkbloom: 1 model.).
  • A start with a tool flag beside a local API that already serves names the URL the tools use, not the address it listens on: Darkbloom already serves at http://127.0.0.1:8001/v1; setting up OpenCode for it. (it said 0.0.0.0:8001 for a pair's).
  • On a Mac whose local API is its pair's (the leading Mac's, or a member's relay), the tools name the pair's models Qwen 3.8 27B (your pair), not (this Mac), for a pair of any size; a run again changes nothing. Hermes makes the pair's model its main one, as it does this Mac's, and a pair's models take their engine's word on image input and reasoning, as this Mac's do.

darkbloom --opencode and --hermes wait for your model, and starts say when a tool points elsewhere

  • Before it writes a tool's config, the start waits while this Mac still loads the models it started with, so OpenCode and Hermes get the limits this Mac gives each model instead of the catalog's. A terminal shows one live line, ⠙ Loading Gemma 4 26B before setting up OpenCode… 42s; without one, a line as it starts and one as it ends. It waits at most 10 minutes. A model still loading then, or one that didn't load, sets nothing up, and one line names the next step (darkbloom status, then darkbloom --opencode again). Ctrl-C stops the wait: nothing is written, and the start says so, also when the model finishes loading just then. Darkbloom keeps serving either way. On one Mac only for now: a pair's local API isn't waited for.
  • A model that isn't loading as the tools are set up (one unloaded when idle, or one that loads on a request) is named in one line: run darkbloom --opencode again once darkbloom status shows it loaded. That holds too when a route that dials out lists the catalog's limits for it.
  • A start without --opencode or --hermes never changes a tool's config. When OpenCode or Hermes is set up for another address than this Mac's local API (another port or --bind), or reads another key file, one line says so: OpenCode points at http://127.0.0.1:8001/v1, not this Mac's local API (http://127.0.0.1:8002/v1): `darkbloom --opencode` points it there. localhost, 127.0.0.1 and ::1 are this Mac, in any case, and so is its .local name for an API on every address. On one Mac only for now: a paired Mac's start doesn't say it.

The update check asks again instead of waiting a minute, and says what failed

  • The check for a new release sent one request to the coordinator and waited up to 60 seconds for its answer. When that connection stalled, darkbloom update failed after a minute with "download failed: update check failed: The request timed out", although nothing had been downloaded, and --check-only with "update check failed: …". Now each try waits at most 15 seconds, and a try that gets no answer, loses or can't open its connection, or can't resolve the coordinator's name is made again after 0.5 to 1, then 1 to 2 seconds: 3 tries, under a minute in all. An answer from the coordinator, an error included, is not asked again. Every automatic update (a single Mac's, a pair's, the watchdog's and the startup check) uses the same check.
  • A pair's automatic update, at its update slot or catching up with the other Mac, asks once more 1 to 2 minutes after a check without an answer, within the same slot, so one stalled minute no longer costs both Macs 30 minutes.
  • A check that still fails says what failed and what to do, on two lines, and points at the network only when no answer came: Couldn't check for updates: api.darkbloom.dev didn't answer within 15 s (3 tries). Nothing was downloaded or changed. and Run `darkbloom update` again in a minute. If it keeps failing, check this Mac's network connection. When the coordinator answered with an error or with no release this Mac can use, the second line says the network works; when the check failed on this Mac (its update record, its coordinator URL), it says so.
  • Each failed try is logged with how it connected (HTTP version, a new or reused connection, direct or through a proxy, the address) and the error's domain and code, so a stall leaves evidence in the provider's, the cluster service's or the watchdog's log.

A video whose decoder fails once is decoded again, not refused

  • When the video reader of GLM 5.3, MiMo V2.6, Qwen4 or Nemotron Super fails on a video that passed its metadata checks, the provider decodes the video once more with a new reader over the same bytes. A valid video that met one reader failure is now served with the same frames. Before, GLM refused it as invalid_media (400), and the coordinator did not send it to another provider.
  • When the reader fails again with a decoder, hardware or interruption fault, the provider refuses the request as a retryable 503, and the coordinator can send it to another provider. Any other second failure, such as a truncated video, is still the deterministic invalid_media (400). A Qwen4 video whose reader fails twice without such a fault is now invalid_media (400) too; before, every Qwen4 reader failure was a retryable 503.
  • Each failed reader pass logs a WARN engine_health event video_reader_failed with the reader status and the domain and code of its errors. It carries no media or prompt content.

Pull requests in this release

83 pull requests merged into dev reached master with #1837, #1859, which promoted dev up to 12c88dfa7b:

  • CI (dev): build each lane once on a large Mac, test on small ones by @davidtai in #1817
  • ci: per-job macOS sizes for Darkbloom routing, gated by DARKBLOOM_JOB_SHAPES by @davidtai in #1821
  • fetch-metallib: use the metal-cpp archive the Darkbloom sandbox image carries by @davidtai in #1814
  • cluster: a served request longer than the model's limit no longer hides the model; a blocked approved model says why (0.10.9) by @jonathan308 in #1828
  • cluster: #1828 nits — say an uncredited speed-up, plain skipped line and plan-failure reason (completes #1828 for 0.10.9) by @jonathan308 in #1831
  • cluster: Qwen3.8-27B pairs decode with the speculative assistant through Darkbloom (parity evidence; served speeds keyed by how they were served; includes #1718) by @jonathan308 in #1819
  • Onboarding checks: a run's reader stops before its terminal closes by @davidtai in #1825
  • Qwen TP decode: submit every 8 layers, not every layer (−15 % solo, −13 % at 4) by @jonathan308 in #1820
  • Gemma TP: build greedy steps one ahead (GLM's step order) by @jonathan308 in #1822
  • Gemma TP: build sampled steps one ahead too (stacked on #1822) by @jonathan308 in #1824
  • tp-check gemma run: --layer-stride to measure Gemma's decode stride by @jonathan308 in #1827
  • Qwen TP batch driver: build-ahead protocol (gated, off until the native executor submits steps) by @jonathan308 in #1830
  • Retry cut prompt fixture downloads; keep integrity failures final by @davidtai in #1833
  • Qwen TP native executor: submit and read decode steps in two phases (PR6a, stacked on #1830) by @jonathan308 in #1832
  • qwen-decode --build-ahead: measured −7.8 % (w1) / −5.7 % (w4) on the pair (PR6c, stacked on #1832; default stays off) by @jonathan308 in #1834
  • ci: sample macOS job memory by class; bound update hash memory by @davidtai in #1829
  • ci: size each Darkbloom macOS lane from its sampled memory by @davidtai in #1838
  • fix(cluster-api): end a rejected stream with the single-Mac error chunk before the pair retires by @jonathan308 in #1839
  • provider: release each chunk of a chunked file read by @davidtai in #1836
  • test: disable the flaky GLM video readiness test (#1847) by @davidtai in #1848
  • Revert #1848: run the GLM video readiness test again by @davidtai in #1849
  • Test the App Attest stop bound by order, not wall time by @davidtai in #1852
  • cluster: a pair takes the requests it can serve and reports its speed (provider 0.10.10) by @jonathan308 in #1844
  • Gemma TP prefill: one shared expert dispatch per prompt chunk (1.87×, same tokens) by @jonathan308 in #1842
  • fix(cluster): DevNet and production no longer share a pair on one Mac by @jonathan308 in #1846
  • Test the cluster group stagger by launch times, not child startup by @jonathan308 in #1856
  • Gemma TP prefill: prompt chunks in row parts, sums issued as built (same tokens; off by default) by @jonathan308 in #1843
  • fix(cluster): production guard follow-ups from #1846's final review by @jonathan308 in #1857
  • Decode a video again when its reader fails, and keep the cause by @davidtai in #1851
  • fix(cluster): the setup quotes no tok/s; the mode advice follows the pair's measurements after an update by @jonathan308 in #1858
  • Qwen TP: assisted lanes prefill merged prompt steps (the wavefront; same bytes) by @jonathan308 in #1854
  • Darkbloom watchdog: copy darkbloom-sandbox's template at d6d257c2 (reads any listing size, rescues partial strands) [dev] by @davidtai in #1861
  • Link control: report a superseded session's end, with the peer's rekey by @davidtai in #1862
  • Owner-retirement tests wait on the real retirement events by @davidtai in #1869
  • Nemotron Super video: retryable 503 for a spent decode allowance; tests decode under the ceiling by @davidtai in #1871
  • Keep MiMo image fixture redirects on the requested origin by @davidtai in #1865
  • Stop the pairing and console pty readers racing their terminals' end; run both families in CI by @davidtai in #1866
  • fix(provider): make the toy Qwen calibration test independent of GPU speed by @davidtai in #1874
  • CI (dev): split the slow cluster runtime groups over 5 shards by @davidtai in #1868
  • Run the real-geometry rows check in two halves on separate GPU shards by @davidtai in #1872
  • Provider CI: pack only what the test jobs read by @davidtai in #1882
  • ObservabilityChecks E12: count the status publisher's ticks, not wall time by @davidtai in #1864
  • Read a MiMo audio track again when its reader fails, and keep the cause by @davidtai in #1867
  • SSHChecks: the renewal cadence check decides on slow hosts instead of refusing by @davidtai in #1883
  • Keep each reader in the test reader trackers so the audio fault tests end the audio reader by @davidtai in #1886
  • cli: darkbloom start --opencode / --hermes (I-D2b, stacked on #1878 + #1873) by @jonathan308 in #1880
  • cluster: Both, me first for a pair in darkbloom cluster (local-first L5b-cli) by @jonathan308 in #1884
  • cluster: darkbloom restart on a stopped pair never starts single-Mac serving by @jonathan308 in #1887
  • cluster: a pair stays started when its automatic stop after an update fails by @jonathan308 in #1888
  • docs: the first docs lead to local use, with one set of mode names (LS-5 docs) by @jonathan308 in #1891
  • LS-1 PR-a: one local API port per Mac, and a local API that can't listen says why by @jonathan308 in #1896
  • cluster: the memory re-plan never starts a pair its owner just stopped by @jonathan308 in #1889
  • cluster: the Mac that follows no longer says a serving pair hasn't served by @jonathan308 in #1895
  • cluster: on a paired Mac start starts the pair, --solo serves alone, no start asks without a terminal, and status says what this Mac serves by @jonathan308 in #1892
  • cli: darkbloom --opencode and darkbloom --hermes (short for start --opencode / --hermes) by @jonathan308 in #1901
  • provider: a single Mac serves its model's whole window and holds every request to it by @jonathan308 in #1893
  • provider: this Mac's /v1/models says what each model takes, and a long prompt shows progress (R-FULL D7, D8; stacked on #1893) by @jonathan308 in #1897
  • fix(provider): the update check asks again, 15 s a try, and says what failed by @jonathan308 in #1890
  • desktop, cluster: the app on a paired Mac offers Start serving, never Autopilot, and its lines say what happened by @jonathan308 in #1905
  • ci: restore the prompt parity fixtures from a verified cache by @davidtai in #1885
  • LS-1 PR-b: Only me serves in the background, and the service always serves the saved choice by @jonathan308 in #1899
  • LS-1 PR-c: a simpler start — Autopilot only for the network, a picker that opens on what fits, no key on screen by @jonathan308 in #1900
  • ci: hourly full CI (dev) run of dev (workflow_dispatch selects every suite) by @davidtai in #1917
  • cluster, status: a paired start says what it does, Apple's check reads as progress, and both Macs show the pause, from now by @jonathan308 in #1908
  • cli: darkbloom route this-mac|my-macs|my-macs-first saves the route (LS-6, R12) by @jonathan308 in #1902
  • cluster: darkbloom cluster leave leaves a pair in one command, from either Mac (LS-6, R14) by @jonathan308 in #1903
  • test(provider): pin cluster local's own model list and the pair's 5 s progress cadence (#1897 review follow-up) by @jonathan308 in #1907
  • provider: every model that reasons takes every reasoning effort, as its own level (B-J2-1) by @jonathan308 in #1909
  • Wait for the release and engine cancel events in the MiMo cancellation test by @davidtai in #1919
  • tools: darkbloom --opencode / --hermes wait for the model to load, and a start says when a tool points elsewhere (LS-4) by @jonathan308 in #1904
  • provider: Gemma 4 thinks for an effort, GPT-OSS renders its Harmony level; the coordinator's effort table is checked against the provider's (B-J2-1, stacked on #1909) by @jonathan308 in #1916
  • provider: me first re-routes Darkbloom work that hasn't answered when your request waits (R-FULL PR A) by @jonathan308 in #1910
  • provider: a streamed local request that can't get this Mac's memory is a 503 before any header (R-FULL PR B; stacked on #1910) by @jonathan308 in #1912
  • provider: this Mac's model list says which models reason, and OpenCode follows it (B-J2-1 part 2, stacked on #1909) by @jonathan308 in #1914
  • cluster: every Mac of a pair answers locally in Both, me first (member relay, one key per Mac) — LS-3 by @jonathan308 in #1894
  • doctor: a Local API section first, and no network checks on Only me (LS-6, R17) by @jonathan308 in #1906
  • tools: say what happened to your default model, name the URL and "(your pair)" (journey 2a J2-e/f/g; stacked on #1904) by @jonathan308 in #1911
  • Follow only same-origin and Hugging Face CDN redirects for MiMo prompt fixtures by @davidtai in #1924
  • Wait for the native cancel event in the local disconnect cancellation test by @davidtai in #1925
  • fix(checks): the diagnostics and placement-flow runners compile again, and CI runs them by @jonathan308 in #1913
  • cluster, provider: a Gemma 4 pair serves its whole 262,144-token context in both modes, cuts an oversized max_tokens, and refuses in one Mac's words before any SSE header — R-FULL D2/D3 by @jonathan308 in #1923
  • docs: a pair paused for its owner keeps its base reward on the 0.10.11 coordinator (darkbloom-platform#709) by @jonathan308 in #1927
  • fix(cluster, provider): a Gemma 4 pipeline serves the memory plan's request; long requests go to tensor parallel (D6) by @jonathan308 in #1930

2 pull requests merged directly into master:

  • Darkbloom watchdog: copy darkbloom-sandbox's template at d6d257c2 (reads any listing size, rescues partial strands) [master] by @davidtai in #1860
  • ci: schedule the hourly full CI (dev) run of dev (7 * * * *) by @davidtai in #1918

4 release pull requests, not listed above: #1837 promoted dev up to 02880d33c3; #1859 promoted dev up to 12c88dfa7b; #1938 prepared the release; #1855 merged master into dev.

Full Changelog: v0.10.10...v0.10.11