Docs

HackSim has an Anthropic SDK call site per role decision. With an API key set, every site attempts a Claude call. Without one, the deterministic stub runs and produces real, distinct output. A no-key run makes zero LLM calls.

Per-call failures (Anthropic rate limit, timeout, transient errors) surface on the SSE run log as decision.anthropic_failed and that one decision falls back to the stub. The orchestrator does not retry silently. With a Tier 1 Anthropic key (10K output tokens per minute) and the default population, expect a few fallbacks per sim. The Light mode preset in Settings (3 builders, 1 judge, 1 designer) stays well under the limit and runs every decision against Claude.

With ANTHROPIC_API_KEY exported in the shell that runs make demo, the SDK calls claude-haiku-4-5-20251001 at four sites across three decision-making roles:

• Bounty designers compose each bounty (packages/agents/bounty_designer/decisions.py).
• Builders pick the bounty that fits their skills (packages/agents/builder/decisions.py).
• Builders write the project HTML (packages/agents/builder/build.py).
• Judges score every submission with feedback (packages/agents/judge/decisions.py).

Without a key, the stub at each call site produces a working interactive canvas, plausible bounty text, and sensible scores keyed off the agent’s peer id and the prompt hash. That fallback is what lets the demo run for someone who has not set a key. We do not use Claude Code in the running demo.

AXL is the wire between agents. The orchestrator spawns one AXL Go binary per role node (15 nodes by default: one organiser, three sponsors, eight builders, three judges). Each node has its own ed25519 keypair and its own ports. They peer through a single TLS bootstrap on 127.0.0.1:9100.

Four AXL HTTP surfaces exercised by the running sim:

• GET /topology for peer discovery (the algorithm is ported from Gensyn’s autoresearch demo).
• POST /send for broadcast (bounty.posted, team.formed, project.submitted, rubric.published, verdict.published, phase.tick, hackathon.closed).
• GET /recv to drain inbound envelopes from each role’s queue.
• POST /mcp/{peer}/{service} for typed JSON-RPC. The organiser confirms each judge’s verdict during the JUDGING phase by calling tools/call score_project on the judge’s aiohttp router, which the destination AXL node forwards to from the Yggdrasil tunnel.

AXL also ships /a2a/{peer} for agent-to-agent streaming. We do not exercise that surface in this submission; HackSim’s lifecycle is request/reply-shaped and adding A2A would have been depth-of-integration cosmetic. See docs/V2_MCP.md for the wire shape and the integration test that proves the round trip across two real AXL Go binaries.

Every cross-agent envelope travels through the Yggdrasil mesh AXL builds on top of. Builders also POST artefact metadata to the orchestrator over a separate HTTP channel; that path is filesystem registration for the showcase iframe, not agent control. Phase ticks, bounties, projects, rubrics, and verdicts ride AXL. Removing AXL silences the simulation.

Same transport (AXL), different shape. The autoresearch demo is a flat topology where identical agents broadcast findings on one envelope type and adopt each other’s improvements. HackSim has four typed roles (organiser, bounty designer, builder, judge) in a phased lifecycle (bounty design, team formation, build, judging, showcase) and seven envelope types. We borrow the broadcast loop and the topology dedup pattern verbatim from research_network.py; the role differentiation, phase choreography, artefact pipeline, and showcase modal are HackSim.

No. The "What AI are the agents using?" entry above covers which call sites the key affects. This entry covers the two ways to set the key when running locally.

• Export ANTHROPIC_API_KEY in the shell that runs make demo. The Spawner inherits the env var and forwards it to every spawned worker process.
• Paste the key into the password field in the home page Settings popover. The in-UI input only renders when the page is served from localhost, the field is SecretStr on the server so it never reaches a log line, and the orchestrator refuses the field with HTTP 403 from any non-loopback origin.

Pace presets in the SimConfig set the phase schedule. Defaults are tuned for a watchable demo:

• smoke: 75 seconds end to end (used by the headless test harness).
• quick (default for make demo): 110 seconds.
• medium: 5-6 minutes.
• deep: 12 minutes.

The Settings popover under the hero prompt picks the pace (Smoke / Quick / Medium / Deep) and caps agent counts (builders 1-10, judges 1-5, designers 1-5) so the loopback mesh stays watchable. Pace and counts ride thePOST /api/sim body; the orchestrator forwards them into every spawned worker via HACKSIM_PACE and the role argv.

Yes. Each builder writes a real index.html plus app.js plus style.css into its own working directory, runs git init && git add && git commit, then broadcasts project.submitted with the commit hash. The orchestrator runs:

git archive --format=tar <commit_hash> | tar -x -C sim-runs/<sim_id>/projects/<project_id>/

The Demo tab in the showcase modal points an iframe at that tree. The Code tab uses shiki.codeToHtml on the real file contents. Click any winner card and switch tabs to see the source the agents wrote, byte for byte.

The artefact static route serves with this CSP:

Content-Security-Policy:
  default-src 'none';
  script-src 'self' 'unsafe-inline';
  style-src 'self' 'unsafe-inline';
  img-src 'self' data:;
  font-src 'self' data:;
  frame-ancestors 'self'

The iframe in the modal sets sandbox="allow-scripts" only (no allow-same-origin, no allow-top-navigation, no allow-forms, no allow-popups). Agent code can run script and styles but cannot fetch, navigate, set cookies, or read parent state.

The rules require “communication across separate AXL nodes, not in-process.” Every agent role runs its own AXL Go binary built from the upstream gensyn-ai/axl submodule, with its own ed25519 identity and its own ports. No process holds two roles. There is no central message broker. Cross-agent messages travel through the Yggdrasil mesh AXL provides.

While a sim is running:

# 1) See the AXL Go binaries running (one per role).
ps aux | grep third_party/axl/node | grep -v grep

# 2) See each role's listening ports.
lsof -i -P -n | grep -E "node.*LISTEN" | sort

# 3) Watch loopback traffic during a run (macOS uses lo0; Linux uses lo).
sudo tcpdump -i lo0 -n 'tcp port 9100 or tcp port 7000' | head -20

Stopping every node interrupts the simulation immediately: designers stop posting, builders stop hearing bounties, judges stop scoring. The AXL nodes are the system’s nervous system; the orchestrator is just the host.

Yes. ETHGlobal Open Agents 2026, for the Best Application of the Agent eXchange Layer (AXL) bounty. Every commit landed during the hackathon window, each with a matching process note under docs/process/. The chronological build is readable in roughly twenty minutes. Source at github.com/vrnvrn/hacksim.