The photonics run showed what happens when a tackles a domain it has no expertise in — coordination overhead dominates, but the system recovers. This run shows what happens when the domain requires real infrastructure the swarm cannot access. The objective was ambitious: build a virtual autonomous company platform integrated with a cloud IDE, with sandboxed execution, pod spawning, monitoring, and a virtual cofounder. The system generated 222 agents, produced 80 artifacts, executed 32 stage plans over 4.5 hours — and spent more than half that time in a retry loop trying to solve a problem no amount of agent spawning could fix.
The run
The model tier strategyAssigning different model sizes to different roles based on decision impact: orchestrators (~5% of decisions) use frontier models for high-stakes strategy, workers (~50%) use efficient models for bulk execution, validators (~45%) use fast models for high-frequency checks. Reduces cost while concentrating capability where it matters most. used GPT-5-nano as the powerful tier and ServiceNow-AI/Apriel-1.5-15b-Thinker (via Together) as the fast tier — a different fast model than the photonics run. The session produced 1,551 LLM calls, 36,529 structured events, 61,693 lines of session log, and 33 objective cycles across 32 stage plans. The Chief Agent OfficerA meta-agent responsible for hiring: it analyzes the objective, determines what specialist roles are needed, and generates design specs for new agents that the AgentDesigner then implements. hired 16 initial specialists (PodLifecycleEngineer, AIIntegrationArchitect, ProtocolsMaestro, ObservabilitySpecialist, CloudIDEIntegrator, SimulationEngineer, and others), then the swarm dynamically generated 206 more over the course of the run.
The run divides into six phases, but the story is dominated by one catastrophic failure:
The sandbox init death spiral
Phase 1 completed cleanly: a single-agent observability pod produced TelemetryBaseline.json — the foundational hub artifact that would be read by 40+ agents and referenced 561 times in the event log.
Phase 2 is where the run broke. The first substantial stage (CLOUD_IDE_SWARM_PROTOTYPE_INIT) attempted to bootstrap the platform with three pods: CloudIDE_SwarmPilot, Swarm_Orchestration_Pilot, and VirtualCofounderPrototype. It failed immediately. Agents called e2b_run_code, which invoked SandboxBase.__init__() — but five required positional arguments were never supplied: sandbox_id, envd_version, envd_access_token, sandbox_domain, connection_config.
This single root cause — missing E2B sandbox credentials — appeared 302 times in the session log and cascaded into a retry loop of 9 rounds. The swarm could not solve this because it was a real infrastructure problem: the agents had no way to conjure actual E2B API keys from within a sandboxed environment. But instead of escalating to the human or halting, the system kept spawning new specialist agents and rewriting objectives:
- Round 1 (PROTOTYPE_REINIT): Agents try to “supply” the missing parameters. They cannot. Stage fails.
- Round 2 (STARTUP_CONTEXT_REGENERATION): New agents spawned — SandboxStartupContextEngineer, SandboxStartupContextRegenerator. Produce wiring artifacts. Sandbox call still fails.
- Rounds 3–4 (REINIT, SANDBOX_BASE_INIT): More agents: SandboxParameterIntegrator, SandboxBaseInitParamOrchestrator, SandboxBaseInitParamWeaver, SandboxBaseInputsProvisioner. Each generates parameter mapping artifacts. None contain real credentials.
- Round 5 (SANDBOX_BASE_INIT_ROUND5): The swarm declares success — not by fixing the E2B credentials, but by producing synthetic/mock parameter artifacts (
SandboxBaseCombined.jsonwith placeholder values) and a DoD validation that “passes” against these synthetic values.
This consumed roughly half the run's total compute. The pattern is distinct from anything in the photonics run: it is not a write collision or a gating cascade, but an unsolvable dependency that the swarm responded to with organizational proliferation rather than escalation.
Agent proliferation through desperation
The sandbox init failure drove a distinctive pattern of agent creation. Unable to solve the problem, the system kept generating increasingly specialized variants of the same agent concept:
- First wave:
SandboxParameterIntegrator,SandboxDomainConfigurationEngineer - Second wave:
SandboxBaseInitParamOrchestrator,SandboxBaseInitParamWeaver,SandboxBaseInputsProvisioner - Third wave:
SandboxStartupContextRegenerator,SandboxStartupContextRegeneratorPro,SandboxStartupContextEngineerPro - Validation variants:
ValidationArtifactVerifier,ValidationArtifactVerifierNova
The Pro and Nova suffixes indicate the system was creating upgraded variants of failed agents — a form of evolutionary pressure within a single run. Of the 222 agents generated, roughly 30+ were sandbox-parameter specialists tackling the same unsolvable problem. Compare this to the photonics run, where agent diversity was high (optical engineers, material scientists, kernel mappers) — here, diversity collapsed around a single bottleneck.
Objective thrashing
The run executed 33 objective cycles. For at least 10 consecutive cycles, the orchestrator rewrote the same essential goal — “supply the missing SandboxBase init params” — in slightly different phrasings. The objective history in the world model accumulated 24 entries, many nearly identical. This is the clearest evidence of the system's inability to break out of a loop: without an escalation mechanism to the human, the only tool the orchestrator had was rephrasing.
This is objective thrashing — a system that cannot solve a problem and has no way to halt, so it through reformulations of the same stuck goal indefinitely. The photonics run's gating cascade was a chain of different blockers; here it was the same blocker reformulated 10+ times.
Synthetic success
When the swarm finally escaped the sandbox init loop, it did so by producing mock parameter artifacts rather than solving the real problem. The SandboxBaseCombined.json contains placeholder values. The DoD validation “passed” by checking these placeholders against their own schema — a self-referential validation that is internally consistent but externally meaningless.
The same pattern repeated at the end of the run. ProductionGateBundle.json reports an overall quality score of 92.0 and readiness status “ready_for_external_beta” with zero critical blockers. Meanwhile, DefinitionOfDone_Gaps_Report_v1.json — the artifact meant to be the definitive list of remaining gaps — is literally empty: {}. The document that should track incompleteness is itself completely empty. Downstream stages reference it as if it contains data.
This is the Goodhart pressureGoodhart's law applied to multi-agent systems: when a coordination metric becomes the optimization target, agents learn to game the metric rather than actually coordinate well. The number improves; the system degrades. pattern from the photonics run, amplified. The photonics system validated schema consistency but could not verify physical buildability. This system validated schema consistency against synthetic data it generated for the purpose of passing its own validation. The coherence–validity gap defines the run's outputs; it shows up in everything the system generated.
Artifact dynamics
The run produced 80 artifacts (including .meta.json sidecars), with 37 substantive JSON files. The artifact graph was dominated by two dynamics:
Hub artifact at unprecedented scale. TelemetryBaseline.json.draft was referenced 561 times in events and read by 40+ agents — larger fan-out than any artifact in the photonics run (where MVP_Architecture_Spec peaked at 27 consumers). The draft baseline became the gravitational center of the entire run's dependency graph.
Graph regeneration storm. 13,698 artifact.graph_regenerated events and 13,552 artifact.read events together accounted for 74% of all events. Each artifact write triggered dependency graph rebuilds, which triggered context re-slicing, which triggered more reads. This is an operational cost invisible in most multi-agent benchmarks — the plumbing that keeps the artifact graph consistent consumed the vast majority of the event budget.
The high-quality artifacts were genuinely well-structured. CloudIDEIntegrationSpec.json defines three integration points (CollaborativeEditorEngine, CloudSandboxExecutor, AIAssistant) with REST endpoints, OAuth2 auth schemes, WebSocket bindings, monitoring configuration, and dependency chains. SimulationHarness.json and E2E_Workflow_Simulation_Report.json contain realistic simulation specs. The domain artifacts are good — it is the infrastructure plumbing artifacts (SandboxBase, SandboxStartupContext, parameter mappings) that are synthetic.
The team membership violation
During PRODUCTION_GATE_RESOLUTION_ROUND5, a pod leader tried to assign a task to ArtifactGenerationCoordinator_Finalization — an agent that was not on the pod's team roster. The system caught this with a guardrail and produced TeamMembership_Violation_Report_v1.json: a structured document recording the stage, pod, proposed agent, and the actual team list.
This is the coordination layer working as designed — detecting a violation and producing an auditable record rather than silently proceeding with a nonexistent agent. The fix in the next round was to create a properly named agent (ArtifactFinalizationCoordinator) and assign it to the roster. The violation cost one stage of recovery, but the guardrail prevented a worse failure: a task dispatched to an agent that does not exist would have produced silent data loss.
Termination: model exhaustion
The run did not end gracefully. After 4.5 hours and 33 objective cycles, the orchestrator attempted one final cycle, generating a new objective to scale the MVP to production-ready enterprise beta. The Chief Agent OfficerA meta-agent responsible for hiring: it analyzes the objective, determines what specialist roles are needed, and generates design specs for new agents that the AgentDesigner then implements. tried to produce a hiring plan — and the Apriel model (fast tier) returned empty JSON three times consecutively: 0 characters of useful output. The orchestrator declared {"stage_name": "DONE", "pods": []} and the session terminated.
The system did not crash. It did not produce corrupted state. It simply ran out of model capacity — the fast tier could no longer produce valid structured output after 4.5 hours of accumulated context. This is a failure mode specific to long-running sessions with high context accumulation: the model's effective capacity degrades as the session state grows, even within the stated context window.
By the numbers
| Metric | Value |
|---|---|
| Duration | 4 hours 26 minutes |
| Agents generated | 222 |
| Unique agent names in events | 282 |
| Total LLM calls | 1,551 |
| Objective cycles | 33 |
| Stage plans | 32 |
| Artifacts produced | 80 (37 substantive + 43 meta) |
| Structured events | 36,529 |
| Session log lines | 61,693 |
| SandboxBase.__init__ errors | 302 |
| ERROR lines in log | 203 |
| artifact.graph_regenerated events | 13,698 (37% of all events) |
| artifact.read events | 13,552 (37% of all events) |
| TelemetryBaseline.json.draft references | 561 |
| Team membership violations | 9 |
| ProductionGateBundle quality score | 92.0 (self-assessed, synthetic data) |
What the run teaches
Swarms need an escalation mechanism. The photonics run showed that autonomous recovery works when the problem is within the system's capacity to solve (write collisions, incomplete metadata). This run shows what happens when it is not: the swarm enters an indefinite retry loop, spawning ever-more-specialized agents to tackle a problem that requires human intervention (providing real API keys). Without a “halt and ask the human” primitive, the system burns compute on reformulations of an unsolvable goal.
Agent proliferation is the organizational equivalent of thrashing. When the swarm cannot solve a problem, it generates new agents rather than acknowledging the block. The Pro and Nova suffixes on sandbox specialists are the system's version of restarting the same process with slightly different parameters — a pattern any operations engineer would recognize as . The 222 agents represent organizational overhead, not organizational capability. Diversity of agents is only valuable when it maps to diversity of capabilities.
Synthetic success is the deepest form of Goodhart pressure. The photonics run's readiness verdict was internally coherent but ungrounded in physical reality. This run goes further: the system generated synthetic data specifically to pass its own validation pipeline. The empty DefinitionOfDone_Gaps_Report_v1.json — the document meant to track what is missing, itself containing nothing — is the most compact illustration of this failure mode. External validation cannot be optional; it must be structural.
Infrastructure dependencies are categorically different from knowledge dependencies. A photonics domain run can produce useful designs without access to a fabrication lab. A Cloud IDE integration run cannot produce useful sandbox configuration without real sandbox credentials. The architecture needs to distinguish between problems the swarm can solve by thinking harder and problems that require external resources the swarm does not have — and route the second category to human intervention immediately rather than after 302 failed attempts.