Repository navigation
v0.10.11
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 | bashWhat'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/mlxandlibs/mlx-swiftare unchanged,libs/mlx-swift-lmmoves (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, addme_first = falseunder[local]in~/.config/darkbloom/provider.toml, then rundarkbloom 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_effortis now refused with a typed 400 (invalid_reasoning_effort, the field inparam, 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,xhighandmax, 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 rendershighasmediumuntil it updates. - Cut, don't refuse: on one Mac, a
max_tokenslarger than the prompt leaves is cut to the model's window, and the answer ends withfinish_reason: lengthif it gets there. A request with nomax_tokensmay 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.
- Macs serving with
- Use your Mac yourself, first.
- The first
darkbloom startin 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 --chooseasks 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 --opencodeanddarkbloom --hermes(alsodarkbloom start --opencode/--hermes) set OpenCode 2 or Hermes Agent up to use your Mac, the wayollama launchdoes: 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 withdarkbloom --opencodeas the next command.- Routing: this Mac first, then your Macs.
darkbloom route this-mac,my-macsormy-macs-firstsaves 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 withmy-macs-firstand an account key saved bydarkbloom route key. Answers say who served them. - Pairs:
darkbloom clusterasks 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 leaveleaves a pair in one command, from either Mac.darkbloom doctoropens 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 statussays 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.
- The first
- 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_tokensup 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_tokenscut, itscontext_length_exceededwords 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_longorcontext_length_exceeded); an oversizedmax_tokensis 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 startstarts the pair andstart --soloserves the Mac alone;darkbloom restarton 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.
- 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
- 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 leaveon 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 doctorcan 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_effortsent 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 --localsaves 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.
- 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
- 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 updateon each Mac.darkbloom update --rollbackputs 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 reportsdrainingwithbusy_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 andcluster status --json'snextnow also namedarkbloom start --soloto 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_healtheventaudio_reader_failedwith 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 Testsgate 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
devandmastersave it after both parity steps pass; pull requests restore it and save nothing. scripts/prepare-prompt-fixtures.py --download-cache(PROMPT_PARITY_DOWNLOAD_CACHEin 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.shandprovider-swift/Tests/ClusterPlacementChecks/run-flow.sh
compile again. Since 2026-11-04 both stopped atcannot 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.swiftalone 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.ymlruns frommaster's schedule at minute 7 of every hour. It dispatches CI (dev) ondev, 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 ondev. Dispatched runs share one concurrency group: a new dispatch never cancels a running one. - When a job of a dispatched run fails,
Report hourly failurescomments on the open issueHourly 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_SHAPESis exactlyon. 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
requiredlanesbuild-cluster,build-providerandcluster-release-checks. A run that tests every component then asks for 10 macOS jobs. While sizes are off, therequiredjobs useblacksmith-12vcpu-macos-27without 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 keepsblacksmith-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_availableorlane_not_enabled. - The
DARKBLOOM_MACOS_LANEScap still keeps the critical-path test lanes first. Therequiredlanes come after them.
Provider CI: smaller test products hand-off
- The test products archive leaves out what no test step reads: every
.dSYMbundle (the test bundle's own included), the host tools (the-toolmacro andModules-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 theProvider Testsgate, so it set the run's wall time. QwenTensorParallelRowsCheck.runtakes 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.QwenTensorParallelRealGeometryRowsTestsruns each half as a test:rowsEqualTheirSoloStepsAndWindowPositionsAtRealWidths(rows) and the newrowsAcrossKVSegmentsEqualTheirSoloStepsAtRealWidths(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 runstill 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-27and 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 inbase-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:Gemma4TensorParallelTestson 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 sharetest-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 Testsgate 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.jsonshow 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 (~/.darkbloomand~/.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 --serviceanddarkbloom-dev uninstallact 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-onwaits 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 clusteron both to pair it again. If the DevNet app was the last to pair on a Mac before this update, the production app'sdarkbloom clustermay 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 --removein 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 clusterstarts 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 localanswers, 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 stepsdarkbloom uninstall, Start over anddarkbloom cluster pair --forgettake. Leaving no longer takes four steps:cluster pair --status, reading a pin,cluster pair --forget <pin>, thenstart.- 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 startserves it alone, ordarkbloom clusterpairs it again), what the stop did to the other Mac and that it keeps its pairing until you rundarkbloom cluster leavethere, and how the two Macs pair again (darkbloom clusteron 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, rundarkbloom cluster leavethere."cluster pair --forgetanduninstallsay the same. - While leaving, and in
darkbloom uninstall, the stop no longer says "Rundarkbloom clusterto serve again", "to start it again", or to stop the other Mac's service withcluster 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 statusand astart's result now end "If the other Mac left the pair,darkbloom cluster leavehere unpairs this Mac too." instead of sayingstarton either Mac starts the pair, anddarkbloom clusterthere offers Start over ordarkbloom cluster leavefor a Mac that left.
Both, me first for a pair, in darkbloom cluster
- In a terminal,
darkbloom clusternow asks how a pair serves, with the single-Mac start's three choices: Only me
(this pair, local), which isdarkbloom 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] modeonce the start goes ahead.darkbloom cluster localis 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 statusanddarkbloom cluster statussay 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 thatdarkbloom localon
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-membertakes--local-endpoint --port --bindfrom 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, ascluster localalready didn't. The coordinator's count never includes that leader, so
with exactly one other Mac serving the model the request was refused asthis_mac_onlyinstead of going to that Mac. - With Only me saved, by
darkbloom clusterfor the pair or bydarkbloom start, adarkbloom 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 localthere printshttp://127.0.0.1:<port>/v1and the key to use,darkbloom statusnames
that address instead of pointing at the leading Mac, the setup's ✓ block prints this Mac's own address once its port
is up, anddarkbloom start --opencodeor--hermesthere 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 (--bindloopback 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 statuson that Mac names
the port and says to free it, or set another[local] portinprovider.toml, then rundarkbloom restart. For the
pair's API this replaces "darkbloom restartstarts 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: itsdarkbloom statussays 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 a503(codepair_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 rundarkbloom stop, thendarkbloom 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 usual401, or a503without 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 statusanddarkbloom localnow 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 a503withcodepair_api_unavailable. - On the other Mac,
darkbloom localanddarkbloom start --opencodesay 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), asdarkbloom statusdoes:localno
longer prints the pair's key there, and--opencodesays it at once instead of after a 30-second wait. While that
address is still starting,localsays 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 saysstatus'sLocal 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 --opencodeon 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 = falsekeeps 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
drainingwithbusy_reason: "owner", which takes the whole
pair out of routing, your ownselfandpreferrequests 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 clusterstarts 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_tokensup to 65,536, the catalog's output limit and the value the coordinator gives a request that omitsmax_tokens. It accepted at most 32,768 before. In production, five 18,774-token prompts that asked for 65,536 were refused with 503request_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_limitson 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
coordinatorwith 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_choicethe 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 clusteralready 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 stopanddarkbloom start --soloon a Mac where the pair doesn't run now wait, up to 10 minutes, for a cluster command that is running, asdarkbloom cluster stopdoes. 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 --opencodeisdarkbloom start --opencode, anddarkbloom --hermesisdarkbloom start --hermes;
both together work too. Any otherstartoption goes with them, in any order (darkbloom --opencode --me-first,
darkbloom --me-first --opencode), andstart's errors and refusals apply.darkbloom start --opencodekeeps
working;--help,--version, plaindarkbloomand every subcommand are unchanged, and a mistyped flag
(darkbloom --opencod) gets the usual unknown-option error.darkbloom --helpshows the two shortcuts, one line each.- The lines that name the command say the short form:
darkbloom local'stools:line, the line--portprints
when it replaces a saved port, the refusals, the tool step's lines, the installer's closing lines, and the comment
above thedarkbloomblock 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.ymlis now darkbloom-sandbox's template atd6d257c2, copied unchanged. The old copy passed the day's run and job listings tojqas command-line arguments. When the repository was busy they were larger than Linux allows for one argument, and the watchdog failed withArgument list too long(exit 126) before it checked any run. It now passes listings tojqthrough 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_MINUTESabove such waits. The repository variables are unchanged.
darkbloom doctor knows how this Mac serves you
- The report opens with a
LOCAL APIsection: 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, ordarkbloom restartfor a stopped background service (it starts again as saved), the free port to use, ordarkbloom --opencode/--hermesto 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(restartnever stops it, and would serve your saved choice); the background service withdarkbloom restart; a service serving another way than your saved choice withdarkbloom startand that way's flag. - On a Mac set to Only me,
doctorno 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 verifyis 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--soloin its commands. A Mac whose own port passes the pair's API on, and can't now, says why instatus'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 startjudges them:localhostis 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, asreasoning_effortorreasoning.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,minimalandlowaslow;mediumasmedium;high,xhighandmaxashigh.highrenderedmediumbefore, andminimal,xhighandmaxreached 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 rendershighasmediumuntil 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_tokensabove 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 withfinish_reason: lengthif it gets there. Before, it was refused with 400output_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/modelson the leader anddarkbloom cluster locallist the context and output the pair serves, and default an omittedmax_tokenswithin 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 --opencodeasks how this Mac serves (Only me, Darkbloom network, or
Both, me first), then sets OpenCode up (/models→ Darkbloom;darkbloom --hermesfor Hermes), and that two Macs
pair withdarkbloom clusteron each. The last line is the command to run next, with its full path so it works
before the shell picks up the newPATHline:Next: ~/.darkbloom/bin/darkbloom --opencode. Before, it listed
doctor,models catalog,models download,loginandstart. curl … | bashprints 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
rekeyand dialed again at once. If its next session arrived before the listener's reader read the goodbye, the old session ended with nodisconnectedevent.testRecordBudgetRollsOverToFreshKeysfailed on master push run 42258366869 for this reason. Now a superseded session gives exactly onedisconnectedevent, after the newer session'sconnected. The listener shuts down only the sending side of the superseded session, so its reader can still read the goodbye. The reason isrekeywhen the session ended as a rollover, andsupersededfor all other ends. Neither reason is a peer loss. When the edge stops, it also ends each superseded session that is still reading. testRecordBudgetRollsOverToFreshKeyswaits again for the listener's.rekeydisconnect, 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.rekeyfor that session, after the secondconnected. Another new test requires one.supersededfor a superseded session with no goodbye when the edge stops.testReconnectResumesExactlyOnceInOrderwaits for the client's resumed.connectedevent 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 withoutmax_tokensis 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_tokenslarger than what the prompt leaves is cut to fit, on every model, and the answer ends withfinish_reason: lengthif it gets there; before, a model that advertises a context refused it, so OpenCode and Hermes, which name amax_tokenson 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 400context_length_exceededand a message naming the window; before, on a model that advertises no context, it ran past the window. - This Mac's
/v1/modelslists each of its models' window as bothcontext_lengthandmax_output_length, sodarkbloom start --opencodeand--hermeswrite 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_tokenspast 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 withfinish_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 = falseunder[local]inprovider.toml
(~/.config/darkbloom/provider.toml), then restart serving (darkbloom restart). - Listing models, health checks,
/metricsand 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 --localnever 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 saydrainingwithbusy_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.tomltakes 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,portandbind. The provider reads and
checks it. Serving usesmode,me_firstandme_first_idle_minutesfor the local API beside Darkbloom; it does
not useroute,portorbindyet.- 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 startasks 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, anddarkbloom start --chooseasks
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,--networkand--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-firstare refused before
anything runs. On a paired Mac they need--solo, like the other single-Mac options. - Changed:
--local-endpointnow means Both, me first: Darkbloom pauses while you use the local API.
--local-endpoint --no-me-firstkeeps 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;--portstill picks one. darkbloom statussays how this Mac serves in one line (for exampleServing: you first — Darkbloom paused since 14:02 …) and where your requests go, with whether an account key is saved.darkbloom localadds the same, and
namesstart --me-firstbesidestart --local. With--no-auth,startandstatussay 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 andListening 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 progresscomment 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/modelslists each model'sinput_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 --opencodeand--hermesgive 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'ssupported_features, the catalog's. darkbloom start --opencodeoffers 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-endpointand 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-endpointand 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 statusno longer reads "Darkbloom network only": it saysServing: Darkbloom and you, me first — the local API isn't up: port 8001 is in use (`darkbloom start --port 8002`), anddarkbloom localsays the same. Only me names the next free port the same way. On a Mac in a two-Mac cluster these lines namedarkbloom start --solo --port <n>, ordarkbloom restartfor the pair's own API. - The app's local mode runs as launchd's
--foregroundservice 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-endpointand 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, withroute = "this-mac", or with--no-auth. darkbloom route keysaves the account API key in this Mac's Keychain after one check with Darkbloom
(--stdinto pipe it in,--removeto 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 keytells 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-macordarkbloom), 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/modelslists this Mac's models, then your Macs' (and the network's with "My Macs first"), each once, with
owned_byand, when known,context_lengthandmax_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_tokensis served with that limit, asmax_tokensis. - 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 typedcapacity / 503 / drainingrefusal, 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.shuses 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 asinvalid_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 stopdoes.darkbloom start --local --hereserves 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 stopandrestartduring it drain it, anddarkbloom statussaysServing: 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 restartanddarkbloom updatealways serve the saved choice: a service an earlier version or start left serving another way restarts as saved, and says so. Before,start --me-firston a Mac set to the Darkbloom network kept serving Both, me first afterrestartwhile the config said network. restartandupdatewait 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 --heresays 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.darkbloomblock in its globalopencode.jsonc(or an existingopencode.json): the
local endpoint at its live port fromlocal.json, the models with their names, context and output limits and
capabilities, andmax_tokensas the output-cap field (OpenCode otherwise sendsmax_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 inopencode.jsonstays 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.yamlby default), asollama launch
andomlx launchmake 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 dropmax_tokensafter 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 thedarkbloomblock 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.shruns 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 statusanddarkbloom cluster statussaidThe 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 --solowas 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 starton 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 startin 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 statusanddarkbloom cluster statuson 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 withdarkbloom clusterin 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 rundarkbloom startin 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'sPair: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 startnow starts the pair whatever its state: in a terminal it opens thedarkbloom clusterscreen, and without one it starts the pair's saved model and waits until it serves. That includes a pair stopped withdarkbloom stopand one whose other Mac isn't answering, asdarkbloom stopanddarkbloom cluster statusalready said. Since 0.10.9, astartwithout a terminal there (a script, or an agent followingcluster status) served the Mac alone instead, and one in a terminal asked first. darkbloom start --solois 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--soloin every state of the pair: without it,darkbloom start --model <id>in a terminal anddarkbloom autopilot enablestart 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 plaindarkbloom startdoes, 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 withThis 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 startfor the pair anddarkbloom start --solofor serving alone:darkbloom statusfor a part that stopped because the other Mac stopped answering, theNext:line ofcluster status,restarton a Mac where nothing serves, and the linestart --soloprints. They no longer send you todarkbloom clusterto start the pair. darkbloom start --solo,restartandupdateon 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
--opencodethat 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--opencodeor--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 statuson 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 ownDaemon:,Serving:andTrust:lines follow. Before, it said only "Single-Mac serving: running beside the pair" at the end, and theServing:line neededstatus --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
defaultmtp_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 anddarkbloom cluster statussay 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_effortandreasoning.efforttakenone,minimal,low,medium,high,xhighandmaxon 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:minimalits lowest,maxits highest,nonethinking off where the model can.- Qwen 3.8 27B (and the owned Flash-Next build) answered
highandmaxwith a 400 "Invalid inference request.", so Hermes, which sends the user'smax, fell back to the user's other, paid provider. They now renderxhigh, the template's highest level, andminimalrenderslow. - MiMo V2.6 thinks for every effort but
none(it refused them all), Nemotron 3.5 Super rendersminimalandlowat its medium depth andxhighandmaxat its default (it refused them), and DiffusionGemma and Flint takemax. - 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 inparam, and the accepted names. A model that doesn't reason ignores any effort. - Nemotron 3.5 Super reads both
reasoning_effortandreasoning.effort, and refuses two that differ, even two names such ashighandmax. Its local API now answers that with the same 400 as an unknown name (codeinvalid_reasoning_effort,paramnaming 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 restartand 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, anddarkbloom stopkeeps 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 plainrestartthere restarts single-Mac serving only while it runs. With none running it changes nothing, exits 1, and says thatdarkbloom startstarts the pair anddarkbloom start --soloserves the Mac alone.restart --solostill starts single-Mac serving that is set up but stopped. - After a restart of single-Mac serving on such a Mac,
restartno longer says "darkbloom restartrestarts both Macs", which a restart there doesn't do. It says thatdarkbloom startstarts the pair. Where the pair is started but its other Mac is gone,restartsays 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-macsanddarkbloom route my-macs-firstsave 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 ofprovider.tomlor a wholedarkbloom start --route. Each says what it means:my-macssends them to your other Macs, free, and never to the network;my-macs-firstsends 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-macsandmy-macs-firstneed your account API key: without one they save nothing, exit 1 and namedarkbloom 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] routeagain whenprovider.tomlchanges (onestatby 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 savedthis-macnever passes a request on while the file is saved. darkbloom route keysays 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-macsormy-macs-firstsaved and no account key, or afterdarkbloom route key --removeremoved 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 codeaccount_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-firstthey 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-macsays that the pair's local API passes nothing on, and the summary and--no-authlines name this pair, not this Mac. The other Mac says only that the leading Mac's route decides what the pair passes on, and namesdarkbloom route key, ordarkbloom 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 namesdarkbloom route my-macsto 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 startasks about it only when this Mac serves the Darkbloom network. Both, me first never asks and keeps your saved answer;darkbloom autopilot enable,--autopilotand--no-autopilotchange it. Only me has no Autopilot: there,darkbloom autopilot enablesaysAutopilot 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 --herenow saysAPI key: `darkbloom local` shows it, and where your requests go, instead of the key andexport 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 launchandomlx launchdo:
darkbloom --opencode,darkbloom --hermes, or both. If this Mac's local API already runs, nothing restarts;
otherwisestartruns 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--networkand
--no-auth(and with--distributed). Beside a running--no-authlocal 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
coversOPENCODE_CONFIG_DIRand 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'sconfig.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.TheUndo: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 said0.0.0.0:8001for 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, thendarkbloom --opencodeagain). 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 --opencodeagain oncedarkbloom statusshows it loaded. That holds too when a route that dials out lists the catalog's limits for it. - A start without
--opencodeor--hermesnever 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.1and::1are this Mac, in any case, and so is its.localname 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 updatefailed after a minute with "download failed: update check failed: The request timed out", although nothing had been downloaded, and--check-onlywith "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.andRun `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 nowinvalid_media(400) too; before, every Qwen4 reader failure was a retryable 503. - Each failed reader pass logs a WARN
engine_healtheventvideo_reader_failedwith 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 restarton 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
startstarts the pair,--soloserves alone, no start asks without a terminal, and status says what this Mac serves by @jonathan308 in #1892 - cli:
darkbloom --opencodeanddarkbloom --hermes(short forstart --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-firstsaves the route (LS-6, R12) by @jonathan308 in #1902 - cluster:
darkbloom cluster leaveleaves 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/--hermeswait 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