Purpose: preserve recovery evidence while testing the smallest coordination mechanism that improves time-to-correct-verified-result.

`program.ts` now uses one persistent table only:

• `micro_tasks`: task definition, priority, prerequisite task IDs, executor requirements, resource locks, lease, submitted result, verifier receipt, and final state.

There is no separate world/fact table. An accepted fact is simply a completed evidence-producing task. Downstream tasks depend on completed task IDs and receive their verified result/receipt as prerequisite evidence.

Normal loop:

task -> batch claim -> execute -> submit -> verify(PASS/FAIL) -> COMPLETE/retry -> downstream task

Within the trusted coordinator call path, the single verify() transition requires a different executor ID with cap:verify. This is logical separation, not authenticated independence: the micro-kernel itself does not prove that caller-supplied executor IDs/capabilities correspond to distinct external model invocations.

A prior falsifier demonstrated that fabricated IDs/tokens can spoof this check if an untrusted caller can invoke mutation functions directly. Therefore the live trust boundary is:

untrusted worker <-> trusted execution adapter <-> internal micro-kernel

The future provider adapter must generate/bind execution identities from actual separate invocations. Do not expose claim/submit/accept/reject as unauthenticated public mutation endpoints. No identity registry is justified before a real execution substrate requires one.

No live agent registry, workstream object, guard language, claim graph, frontier object, mission object, superhero factory, autoscaler, or Meta-OS.

Against preserved Brain generation 2638:

• event chain verification: PASS
• claim graph verification: PASS
• 59,664 eligibility comparisons: 0 mismatches after collapsing dependency/guard concepts
• 528/528 scheduler choices matched
• repeated minimal scheduler benchmark: about 56.5x faster than the legacy predicate-heavy decision path
• dynamic claim simulation: 528/528 executor outcomes matched
• 10 causal claim/complete waves, 39 downstream claims: 0 mismatches
• logical verification gate test: same-ID verification blocked; missing cap:verify blocked; different-ID verifier unlocked downstream work
• verification-authentication falsifier: fabricated executor IDs/tokens can spoof independence if mutation calls are exposed to untrusted callers; external independence remains unproven until bound by a trusted execution adapter
• accept() + reject() collapsed into one verify() transition; PASS -> COMPLETE, FAIL -> READY
• one-task-graph projection against generation 2638: 59,664 eligibility decisions and 528 scheduler choices matched with 0 mismatches while representing historical claim/artifact prerequisites as fact-task nodes
• one-table live qualification: lifecycle, false-verdict rejection, task-ID collision fail-closed, and 128-executor/64-task concurrency PASS
• `micro_world` physically dropped after live regression PASS
• batch assignment: 10,000 executors -> 10,000 unique tasks in ~3.37 s in staging
• historical adaptive replay: one verified sample per branch then concentrate on the best observed branch was 2.583x faster than uniform allocation in that dataset

These are staging results, not universal proofs.

A credentialless Kilo gateway route was rediscovered in existing project assets and requalified live.

Verified current facts:

• Kilo live catalog exposes 19 isFree=true routes with zero prompt/completion pricing.
• kilo-auto/free returned HTTP 200 and routed to a free model with reported cost 0.
• Real producer/verifier qualification PASS:
  • producer: dots-studio/dots-3-note-preview:free
  • verifier: stepfun/step-3.7-flash:free
  • distinct adapter invocation IDs
  • distinct provider response IDs
  • different requested models
  • deterministic arithmetic cross-check PASS
  • producer reported cost 0; both catalog entries zero-priced
  • micro-kernel task reached COMPLETE only after verifier PASS
• Dots-3 concurrency:
  • 32/32 simultaneous calls PASS at explicit cost 0 in one run
  • 64/64 PASS in another run
  • 128-way burst produced 36 HTTP 200 and 92 HTTP 429
  • later 40/40 passed, then a following 48-way burst was mostly 429
  • therefore no fixed concurrency ceiling is promoted; observed limits are rolling/provider-state dependent.
• Free model qualification matrix:
  • 18 exact free routes tested once
  • 11 returned correct structured arithmetic
  • 14 returned HTTP-level success
  • multiple upstreams were independently usable.
• Harder scheduling qualification:
  • 11 previously responsive free models tested
  • 7 produced a deterministically verified optimum 4-wave schedule at least once
  • fastest single valid results in that run were Nex N2.5 Mini and inclusionAI Ling variants at roughly ~1 s.
• Reliability correction:
  • one-shot model success is not enough to call a route a reliable worker.
  • an 8-attempt-per-model diverse load test produced only 3 verified schedules total while many HTTP calls still succeeded.
  • worker selection must optimize verified useful results per second, not HTTP throughput.
• Parallel replication signal:
  • Nex N2.5 Mini with a mechanically supplied lower-bound hint produced 16/16 verified schedules in one 16-way run; first verified result arrived in ~0.86 s.
  • a matched first hint ablation showed raw 0/8 vs hinted 7/8.
  • a second-instance replication was transport-confounded by rate limiting (only 3/8 raw and 4/8 hinted reached usable HTTP success), so the hint effect is not promoted as general.

Current inference conclusion:

Real independent $0 execution is proven. The dominant frontier is now verified-yield routing under changing provider capacity, not Brain architecture.

Minimal operational rule:

Prefer deterministic preprocessing when cheaply available; launch a small diverse set of zero-priced workers; accept only independently/deterministically verified output; treat 429/provider failures as route availability changes, not task/model scientific failures; do not maintain a permanent worker registry or fixed concurrency doctrine.

Two concrete ABA/stale-attempt bugs were reproduced and fixed without adding a subsystem.

Reproduced:

1. executor A leases task T
2. lease expires
3. the same executor ID A leases T again
4. a late result from attempt #1 arrives
5. old API accepted it under attempt #2 because submission was fenced only by task ID + executor ID + current expiry

Fix:

• every assignment now carries a random opaque lease_token
• submit() requires the exact current token
• expired/rejected/submitted leases clear the token
• 64-task batch regression produced 64 unique task IDs and 64 unique lease tokens
• stale token -> NOT_CURRENT_LEASE_ATTEMPT
• current token -> PASS

A malformed caller previously could request an arbitrarily long lease; a live falsifier created a lease expiring in 2036.

The slow-path kernel now accepts only integer leaseSeconds in 30..900. The compact offline regression checks both bounds plus both ABA fences and batch uniqueness.

Reproduced:

1. submission #1 is produced and a verifier starts reviewing its hash
2. another verifier rejects #1
3. task is retried and submission #2 replaces the result
4. stale verifier for #1 returns PASS
5. old API accepted PASS against submission #2 because verification was not bound to the reviewed result

The falsifier ended with a COMPLETE row whose current result hash was submission #2 while the stored verifier receipt explicitly referenced submission #1.

Fix:

• verify() now requires the exact result_sha256 reviewed
• mismatch -> STALE_VERIFICATION_RESULT
• matching current hash -> PASS/FAIL transition allowed

Post-fix real Kilo regression PASS:

• Dots-3 producer HTTP 200, answer 437, reported cost 0
• Step 3.7 verifier HTTP 200, independent provider response ID, correct verdict
• lease token present
• verifier receipt hash == current result hash
• task reached COMPLETE

Concurrency note:

• an in-process Promise.all of multiple libSQL write transactions triggered a Val Town/libSQL client failure and is not evidence of a kernel race.
• a realistic two-separate-Val-execution race for the same task produced exactly one assignment and one empty result, with one durable lease owner.
• therefore no mutex/lock subsystem was added.

Free-model audit note:

Free models are hypothesis generators, not authorities. Multiple bug-hunt outputs in these rounds confidently described code paths that do not exist or had already been handled correctly. Every proposed defect must be deterministically reproduced before it earns a fix.

Official Kilo gateway documentation currently states:

• free models are available to anonymous users
• free-model traffic is rate-limited at 200 requests/hour per IP
• :free routes have zero cost, but upstream providers can impose additional limits
• free-model availability can change over time

Therefore model diversity is used for quality/upstream availability, never to bypass the gateway-wide free limit.

Automation deletion:

• keep: Brain Frontier Worker — the single active hourly condition-watch. It checks canonical restoration/support first, then continues the highest-leverage verified frontier.
• disabled: redundant Brain Restore Watch after folding its exact check into the Frontier Worker
• disabled: redundant Runtime Falsifier
• disabled: redundant Runtime Limit Watch

The single surviving worker now carries recovery checking, the one-table kernel, lease_token fence, result_sha256 verification fence, Kilo free-limit, and verified-yield policy.

Bounded state-machine fuzz:

• 50 seeded mixed claim/submit/verify actions
• 21 claim actions, 14 submit actions, 15 verify actions
• 5 actual assignments, 5 accepted submissions, 3 successful verify transitions
• stale/invalid calls were rejected
• 0 structural invariant violations
• a 500-step single-runtime attempt was non-diagnostic because the Val Town/libSQL client failed before scientific completion; this is treated as a substrate ceiling, not a kernel failure.

The micro-kernel is not the default execution path.

Use direct verified execution when all are true:

• work is bounded and synchronous
• no cross-run handoff is required
• no shared task ownership is required
• no prerequisite graph or resource lock is needed
• losing the current process would make rerun cheaper/simpler than durable coordination

Direct path:

deterministic preprocessing -> zero-cost worker attempt(s) -> deterministic verifier when possible -> optional distinct model verifier -> first verified result wins

Use the one-table micro-kernel only when persistence/ownership/prerequisites/resource locks actually change correctness or expected time-to-verified-goal.

This makes the Brain a conditional durability/coordination primitive, not a universal wrapper around intelligence.

Live files are now intentionally only:

• program.ts — optional one-table durable coordination kernel
• run_e001.ts — compact self-cleaning regression for lease bounds, task-ID fail-closed behavior, worker-attempt ABA, verifier-result ABA, verification separation, SUBMITTED resource exclusivity, and batch uniqueness
• README.md — current evidence/operating boundary

The separate HTTP status endpoint was deleted because direct Val Town inspection already provides the needed state and the endpoint had no causal job.

• Canonical mosadek/project-brain-live-v1-durable remains absent from the live Val Town listing.
• Exact restoration request was sent to Val Town's currently documented contact hi@val.town on 2026-09-09 after verifying the earlier request had only been sent to support@val.town.
• No automated resend loop is allowed. Wait for a meaningful reply/restoration event.
• Pollinations legacy anonymous OpenAI-compatible endpoint was tested live from Val Town with no Authorization header and returned HTTP 402 Payment Required. It is therefore disqualified as a current $0 credentialless execution lane.
• Kilo remains the only empirically proven credentialless $0 inference lane in this project state.
• Do not search indefinitely through stale “free API” lists. Add another provider only after current official/primary evidence plus a live zero-cost probe.

Current official OpenAI product evidence changes the default execution hierarchy:

• Codex is explicitly designed for multiple agents working in parallel with isolated worktrees/cloud environments.
• ChatGPT Plus includes Codex, and current OpenAI guidance says Plus includes Work/Codex allowance; rollout/availability can differ by surface.
• ChatGPT Work is the native long-running multi-step work surface.
• This current chat tool surface does not expose a callable Codex/Work delegation tool, so no Codex run is invented here.

Therefore:

If native Codex/Work is available in the active product surface, prefer it over custom Kilo/Val orchestration for substantial multi-agent work.

Fallback order:

1. deterministic computation
2. native Codex/Work parallel agents when available
3. direct zero-cost Kilo attempts for public/non-sensitive bounded work
4. one-table micro-kernel only when durable ownership/prerequisites/resource locks are actually required

Do not build a parallel-agent manager, worktree manager, agent registry, or background-run framework merely to reproduce native Codex capabilities.

AI Horde note:

• official AI Horde docs still support anonymous text generation with public anonymous key 0000000000
• live text-worker status returned active workers
• this ChatGPT tool surface blocks credential-shaped authorization handoff, and no-auth OpenAI-proxy call returned HTTP 401
• therefore AI Horde is officially available but not callable from this surface without crossing a tool safety boundary; do not route around that boundary.

Affected deleted Val: mosadek/project-brain-live-v1-durable.

Do not silently recreate a new Val and call it the original. If Val Town restores the soft-deleted project, verify its code/history, project SQLite, blobs, env-var metadata/keys, branches, event chain, claim graph, and frontier before using its historical state. Restoration recovers evidence; it does not automatically reactivate the old architecture or authority.

Best independently preserved state currently found:

• source: mosadek/brain-cohort-v3-p0-test-m1
• generation: 2638
• event head: a5de552b7e2e3c9208e2b42410f66dc0fd301881f1e123b7ea97cb7e03177871
• event-chain verification: PASS
• claim-graph verification: PASS

A second project-scoped copy exists in this staging Val as:

• recovery/g2638/part0.bin — 900000 bytes
• recovery/g2638/part1.bin — 900000 bytes
• recovery/g2638/part2.bin — 900000 bytes
• recovery/g2638/part3.bin — 335503 bytes

Concatenated bytes: 3035503
SHA-256: ddaae55c3060f12802220d4bbe9385bcfefdbe675de8c3065e477890cbbc4405

Independent reconstruction/readback of that copy passed. It is evidence, never canonical authority by itself.

authority = NONE.

The deleted canonical project mosadek/project-brain-live-v1-durable remains the recovery target. Restored historical state is evidence/data, not automatic authority for the old architecture.

Do not recreate the old architecture by default. A mechanism survives only if removing it measurably worsens correctness or end-to-end verified progress.

Recover knowledge. Delete machinery. Scale useful execution.

Live readback from mosadek/persistent-single-process-agent-canary falsified the attempted long-lived in-process HTTP-agent route on this Val Town surface.

Observed durable record:

• durable boot_id: bd1ac513-b84c-496b-8433-c0f15ca98c31
• kind: start
• tick: 2
• useful_iterations: 5000
• cognition_count: 1
• no later heartbeat replaced the start record, even though the code persists every 30 ticks (~60 s)

Fresh /status reads at 14:31:59Z and 14:32:00Z:

• current boot_id: c3f5991f-c572-4b50-b88d-90cb69405157
• started: false
• tick: 0
• same_boot_as_durable=false
• same_process_canary_alive=false

Inference:

A started HTTP process did not survive long enough to produce its first scheduled heartbeat. Do not use one long-lived HTTP process as the autonomy substrate here. Prefer native Work/Codex when exposed, otherwise external scheduled/event re-entry with durable state; direct synchronous execution remains the default for bounded work.

A current Project Brain liveness probe reproduced stale-model failure in mosadek/gdi-kilo-bridge: the hard-coded minimax/minimax-m3:free route returned HTTP 404 model_not_found even though the bridge had been edited recently. The bridge was repaired with exactly one model-line change to Kilo's server-maintained kilo-auto/free alias. Immediate live verification returned HTTP 200, exact KILO_OK, resolved to poolside/laguna-s-2.1:free, and reported usage.cost = 0.

Operational consequence:

Do not pin an anonymous free worker merely because it was live earlier the same day. For generic liveness/first-attempt work, prefer kilo-auto/free or a fresh live catalog selection. Pin an exact free model only when task-specific evidence justifies it, and revalidate existence/zero pricing immediately before use. A stale model ID is a route-availability failure, not a model/task failure.

Current ChatGPT/Val Town recheck preserved these additional non-authority facts:

• mosadek/project-brain-live-v1-durable is still absent from the live Val listing.
• The existing read-only recovery import probe fails with ERR_MODULE_NOT_FOUND for project-brain-live-v1-durable@2407-main/val_native_kernel_v1.ts; published-module import is not a current recovery path while the Val remains soft-deleted.
• Direct project-scoped SQLite access against the deleted Val fails with This val could not be found; the MCP database surface cannot currently reach the retained soft-deleted database.
• A bounded inspection of the recent isolated Brain Val databases did not establish a newer complete independent canonical snapshot than the already reconstructed generation-2638 copy. This is not proof that no later fragment/evidence exists.
• Therefore in-place Val Town restoration remains the exact recovery boundary. Do not create a replacement Val and call it canonical, and do not repeat these dead recovery probes unless the platform state changes.

A new ChatGPT run attempted the mandated canonical boot through mosadek/project-brain-live-v1-durable and fail-closed because the Val is still absent.

Fresh checks:

• exact canonical Val listing: still absent;
• Gmail search for a new Val Town restoration reply: none found;
• current Val Town tool surface exposes no restore/undelete operation; its soft-delete contract explicitly says restoration is by Val Town request and there is no self-serve undo;
• native ChatGPT Work/Codex delegation is not callable from this chat tool surface; plugin discovery exposed OpenAI Developers but not a Work/Codex execution handoff;
• Camber is connected and has existing agents, and current public pricing includes a $0 plan, but this tool surface exposes no remaining-message/credit balance or hard no-overage proof for the current account, so Camber was not consumed or promoted as an autonomous $0 execution lane.

Decision:

Do not counterfeit canonical Brain authority, do not recreate the deleted Val, do not build replacement orchestration, and do not spend scarce free-agent quota merely to demonstrate activity. The current fastest safe execution order remains deterministic direct work first, then native Work/Codex only when actually callable, then already-qualified zero-priced Kilo for bounded public/non-sensitive tasks, with the one-table kernel only when durable coordination is causally required.

This is non-authority recovery evidence only.

A bounded 8-call scheduling probe was run from Val Town against four credentialless Kilo routes. The task had an exact deterministic verifier and a known feasible/optimal makespan of 4. A result counted as a qualified zero-cost worker result only if HTTP succeeded, the returned schedule passed the deterministic verifier, and the gateway response explicitly reported usage.cost = 0.

Observed:

• dots-studio/dots-3-note-preview:free: 2/2 verified, explicit cost 0, actual model unchanged, provider AtlasCloud; verified latencies 15.426 s and 20.945 s.
• kilo-auto/free: 1/2 verified, explicit cost 0 on the successful result; successful latency 39.294 s and actual route nvidia/nemotron-3-ultra-550b-a55b:free. The other call returned HTTP 200 but no usable completion/cost attestation.
• stepfun/step-3.7-flash:free: 2/2 schedules were deterministically valid, but the gateway responses omitted usage.cost and provider metadata, so they fail closed for autonomous $0 qualification in this snapshot.
• minimax/minimax-m3:free: 0/2, HTTP 404. An immediately preceding preflight that requested this name had been transparently served by a Nemotron free model, confirming that requested route labels cannot be treated as execution identity.

Current bounded inference:

For public bounded work on this execution surface, Dots-3 is the strongest currently observed route among those tested because it combined 2/2 deterministic correctness with explicit zero reported cost. Treat this only as a current capacity snapshot, not a permanent registry or universal ranking.

Operational change:

Start with the smallest currently qualified route set; audit the actual returned model/provider/cost; verify output deterministically; expand/fallback only when the first route fails or latency economics justify it. Do not keep stale model names merely because they worked earlier.

A live isolated-branch audit reproduced a resource-lock hole in the one-table kernel.

Pre-fix sequence:

1. T1 and T2 were READY with the same exclusive resource R.
2. executor A claimed T1.
3. A submitted a result; T1 moved to SUBMITTED and was still unverified.
4. executor B immediately claimed conflicting T2.

Observed audit field:

• reproduced_conflicting_claim_while_first_submitted = true

Root cause:

• claimBatch() built its locked-resource set from state='LEASED' rows only.
• submit() clears the lease and moves the task to SUBMITTED, so exclusivity vanished before verification.

Minimal repair:

• one query predicate changed from state='LEASED' to state IN ('LEASED','SUBMITTED').
• no new table, lock manager, registry, or subsystem.

Post-fix deterministic audits:

• conflicting second claim while T1 was SUBMITTED: blocked.
• verifier PASS moved T1 to COMPLETE.
• T2 became immediately claimable after verified completion.
• audit rows were cleaned from micro_tasks after each run.

Classification:

RESOURCE_LOCK_RELEASED_BEFORE_VERIFICATION = REPRODUCED_AND_FIXED

Operational invariant:

An exclusive resource remains locked from claim through SUBMITTED and is released only when verification resolves the task to COMPLETE or back to READY.

A 16-call matched, no-retry, deterministic-verifier run compared raw scheduling prompts against the same prompts plus a mechanically derived lower-bound/optimality hint across two compact scheduling problems and four requested Kilo free routes.

Verified outcomes:

• P1 raw: 3/4; hinted: 3/4. First verified result: 19.250 s raw vs 17.555 s hinted.
• P2 raw: 3/4; hinted: 3/4. First verified result: 26.041 s raw vs 27.000 s hinted.
• Dots-3: 2/2 raw and 2/2 hinted, HTTP 200, reported cost 0.
• Nemotron-3 Super: 2/2 raw and 2/2 hinted, HTTP 200, reported cost 0.
• Step 3.7 Flash: 2/2 raw and 2/2 hinted but cost attestation was absent in these responses, so it remains fail-closed for autonomous $0 qualification.
• Minimax M3: 0/4, HTTP 404, confirming the route is stale.

Classification:

The earlier lower-bound-hint advantage does NOT generalize on these two matched tasks. Verified yield was identical and first-result latency moved in opposite directions. Do not inject deterministic hints by default. Use deterministic preprocessing when it directly solves, verifies, prunes, or cheaply reduces a demonstrated search burden; otherwise omit it.

This is non-authority staging evidence, not a universal claim about prompting or models.

A fresh Kilo catalog read still exposed 19 explicit isFree=true routes, but the previously hard-coded minimax/minimax-m3:free route now returns model_not_found. This is direct evidence against permanent worker registries.

A bounded scheduling probe used a deterministic exact preprocessor to prove the optimum wave count before inference, then required a strict JSON schedule and deterministic verification.

First hinted/reasoning-suppressed round:

• Nex N2.5 Mini: 1/4 verified across exploration + repeats; fastest valid 922 ms, then 3 consecutive invalid outputs.
• Ling 3.0 Flash Fin: 4/4 verified in the first burst.
• Ling 3.0 Flash Sante: 1/1 verified in the first burst.
• Dots3 Note Preview: 1/1 verified in the first burst.
• Kilo Auto Free: 1/1 verified but ~27.3 s.
• Step 3.7 Flash and Nemotron 3.5 Lightning exhausted the response budget without a usable final artifact.
• North Mini Code returned a structurally invalid schedule.

Immediate three-round replication minutes later:

• Ling Fin: 0/3 strict verified despite HTTP 200 and reported cost 0.
• Dots3: 2/3 strict verified.
• Ling Sante: 0/3 under the strict wire schema, but all 3 outputs were semantically valid schedules encoded as arrays of sole-field {"task":"X"} objects. A deterministic canonicalizer can safely map that exact shape to task strings before verification.

Inference:

Fixed model ranking is unstable even over minutes. One fast first success is not a reliable routing signal. Preserve a small diverse launch set, use only short-lived recent verified-yield as a bias, and expire that bias aggressively.

Minimal direct execution pipeline is therefore refined to: deterministic preprocessing -> small diverse zero-priced burst -> safe deterministic canonicalization of mechanically equivalent wire shapes -> deterministic verification -> first verified result wins.

Do not canonicalize semantic mistakes, missing tasks, duplicate tasks, dependency violations, or unsupported structures. Canonicalization is syntax-only and must fail closed.

No new persistent worker registry, autoscaler, or routing service is justified by this evidence.

A live semantic falsifier proved that executor separation alone is not verification. A solver submitted a knowingly false result (2+2=5); a different verifier identity with cap:verify then supplied caller-controlled {passed:true} without checking the claim, and the previous generic transition accepted it as COMPLETE.

Classification:

CALLER_ATTESTED_PASS_IS_NOT_INDEPENDENT_VERIFICATION = REPRODUCED

Current program.ts therefore fails closed on generic positive verdicts with POSITIVE_VERIFICATION_NOT_ENFORCEABLE. Negative verdicts may still return a task to READY. This is intentionally a boundary, not a new proof bureaucracy.

Operational consequence:

The one-table kernel is a coordination/rejection primitive unless the trusted execution adapter supplies a task-specific verifier whose truth condition is independently enforceable, preferably deterministic. Distinct model/executor identities can provide evidence, but a caller-supplied boolean must never manufacture canonical truth.

Older staging evidence where a generic verifier PASS moved a task to COMPLETE is historical behavior and is superseded by this live boundary.

A fresh 6-call, two-repeat-per-route probe moved away from the repeated scheduling benchmark. The task was an exact five-element subset-sum/lexicographic-minimum problem with a deterministic exhaustive verifier. Full raw evidence is preserved in project-scoped blob evidence:verified-yield:crossdomain-v1.

Verified explicit-zero-cost outcomes:

• dots-studio/dots-3-note-preview:free: 2/2, AtlasCloud, first verified result 22.567 s.
• nvidia/nemotron-3-super-120b-a12b:free: 2/2, Nvidia, first verified result 40.611 s.
• kilo-auto/free: 1/2, routed to Poolside Laguna S 2.1; one correct result at 46.407 s, plus one very fast 1.466 s wrong answer that failed the deterministic verifier.

Decision-changing inference:

Response latency is not progress latency. The current first wave should favor a tiny set of recently cross-domain-verified exact zero-cost routes, presently Dots-3 plus Nemotron Super when suitable, and verify before accepting anything. kilo-auto/free remains a useful availability fallback, not a truth shortcut. Do not promote this snapshot into a permanent registry; expire routing bias aggressively as provider state changes.

No new routing service, autoscaler, or worker registry is justified.

A deterministic scan of mosadek/brain-cohort-v3-p0-test-m1 enumerated every surviving table with a column named exactly generation and measured its maximum value. 59 generation-bearing tables were checked in bounded groups.

Highest full heads observed:

• brainvn_epoch_meta: 2638
• tmp_p0shadow_sol_epoch_meta: 2304
• several IBAT snapshots: 2228–2229
• brainv3s1320_epoch_meta / brainv3s1408_epoch_meta: 2176
• all older recovery/snapshot families: lower.

A focused brainvn consistency read found:

• epoch generation: 2638
• max epoch-event generation: 2637
• max workstream head: 2635
• max agent generation: 2638
• max committed mutation receipt generation: 2638
• 895 epoch-event rows
• 513 task rows
• 528 agent rows

Classification:

Within the richest surviving independent Brain database currently accessible through Val Town, generation 2638 remains the highest recoverable complete head. No surviving exact-generation table demonstrates a later complete Brain snapshot.

This does not prove that no later fragment exists elsewhere, but it closes repeated broad recovery scanning until a new source appears or Val Town restores the deleted canonical project.

Fresh readback from mosadek/brain-yield-spike-260909 established a routing error in the weighted-interval spike.

Evidence:

• blob: brain-yield-spike-260909/result-v2.json
• stored size: 7307 bytes
• 4 synthetic weighted-interval instances
• 5 requested zero-priced Kilo routes per instance
• total inference attempts: 20
• deterministically verified optimal model outputs: 0/20
• many calls still returned HTTP 200 and several reported cost 0
• the same spike code already computes the exact optimum locally with dynamic programming before inference

Classification:

MODEL_ROUTING_TO_ALREADY_SOLVED_DETERMINISTIC_TASK = REPRODUCED_WASTE

Operational correction:

If a cheap deterministic procedure already produces the exact required answer, inference eligibility is false. Do not use model diversity, routing, retries, or larger swarms on that task. Use models only for residual work that deterministic machinery cannot already complete, while retaining deterministic verification when available.

This supersedes any interpretation of that spike as evidence that more model calls were needed. It is non-authority recovery evidence.

Current official Kilo Gateway documentation was rechecked live:

• anonymous/free-model traffic is limited to 200 requests/hour/IP
• the same 200/hour/IP free-model limit applies to authenticated free-model requests
• :free / Auto Free usage is zero-priced on Kilo's side, subject to upstream availability

Capacity consequence:

• with deterministic verification, one such gateway quota can sustain at most 200 model-generation attempts/hour before upstream/model failures
• if every accepted result requires a separate model-verifier call, the gateway-level upper bound is 100 producer+verifier pairs/hour
• multiplying IP identities to evade the quota is not an admissible scaling strategy

Classification:

KILO_FREE = QUALIFIED_ZERO_COST_EXPERIMENTAL_FALLBACK, NOT MILLION_SUPERHERO_SUBSTRATE

Current official OpenAI product evidence:

• Codex is included across ChatGPT plans and is designed for parallel cloud-agent workflows
• Work and Codex share a plan allowance; Plus usage is bounded by five-hour and weekly limits, with actual task consumption varying by model/task/settings
• Plus currently has included Work/Codex usage but not remotely close to evidence for one-million concurrent frontier-grade agents

Scaling implication:

A million logical superheroes can only be real at $0 if most do not each consume an independent frontier-model inference stream, or if additional independently granted/authorized compute arrives. Current proven $0 inference lanes are sufficient for bounded experimentation and useful work, not one-million simultaneous frontier agents.

Therefore preserve the architecture distinction:

SUPERHERO_COUNT != FRONTIER_MODEL_STREAM_COUNT

Use deterministic programs/tools for everything they can solve; spend scarce model invocations only on residual cognition that actually requires them.

A bounded non-authority experiment advanced the actual-superhero frontier rather than coordination machinery.

Current official Deno/JSR documentation was used to freeze a tiny trusted skill catalog:

• YAML: jsr:@std/yaml@1.2.0, export parse
• TOML: jsr:@std/toml@1.0.11, export parse
• XML was included as a distractor skill.

The independent verifier Val generates fresh random challenge values, stores the expected value privately in its own project-scoped blob, and exposes only the runtime document plus expected-value hash. The controller cannot recover the private answer from its own storage.

V2 first live canary:

• fresh TOML challenge
• three anonymous zero-priced Kilo routes selected the TOML parser correctly
• fastest valid selector: Nemotron 3 Super, 1410 ms, explicit reported cost 0
• dynamic JSR import + execution extracted the private target correctly
• verifier PASS
• this run is candidate/non-authority and increments no canonical superhero count

A verifier weakness was then found before promotion: it checked that a claimed skill was trusted, but did not bind the skill identity to the challenge format. The verifier was repaired to persist challenge input format and require exact format/package/skill binding.

V3 cross-format replication after that repair:

• YAML: PASS; selected yaml_parse; Nemotron 3 Super fastest valid selector at 2311 ms, cost 0; Dots-3 also valid at 2512 ms
• TOML: PASS; selected toml_parse; Dots-3 valid at 1346 ms, cost 0; Nemotron response produced no usable JSON on this run
• both fresh private-answer verifier receipts passed all checks, including skill_matches_format
• exact candidate artifacts are in:
  • mosadek/brain-superhero-jit-skill-v1/controller_v2.ts
  • mosadek/brain-superhero-jit-skill-v1/controller_v3.ts
  • mosadek/brain-superhero-jit-skill-verifier-v1/challenge_v2.ts
  • controller blob jit-skill-v3/LATEST.json
  • verifier blobs jit-skill-v2/receipts/<run_id>.json

Narrow verified inference:

A real zero-cost external worker can select a trusted capability after the goal is known; the controller can dynamically materialize and execute that capability; and a separate verifier holding the answer privately can validate the result. This is a real JIT-skill superhero primitive, not a full superhero and not canonical authority.

Current limiting question:

Generalize from trivial format-parser skill selection to decision-relevant JIT knowledge/skill acquisition on tasks where the capability cannot be replaced by a simple deterministic controller. Preserve the rule that deterministic direct solutions dominate model calls whenever they solve the task completely.

The first graph-semantic V4 canary initially looked positive against a generic token-overlap router: both Dots-3 and Nemotron Super selected and executed all three graph capabilities correctly while the token router scored 2/3. A concurrently produced stronger deterministic phrase-rule baseline then scored 3/3 with zero model calls.

Classification:

V4_GRAPH_SEMANTIC_TASK = SATURATED_BY_SIMPLE_TASK_SPECIFIC_RULES.

No model advantage is promoted from V4.

The successor V5 removed the known routing phrases from the baseline and used six one-shot held-out indirect goals over the same three capability classes. The verifier privately bound each challenge to the required skill, allowed exactly one baseline and one model submission per challenge, independently checked the executed artifact, and required explicit model cost 0.

Durable controller artifact:

• mosadek/brain-superhero-jit-skill-v1 blob jit-skill-v5/LATEST.json
• batch: jit4batch-585577b3-8cd1-44f2-888d-417e668f83ee

Observed:

• generic lexical deterministic router: 2/6 verified
• dots-studio/dots-3-note-preview:free: 6/6 verified
• model calls: 6
• every model call reported cost 0
• selected capabilities were dynamically executed only after the goal was observed
• independent verifier receipts passed all six model runs

The successful held-out mappings included indirect language such as battery loss -> minimum-weight route, network construction expense/redundancy -> minimum spanning connector, and job unlocking/arrow precedence -> dependency ordering.

Narrow inference:

External model semantics can replace some fixed task-specific routing rules when choosing a trusted JIT capability from descriptions after the goal is known. This is a real candidate advantage over the frozen generic lexical baseline, but it is not proof that no better deterministic semantic router could close the gap, not a full superhero, and not authority.

Next highest-leverage falsification:

Freeze a generic controller first, then introduce a genuinely new trusted skill catalog/domain after that freeze. Require it to select and execute previously unseen skills from runtime descriptions under independent one-shot verification. If a fixed deterministic controller still suffices, delete model routing for that class.

The fresh semantic graph-skill candidate was checked against the simplicity law before any model selector was run.

Candidate surface:

• three randomized graph goals: shortest route, minimum spanning backbone, prerequisite ordering;
• three executable local skills: route_cost_path, network_connector, dependency_order;
• private verifier checks exact skill identity plus deterministic output correctness.

A frozen zero-model lexical baseline in mosadek/brain-superhero-jit-skill-v1/semantic_baseline_v3.ts fetched a fresh shuffled batch, selected the skill from ordinary goal wording, dynamically loaded the corresponding executable skill, and submitted to the private verifier.

Observed fresh result:

• topological-order challenge: PASS
• minimum-spanning-tree challenge: PASS
• shortest-path challenge: PASS
• total: 3/3 PASS
• model calls: 0

Classification:

JIT_SEMANTIC_V3_MODEL_SELECTION = DOMINATED_BY_SIMPLE_DETERMINISTIC_CONTROLLER

Operational consequence:

Do not spend scarce model inference on this V3 task family as currently written. It does not answer the current limiting question because a cheap deterministic selector already completes the skill-routing decision. Keep the executable skills/verifier as reusable machinery, but move the scientific frontier to JIT knowledge/skill acquisition where deterministic preprocessing cannot already resolve the decision.

This is non-authority staging evidence and increments no canonical superhero count.