Project Info
This project did not submit a demo video on Devpost.
Inspiration
Quantum computers need fast, reliable error correction to become useful. A big part of that problem is the decoder: the hardware/software path that turns noisy syndrome measurements into corrections before errors compound. We built CryoBrain because most AI-for-hardware demos stop at generated code or proxy scores. We wanted a system where agents could propose hardware improvements, test them against real verification and measurement tools, learn from research, and leave behind artifacts that judges can actually inspect. What It Does CryoBrain runs a multi-agent refinement loop for quantum-decoder hardware. Each iteration proposes decoder/FIFO design changes, measures them through a real toolchain, records verification artifacts, and archives the evidence. The reward is grounded in measured behavior rather than a mock demo: [ reward \approx f(\text{logical error suppression}, \text{latency}, \text{area}, \text{validity}) ] The project includes: A measured RL/refinement loop 50 archived sponsor-backed training iterations Verifiable artifacts for each iteration Offline demo dashboard Memory A/B tracking with honest parity reporting Pareto frontier views for hardware tradeoffs Sponsor integrations for research, model generation, remote measurement, and eval proof How We Built It We built the project as a Python-based hardware-design training environment. The core loop runs agents that propose, generate, verify, measure, score, and archive hardware variants. The system uses real hardware tooling where possible: Verilator for simulation, Yosys for synthesis-style metrics, Stim for quantum-error simulation, and Python orchestration for the RL loop. We also integrated sponsor platforms: Exa for research context, Fireworks for proposal generation, Modal for remote measurement, and HUD for evaluation gating. For the final proof run, we executed 50 sponsor-backed refinement iterations and archived each cycle under artifacts/marathon_runs/cycle_###, with a summary validator confirming the artifacts are present and measurable. Challenges We Faced The hardest part was keeping the evidence honest. It is easy to make an AI system look like it is improving if the reward is synthetic or if artifacts are overwritten. We had to build checks that preserved every iteration and verified that the data was real. We also had to fix claim discipline around memory. The memory A/B evidence showed parity, not an advantage, so we changed the demo and validators to avoid claiming memory improved the run unless the endpoint delta is strictly positive. Another challenge was making the project submission-clean: removing local developer paths, avoiding committed secrets, keeping sponsor evidence verifiable, and ensuring the dashboard only presents measured artifacts. What We Learned We learned that AI agents can be useful for hardware design only when their outputs are tied to real verification. The interesting part is not just generating RTL; it is closing the loop between research, candidate generation, simulation, scoring, and auditability. We also learned that honest negative or neutral results matter. Memory parity is still useful evidence because it prevents overclaiming and makes future improvement measurable. What's Next Next, we want to push beyond parity into real memory-driven improvement, expand the decoder search space, add stronger formal verification, and run longer training loops with richer research ingestion.
CryoBrain
The AI hardware lab for designing the full quantum chip, starting with the brain that keeps it alive.
CryoBrain is a measured agentic hardware-design platform. Today it proves the loop on quantum-decoder and FIFO hardware targets: agents research, propose, generate RTL, simulate, synthesize, verify, score, remember, and improve against real artifacts. The bigger vision is full chip design: an AI lab that co-designs the decoder, dataflow, memory, control, verification, and cryogenic hardware stack for future quantum processors.
The pitch is simple: every quantum chip needs a brain. CryoBrain is the swarm that designs that brain today, and the path to AI-designed full-chip systems tomorrow.
Contents
- Why This Exists
- Status At A Glance
- What Is Built
- Evidence
- Architecture
- Demo
- Demo Video
- Quick Start
- Configuration
- Repository Map
- Verification
- Built With
- Roadmap
- Contributing Invariants
- License
Why This Exists
Quantum computers will not scale without real-time error correction. That means future chips need more than qubits: they need an on-chip intelligence layer that can interpret syndrome streams, choose corrections, respect cryogenic hardware budgets, and keep the machine alive.
Most AI hardware demos stop at generated code or proxy scores. CryoBrain is built around a stricter rule:
worse RTL -> worse measured behavior -> lower reward
The system is useful only if a proposed design survives measurement and verification. That is why the repo is organized around measured artifacts, not screenshots or synthetic claims.
The current implementation is the slow design loop: an AI swarm improves hardware designs offline. The full-chip vision is the fast loop: the learned NPU-style brain eventually sits inside the quantum control stack and helps run the chip in real time. The README sells that full vision, while the status table below separates what is actually built from what remains the roadmap.
Status At A Glance
| Area | Status | Evidence |
|---|---|---|
| Measured reward spine | Built and validated | score_measured, Stim vectors, Verilator, Yosys; C0-C10 gate passes |
| Quantum-decoder task | Built, early climb | artifacts/measured_climb.json; golden baseline is landed, multi-step decoder improvement is still limited |
| FIFO hardware target | Built, improving | 50/50 marathon iterations show positive FIFO throughput delta |
| 50 sponsor-backed marathon | Built and archived | artifacts/marathon_runs/cycle_001 through cycle_050; summary in artifacts/measured_50_iteration_summary.json |
| Research adoption loop | Built | Exa research context is threaded into proposal/memory artifacts and the swarm event bus |
| Offline demo dashboard | Built | demo/index.html, generated from measured artifacts only |
| React/Three pitch site | Built on this branch | web/, a 14-section scrollytelling app bound to web/public/data/cryobrain.json |
| Memory A/B | Evidence present, no advantage claim | 50/50 iterations report memory_parity; memory_wins=0 |
| Full chip design platform | Vision, partially proven by two hardware targets | Current proof covers decoder + FIFO; roadmap expands to broader chip subsystems |
| In-chip real-time NPU brain | Vision | Not claimed as built in this repo |
What Is Built
CryoBrain is a nine-role hardware-design swarm:
| Role | Responsibility | Current implementation |
|---|---|---|
| Research | Pull current decoder/QEC context and provenance | Exa-backed context packs |
| Planner | Choose the next experiment direction | Planner climb artifacts |
| Architect | Propose candidate decoder/NPU configurations | Fireworks-enabled proposer with deterministic fallback |
| RTL | Generate synthesizable SystemVerilog | cryobrain/rtl_gen/ and task RTL outputs |
| Measurement | Run measured simulations and hardware metrics | Stim, Verilator, Yosys, FIFO throughput |
| Verifier | Enforce L1-L5 checks | Functional, accuracy, formal-when-available, synthesis, budget |
| Scorer | Convert measured behavior into reward | Measured-only reward path |
| Memory | Store verified winners and provenance | JSONL memory records and A/B evidence |
| Visualization | Render the audit trail | Offline dashboard bound to measured artifacts |
The core loop is:
Research -> Planner -> Architect -> RTL -> Measurement -> Verifier -> Scorer -> Memory
^_______________________________________________________________|
The loop is intentionally not just "AI writes Verilog." It is an evidence machine: every useful claim should point at an artifact.
Evidence
The strongest current proof is the sponsor-backed marathon:
| Evidence | Current value |
|---|---|
| Completed iterations | 50 |
| Steps per agent per iteration | 2 |
| Archived iteration directories | 50 |
| Required live sponsors | HUD, Exa, Fireworks, Modal |
| FIFO iterations with positive throughput delta | 50 |
| Decoder iterations with positive delta | 0, because the decoder is already at the golden baseline in these runs |
| Memory iterations marked as wins | 0 |
| Memory status | memory_parity |
| Measured Pareto points | 26 total, 22 frontier points |
Key files:
artifacts/measured_50_iteration_summary.json- top-level marathon summary.artifacts/marathon_runs/cycle_001/...cycle_050/- archived measured evidence per iteration.artifacts/measured_fifo_climb.json- FIFO throughput improvement evidence.artifacts/measured_climb.json- decoder measured climb evidence.artifacts/measured_memory_ab.json- memory A/B artifact; currently parity, not advantage.artifacts/measured_pareto.json- measured design frontier.artifacts/verification_report.json- L1-L5 verification summary.
Architecture
flowchart LR
research["Research<br/>Exa context + provenance"]
planner["Planner<br/>experiment direction"]
architect["Architect<br/>candidate design"]
rtl["RTL<br/>SystemVerilog generation"]
measure["Measurement<br/>Stim + Verilator + Yosys"]
verify["Verifier<br/>L1-L5 gates"]
score["Scorer<br/>measured reward"]
memory["Memory<br/>verified winners"]
demo["Demo<br/>measured dashboard"]
research --> planner --> architect --> rtl --> measure --> verify --> score --> memory
memory --> planner
measure --> demo
verify --> demo
score --> demo
The measured reward path is the moat:
- Generate a hardware candidate.
- Run real simulation / measurement.
- Reject invalid or over-budget designs.
- Score only measured behavior.
- Archive the result so the claim can be audited later.
The full-chip design vision extends this same loop beyond the current decoder/FIFO targets: interconnect, memories, control, calibration datapaths, verification plans, and eventually the on-chip NPU-style brain.
Demo
Demo Video
Watch the demo: https://youtu.be/-cI-zxsLctQ
The video walks through the CryoBrain pitch: the full-chip vision, measured decoder evidence, sponsor-backed marathon results, and the live React scrollytelling app.
Live app: https://ayushozha.github.io/CryoBrain/
There are two demo surfaces:
| Surface | Purpose | Path |
|---|---|---|
| React/Three scrollytelling site | Sells the full-chip vision with a polished visual narrative bound to measured project data | Live · web/ |
| Offline audit dashboard | Shows the raw measured loop: waveform, improvement tracks, memory A/B, Pareto, and swarm bus | demo/index.html |
React/Three Vision Site
Deployed: https://ayushozha.github.io/CryoBrain/
Run the richer pitch experience locally:
cd .\web
npm install
npm run dev
Then open the local Vite URL: http://127.0.0.1:5174/ or http://localhost:5174/.
Build the static site:
cd .\web
npm run build
The web app uses web/public/data/cryobrain.json as its measured data contract. It presents the 2040 full-chip arc, but keeps measured numbers tied to the checked-in evidence.
Offline Audit Dashboard
Open the offline dashboard:
Invoke-Item .\demo\index.html
Recommended 2-minute flow:
- Show the full-chip thesis: CryoBrain is the AI hardware lab for the chip's brain.
- Start with the React/Three site for the vision and chip story.
- Open
demo/index.htmland click Play story for the audit trail. - Point to Panel B for measured decoder/FIFO improvement tracks.
- Point to the swarm bus: research, proposal, measurement, verification, scoring, memory.
- Point to Panel C honestly: memory A/B exists, but current evidence is parity.
- Point to the archived marathon summary for 50 sponsor-backed iterations.
If you need to rebuild the demo from artifacts:
uv run python scripts/build_demo.py
uv run python scripts/check_demo_rehearsal.py
Quick Start
Windows / PowerShell
Prerequisites:
- Python 3.11 or 3.12
uv- WSL for the full EDA-backed path
- OSS CAD Suite inside WSL for Verilator/Yosys flows
Install Python dependencies:
uv sync --extra rl --extra sponsors
Run the lightweight local checks:
uv run pytest tests/test_demo_measured.py tests/test_marathon_iterations.py -q
uv run python scripts/check_spec_v61_checkpoints.py
uv run python scripts/check_demo_rehearsal.py
Run the React/Three site:
cd .\web
npm install
npm run dev
WSL / EDA Path
Install the OSS CAD Suite if needed:
bash scripts/install_oss_cad_wsl.sh
Run the full SPEC-v6.1 gate:
bash scripts/run_spec_v6_gate_wsl.sh
Run or validate the sponsor-backed marathon:
bash scripts/run_improvement_marathon_wsl.sh 50 2 0 50
python scripts/check_marathon_iterations.py --min-iterations 50 --require-sponsors --require-artifacts
Configuration
Create a local .env for private keys. Do not commit it.
| Variable | Purpose |
|---|---|
HUD_API_KEY | HUD evaluation/runtime access |
EXA_API_KEY | Research context retrieval |
FIREWORKS_API_KEY | Architect/Planner proposal generation |
MODAL_TOKEN_ID | Modal remote measurement credential |
MODAL_TOKEN_SECRET | Modal remote measurement credential |
MODAL_TOML | Optional path override for Modal config; defaults to $HOME/.modal.toml in WSL wrappers |
Sponsor readiness check:
uv run python scripts/check_sponsors.py --require-core
Repository Map
| Path | Role |
|---|---|
env.py | HUD environment and agent tools |
tasks.py, task_catalog.py, grader.py | HUD task registration and hidden grader routing |
cryobrain/rl/ | Measured training, FIFO loop, planner loop, Modal measurement integration |
cryobrain/swarm/ | Event bus, executors, proposal loop, visualization data |
cryobrain/retrieval/ | Research context packs and provenance tags |
cryobrain/rtl_gen/ | SystemVerilog generation |
cryobrain/verify/ | L1-L5 verification logic |
cryobrain/artifacts/ | Artifact builders, Pareto/frontier support, reports |
tasks/cryo_brain_decoder/ | Primary quantum-decoder hardware task |
tasks/stream_arb_fifo_* | FIFO repair/DV/formal tracks used as a broader hardware proof point |
scripts/ | Checkpoint, marathon, WSL, demo, and export commands |
demo/ | Offline measured dashboard |
web/ | React/Vite/Three scrollytelling site for the full-chip vision |
docs/specs/ | Versioned specs; SPEC-v6.1 is the current checkpointed spec |
artifacts/marathon_runs/ | Archived 50-iteration sponsor-backed evidence |
Verification
Commands last used for the merged evidence path:
uv run pytest tests/test_marathon_iterations.py tests/test_demo_measured.py tests/test_modal_measure.py tests/test_fireworks_proposer.py tests/test_exa_integration.py -q
uv run python scripts/check_marathon_iterations.py --min-iterations 50 --require-sponsors --require-artifacts
uv run python scripts/check_spec_v61_checkpoints.py
uv run python scripts/check_demo_rehearsal.py
React/Three app:
cd .\web
npm run build
WSL syntax check for the sponsor wrappers:
wsl.exe --cd /mnt/c/path/to/CryoBrain bash -n scripts/run_improvement_marathon_wsl.sh scripts/run_spec_v6_gate_wsl.sh
The full 50-iteration run was executed with:
wsl.exe --cd /mnt/c/path/to/CryoBrain bash scripts/run_improvement_marathon_wsl.sh 50 2 0 50
Built With
- Python 3.11-3.12
- uv
- HUD
- Stim
- PyMatching
- Verilator
- Yosys
- Cocotb / PyUVM
- Modal
- Fireworks
- Exa
- Pytest
- WSL
- HTML, CSS, and JavaScript for the offline demo
- React 18
- Vite 5
- TypeScript
- Three.js / React Three Fiber
Roadmap
The roadmap is full chip design, not only decoder tuning.
| Horizon | Goal |
|---|---|
| Next | Push decoder beyond the golden baseline with multi-step L2-valid improvements |
| Next | Turn memory A/B from parity into measured advantage before claiming compounding |
| Near | Add richer chip subsystems: memory hierarchy, routing/dataflow, calibration control, and scheduler logic |
| Near | Expand verification from per-block evidence to cross-block chip-level contracts |
| Long | Train the design swarm across the complete cryogenic control stack |
| Long | Move from offline chip-design lab to an in-chip NPU-style brain that can support real-time QEC decisions |
Contributing Invariants
Keep these rules intact:
- Do not replace measured reward with proxy-only scoring.
- Do not present a generated design as useful until measurement and verification artifacts exist.
- Do not claim memory advantage unless
endpoint_delta > 0in measured A/B evidence. - Keep sponsor keys and local credential paths out of committed artifacts.
- Keep roadmap/full-chip claims clearly separated from built evidence.
- Preserve PowerShell-safe commands for Windows users and label WSL commands clearly.
License
No root LICENSE file is currently checked in. Do not assume the repository is MIT-licensed until a root license is added.
Third-party HDL notices are documented in THIRD_PARTY_NOTICES.md. Vendored BaseJump STL files under tasks/stream_arb_fifo_* preserve their upstream Solderpad Hardware License notices.
Analysis
View
Metric
- 66
Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.
Technology
- HTMLIn code
- OpenAIIn code
- PythonIn code
- ReactIn code
- TypeScriptIn code
- CSSClaimed
- JavaScriptClaimed
5 of 7 appear in the indexed code. 2 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.
AI coding agents
No AI coding agent signals were found in this repository.
Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.
Codebase size
Source size
5.4 MB
Source files
528
Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.
Repository
ayushozha/CryoBrain
3,942 files · 9.1 MB · @ b3c7b34
Structure
Interface
3 files · 0%Screens, components and styles rendered to the user.
Application logic
3,472 files · 88%Domain rules, services and shared utilities.
+19 moreBackground jobs
54 files · 1%Work run outside a request: tasks, workers and schedules.
Data & schema
1 file · 0%Schema definitions, migrations and data access.
Supporting
Layers are inferred from where files sit in the tree, not from reading the code. A project that names its directories unconventionally will read oddly here — open the file browser to check anything the diagram implies.
Languages
- HTML80%
- Python13%
- Markdown5%
- TypeScript2%
- Shell1%
- YAML0%
Share of indexed source by file size. Binary and vendored files are excluded.
Dependencies
pyproject.toml
pypi · 16- cocotb
- cocotb-bus
- cocotb-coverage
- hud-python[agents]
- hypothesis
- matplotlib
- numpy
- pydantic
- pymatching
- pyuvm
- stim
- +5 more
web/package.json
npm · 11- @react-three/drei
- @react-three/fiber
- react
- react-dom
- three
- +6 more
Declared in the repository’s manifests at the indexed commit. A declared package is not proof it is used, and runtime dependencies are listed first.
Feature verification
50 archived sponsor-backed training iterationsVerified
50 archived sponsor-backed training iterations, each cycle recorded under artifacts/marathon_runs/cycle_###.
Claimed on Devposthigh confidenceartifacts/marathon_runs/cycle_001— Directory exists with design_runs, measured_climb.json, measured_fifo_climb.json, measured_memory_ab.json, measured_pareto.json, planner_climb.json, summary.json, verification_report.jsonartifacts/measured_50_iteration_summary.json:6— completed_iterations: 50, and iteration_artifact_dirs lists cycle_001 through cycle_050 with required_sponsors hud/exa/fireworks/modal true
50 sponsor-backed marathon required all live sponsors (HUD, Exa, Fireworks, Modal)Verified
Required live sponsors for the marathon run were HUD, Exa, Fireworks, and Modal.
Claimed on readmehigh confidenceartifacts/measured_50_iteration_summary.json:10— required_sponsors block shows hud: true, exa: true, fireworks: true, modal: true (daytona/antim false, consistent with them being non-required)
Decoder golden baseline / limited multi-step decoder improvementVerified
Quantum-decoder task is built with an early climb; golden baseline landed, multi-step decoder improvement still limited (0 decoder iterations with positive delta in the 50-run marathon).
Claimed on readmemedium confidenceartifacts/measured_climb.json:6— Sample decoder climb artifact shows candidate_ler at 0.0 / suppression 1.0 already, consistent with the claimed 'already at golden baseline, 0 iterations with positive delta'
Memory A/B tracking with honest parity reportingVerified
Memory A/B tracking reports honest parity rather than an inflated advantage; memory_wins=0, endpoint_delta must be strictly positive to claim advantage.
Claimed on Devposthigh confidenceartifacts/measured_memory_ab.json:3— with_memory and without_memory arrays contain identical measured values (parity), not an inflated advantagescripts/run_memory_ab.py:83— memory_wins computed from end_reward comparison between with/without memory runs
Multi-agent refinement loop (research, planner, architect, RTL, measurement, verifier, scorer, memory)Verified
CryoBrain runs a multi-agent refinement loop for quantum-decoder hardware, proposing, generating, verifying, measuring, scoring, and archiving hardware variants each iteration.
Claimed on Devposthigh confidencecryobrain/rl/proposal_loop.py— Implements the proposal/measure/verify/score loop referenced by the marathon scriptscryobrain/swarm/executors.py— Executors implement the swarm roles (research, architect, RTL, measurement) described in the READMEcryobrain/swarm/event_bus.py— Event bus wiring the multi-agent pipeline stages together
Offline demo dashboard bound to measured artifactsVerified
An offline demo dashboard (demo/index.html) generated from measured artifacts only.
Claimed on readmehigh confidencedemo/index.html:1— Standalone dashboard HTML file exists in the reposcripts/build_demo.py— Build script referenced by README that generates the dashboard from measured artifacts
Pareto frontier views for hardware tradeoffsVerified
Pareto frontier views for hardware tradeoffs (accuracy vs area) computed from measured data.
Claimed on Devposthigh confidencecryobrain/benchmark/pareto.py:49— _is_dominated implements standard Pareto dominance over measured LER and area_um2, sourced from the memory storeartifacts/measured_pareto.json— Archived Pareto artifact file exists as claimed
React/Three.js scrollytelling pitch site (14 sections)Verified
A React/Vite/Three.js 14-section scrollytelling app bound to web/public/data/cryobrain.json, deployed to GitHub Pages.
Claimed on readmehigh confidenceweb/src/sections/S01Hero.tsx— First of 14 numbered section components (S01-S14) found under web/src/sectionsweb/src/three/HeroScene.tsx— Three.js scene components under web/src/three, confirming the Three.js visual layerweb/public/data/cryobrain.json— Measured data contract file exists as referenced by the web app
Real toolchain measurement: Stim quantum-error simulationVerified
Stim is used for quantum-error simulation to compute logical error rate.
Claimed on readmehigh confidencecryobrain/stim/vector_bank.py— Stim vector generation modulecryobrain/stim/compare.py— Compares measured decoder output against Stim-generated syndrome vectors, feeding candidate_lercryobrain/accuracy/measured_ler.py— Computes measured LER from Stim/Verilator pipeline
Real toolchain measurement: Verilator simulationVerified
Verilator is used for simulation as part of the real measurement toolchain.
Claimed on readmehigh confidencecryobrain/verify/l1_functional.py:23— run_l1 shells out to the real 'verilator --lint-only' commandcryobrain/rtl_grader/synth_metrics.py— Additional Verilator-based metrics extraction referenced across rl/verify modules
Reward grounded in measured behavior (LER suppression, latency, area, validity)Verified
The reward is grounded in measured behavior rather than a mock demo: reward ≈ f(logical error suppression, latency, area, validity).
Claimed on Devposthigh confidencecryobrain/grader/score.py— score_measured combines L1/L4/L5 gate results with measured LER and synth metrics into a rewardartifacts/measured_climb.json:1— Archived climb artifact records candidate_ler, suppression, area_um2, latency_cycles per step, matching the claimed reward inputs
RTL generation for decoder/FIFO hardwareVerified
RTL role generates synthesizable SystemVerilog for decoder/FIFO candidates.
Claimed on readmehigh confidencecryobrain/rtl_gen/generator.py— Decoder RTL generator modulecryobrain/rtl_gen/fifo_generator.py— FIFO RTL generator module
Sponsor integration: Exa research contextVerified
Exa integration provides research context for proposals via real API calls.
Claimed on Devposthigh confidencecryobrain/integrations/exa_rag.py:25— _client() builds a real exa_py.Exa client keyed off EXA_API_KEY, with clean skip (not fabrication) when absentartifacts/measured_50_iteration_summary.json:16— exa_urls/exa_titles recorded in the marathon summary show real Exa search results were captured
Sponsor integration: Fireworks proposal generationVerified
Fireworks integration used for the Architect/Planner proposal generation.
Claimed on Devposthigh confidencecryobrain/integrations/fireworks.py:21— Calls the real Fireworks inference API (FIREWORKS_BASE) with a validated JSON proposal schema, no mocked responses in the production path
Sponsor integration: HUD evaluation gatingVerified
HUD integration used for evaluation gating of the agent environment.
Claimed on Devposthigh confidenceenv.py:11— Imports hud.Environment/Workspace and defines the CryoBrain HUD environment with run_eval, cryo_task, verilog_task entrypoints
Sponsor integration: Modal remote measurementVerified
Modal integration used for remote/parallel measurement of hardware candidates.
Claimed on Devposthigh confidencecryobrain/rl/modal_measure.py:1— measure_batch fans out score_measured (Verilator/Yosys/Stim) across parallel Modal containers, with a local fallback when Modal isn't configured
Verifiable artifacts for each iteration (L1-L5 verification report)Verified
Records verification artifacts for each iteration; a summary validator confirms artifacts are present and measurable.
Claimed on Devposthigh confidencecryobrain/verify/l1_functional.py:17— run_l1 invokes real Verilator lint and writes a log artifactcryobrain/verify/l4_synth.py— Synthesis-stage verification gatecryobrain/verify/l5_budget.py— Budget verification gatescripts/check_marathon_iterations.py— Validator script referenced in README that checks archived iteration artifacts
FIFO hardware target with 50/50 positive throughput deltaCode-supported
The FIFO hardware target shows improving results across all 50 marathon iterations with positive throughput delta.
Claimed on readmemedium confidenceartifacts/measured_fifo_climb.json:8— One sample climb artifact shows throughput increasing from 0.09375 to 0.3125 across steps, consistent with the claim, but only one iteration's file was inspected, not all 50cryobrain/accuracy/fifo_throughput.py— Measured FIFO throughput computation module backing the claim
Real toolchain measurement: Yosys synthesis-style metricsCode-supported
Yosys is used for synthesis-style metrics (e.g., area) in the measurement toolchain.
Claimed on readmemedium confidencecryobrain/verify/l4_synth.py— L4 synthesis verification gate references Yosys-based flowcryobrain/rtl_grader/synth_metrics.py— Synthesis metrics module referenced by grader/score.py for area_um2
An AI agent derived these features from the project’s Devpost page and readme, then searched the code for each one. Verified features are backed by cited code; claimed-only features had no supporting code, which is not by itself proof a feature is missing.
Export this project's context (description, README, evidence, key source files) to chat with an AI agent elsewhere.