Storybound, for the neatHack judges
A bedtime-story helper that checks its own work, so a parent doesn't have to. A child draws a hero; before any page reaches the child, the agent has checked it against promises it wrote first, rewritten what broke, and afterwards it hands the parent a receipt.
Open the live app Free demo mode 3-minute video Full tour video Code
The problem and the solution
Problem. AI can write a story about your child's drawing in seconds, and nobody checks it. In our own experiment the same writer, left alone, slipped at least one broken promise into 27 of 28 stories (a lesson that never showed up, the right answer always in the same place, words too hard for the age, sometimes an unkind line). A parent cannot read every story first.
Solution. The agent writes an oath (a checkable list of promises) for each drawing and lesson, checks every page against it with simple rules and an independent second AI, rewrites any page that breaks a promise, shows a page only when its words, picture and voice all exist, and gives the parent a receipt. With every page checked, 0 of 28 stories shipped a broken promise. Why it matters to families and communities: docs/WHY.md.
What the judges score: the agent 30%, use of neatlogs, Entire and cfo.ai 25%, demo video 20%, building in public 15%, usefulness and originality 10%. The page below is the 25%.
How we used the tools
Short answers to the three questions of the submission form follow, each with evidence links and screenshots from our own dashboards. Trace and trail pages need a login, so the screenshots stand in for them; the repository holds exported traces and the files behind every number.
neatlogs: what did you trace, debug or improve?
Short answer
We traced every story run as one trace (the oath, each page, each judge call, each picture, each voice) and made every promise check its own span, with the quoted words and the verdict. We then used neatlogs to find our own bugs: its incidents, detections, alerts, error spans and evaluations led to a series of fixes, each with before and after numbers. Trace first, then fix, was our written rule (CLAUDE.md).
What we traced and what it led to
| What neatlogs showed | What we changed | Evidence |
|---|---|---|
| One trace per story with a GUARDRAIL span per verdict (quoted text, pass or fail) | The parent's receipt is built from the same verdicts | TOOLS.md, exported traces |
Reading level broke on most first-pass pages (trace 264208295ada9b28) | Told the writer the limit: pages over the limit fell from 42.9% to 1.8% | HR-001, HR-003 |
| Its own triage cards: an 87 s Gemini stall, "hurts" flagged critical, a PII card | One confirmed (hedged retry later), one partly (mild words now ask for a rewrite), one refuted (it read its own redaction) | TRIAGE-REVIEW, HR-004, HR-011 |
| A second pass through traces, detections, alerts and analytics: two detections had never fired, no alert could notify anyone, the stall was back | Hedged retry, tiered a false stop, a quiz detection on the right span type, alerts retuned with email delivery | incident review, HR-011 |
| Error spans of a stronger writer (Claude Sonnet): 3 of 10 stories ended with a page-format error | A tolerant parser: 10 of 10 afterwards | HR-014, HR-015 |
| Drills we ran on purpose (judge down, 503s, stalls, image 429s): none of 5 stories shipped with the judge down | A judge from another family on failover (5 of 5), and a calm "try again" screen instead of a refusal | HR-015 |
| Three new incident cards on 12 Oct: "repair loop never ends", "latency in illustrate", "K2 returns prose" | Each checked against the traces: the cap holds; our own drill; refuted by the span. The first exposed a real fault of ours: pictures and judge calls were missing from the story's trace (208 spans before, 225 after, 2 of 4 pictures before, 4 of 4 after). Fixed. | HR-016, triage notes, before and after |
| The "Picture has words painted in" detection, blind until the fix | A drill painted words into a real picture: the vision judge caught it, the agent repainted it, the detection fired (1 occurrence, 0 before) | HR-016, trend |
| Measured cost per story: $0.0199, about 20% above our token estimate | Replaced the estimate in the cfo.ai model | cost file |
| Evaluations: a human reviews single judge verdicts (17 verdicts assigned) | Measures human and judge agreement; no agreement number is claimed until it is answered | evaluation setup |
Screenshots (neatlogs)







Also in the repository: the screen recording of the dashboards that the videos use, and the neatlogs exports under evidence/neatlogs.
Entire: how did you use it?
Short answer
Entire recorded the coding agent that built Storybound. We made one commit per intent so each checkpoint maps to one change, used entire-graph to see what a change touched before and after, used Trails with tailored runners and entire review to gate each pull request, and recorded durable decisions in Brain. Its reviews found real defects in our own work, which we fixed.
Everything below lives on Entire: Overview Commits and checkpoints Trails Runners Sessions Analytics
Checkpoints: progress and key decisions
- The checkpoint link for submission: commit 1a96c19 (checkpoint
01M4MJM5TRM7NE2F8FHFJ49NE6); other key commits on Entire: HR-003, HR-004, the picture agent (HR-010), the tracing fix (HR-016), the chaos-setting fix; anonymous render checked in this screenshot. - Every hardening record names its commit and checkpoint, and says where there is none (early work before 15:08 on 10 Oct has no checkpoint): commits on Entire, with the records in evidence/hardening.
- Key decisions kept as checkpoints and Brain facts: pipelined review (HR-002, with the honest note that time to first page did not improve), the safety-word tiering (HR-004), the history rewrite after two keys were pasted into a session and reached checkpoint refs ([the note](https://github.com/hatif03/storybound/blob/main/evidence/history-rewrite/NOTE.md)), and the narration rule below.
- The sessions are readable on Entire: the hardening session (screenshot E5) shows the sweep, the report change and the checkpoints it produced.
entire-graph: finding code and assessing risky changes
entire-graph runs on the command line and saves its output; these are the saved runs (files in the repository). The commits they describe are on Entire (links above).
- Before touching the safety words: graph impact of story_safe_text and of verify_scene_async showed what depended on them.
- After each hardening fix: graph diffs for HR-001, HR-002, HR-003, HR-004, HR-006 and the picture agent, which listed the entities each change touched.
- Why is this line here?
entire whyon the oath catalog and the prompts: catalog, prompts. - Brain: ten durable facts and a brain brief that returns the likely files for a task.
Trails and reviews: what Entire found in our own work
| Review | What it found | What we did |
|---|---|---|
PR 1 (entire review general) | 5 findings, one a real bug: the evidence builder printed the latest commit as "First commit" | All five fixed. On Entire: trail 2 (review text) |
| PR 2 | 8 issues, including a missing fallback that would have turned a gateway outage into failed stories | All fixed. On Entire: trail 3 (review text) |
| PR 4 | 10 points, 7 real defects in our own failure fixes: a refusal that could become "try again", a pass hiding an unverified safety check, a failover that re-paid its retries, and more | Fixed with tests. On Entire: trail 5 (review text, HR-015) |
| Trail 5 runner | High: a stray chaos-injection setting could reach production | It now does nothing unless a drill names itself (commit 5f9253b) |
| Trail 5 runner | High: autoplay against our "no autoplay" rule | Dismissed by design with a written reason, and the rule now says exactly what may start by itself (a page's own narration, never the next page): WEB.md |
Trails 2 to 5 and their gates: 2, 4, 5; gate output files in evidence/entire. The solo "approvals" gate stays unmet on every trail, since the trail rule wants a second reviewer; the runners and findings gates did their work.
Open-source builds on Entire's CLI, Graph or External Agents
We did not contribute code to Entire's own open-source projects. What we built on top of them: six Trail runners tailored to this project's hard rules (no secrets, no child data, evidence discipline, the oath as the product, no timers or streaks for children) (shown on the runners page; the files are .entire/runners); Claude Code run as an Entire-supported agent with commit linking set to always; custom redactions for key shapes in .entire/settings.json after a key reached a checkpoint; and scripts/build_evidence.py and scripts/lint_evidence.py, which build the evidence index from checkpoints, traces and the run ledger. We also documented the tool gaps we hit (docs/TOOLS.md: Brain refuses a dirty tree; a pushed checkpoint cannot be removed).
Screenshots (Entire)







cfo.ai: how did it shape your business plan?
Short answer
cfo.ai turned "what does a story cost?" into product decisions. Painting every page leaves a 43% gross margin against our 60% bar, painting half clears it at 67%, so the agent now spends a fixed picture budget on the pages that matter most. We replaced the cost estimate with the cost neatlogs measured, it showed that video AI would take the margin to minus 70%, so video is left out, and it priced what a real launch needs (about 2,490 paying households at $6.99).
- The public model: app.cfo.ai/s/vGE_ZEwfQtpoxPrg (it does not show the later Launch plan and Video AI pages; the readback of those is in evidence/cfo).
- The business plan in plain words: BUSINESS.md. How the model changed the product: HR-010 (the agent chooses which pages to paint; first picture at 70 s instead of 278 s).
- Four scenarios for video AI, a launch plan with operating and one-time costs, and the workbooks saved offline: workbook.
- The cost input in the model is the number neatlogs measured, not a guess: Version history (unit economics) and Version history (policy) show the edit "Cost input = Text and verification B1 gated".
- Hackathon credits: the gateway budget is evaluation money, not product spend, because a story costs about two cents of text: CREDITS.md.
Decisions the model made
| Question | What the model said | What changed |
|---|---|---|
| Can we paint every page? | No: 42.8% margin; half the pages clears the bar (67.2%) | The picture policy, then auto: a $0.16 budget spent on the most important pages |
| Does sampling the checks save money? | Under half a point | We kept full verification: safety does not get cheaper |
| What if we used video AI? | The three cheapest clips: 67% to -70% | Motion stays deterministic; video, if ever, a priced add-on |
| What would a real launch cost? | About $7,300 a month and $23,500 once (assumed) | A checklist of what a product needs beyond the code |
Screenshots (cfo.ai)







Recommendations and input from the tools, and what we changed
| Tool | Its recommendation or input | What we did | Link |
|---|---|---|---|
| neatlogs | Triage card: a Gemini call stalling 87 s | Hedged retry (send the call again after 45 s) | HR-011 |
| neatlogs | Triage card: critical stops on "hurts" | Mild words ask for a rewrite; the stop is kept for the severe ones | HR-004 |
| neatlogs | Suggested detections ("Critical Violation Monitor", "High Latency LLM Monitor") | Accepted both; they now fire on our traces (screenshots N6, N7) | N7 |
| neatlogs | Incident cards of 12 Oct | Found the fragmented traces; fixed the span context; the other two refuted or explained | HR-016 |
| neatlogs | Alerts and email delivery | Thresholds retuned (oath violation 40 an hour, slow story 450 s, expensive story $0.10), seven rules with email | retune |
| Entire | Review of PR 1, 2 and 4, trail runners on 4 and 5 | Fixed 5, 8 and 7 defects, a high-severity chaos setting, and wrote the narration rule precisely | HR-015 |
| Entire | graph impact on the safety words | Changed the tiers only where the graph showed the callers were covered | impact |
| cfo.ai | Margin against pictures per story | The agent chooses which pages to paint within a budget | HR-010 |
| cfo.ai | Video AI scenarios | Video left out; motion is deterministic and checked | BUSINESS.md |
| cfo.ai | Measured cost replaces the estimate | Version history shows the edit | C6 |
What broke, said plainly
- A 40 s timeout for the stall: tried, did not hold up in an A/B, reverted (HR-005).
- Cheaper models as writer, character reader and safety screen: 3 of 10 stories shipped a break; a drawn carrot read as an ice-cream cone; 23 of 26 safety fixtures (HR-012).
- Trace-level regex detections on multi-line verdicts never fired until we moved them to the right span type (HR-011).
- Pictures and judge calls missing from the story's trace, and incident cards read the fragments as failures: our bug, fixed (HR-016).
- A safety-screen outage was shown to the child as "your picture was refused", and the second judge could hide an unverified safety check: found by our drills and Entire's review (HR-015).
- Two keys were pasted into a session and reached checkpoint refs; the history was rewritten with the builder's approval and the keys are due for rotation (note).
Verify it yourself
git clone https://github.com/hatif03/storybound && cd storybound uv sync .venv/bin/python -m pytest -q tests # 107 backend tests .venv/bin/python scripts/lint_evidence.py # evidence checks python scripts/compare_experiments.py # the experiment table (HR-014) wc -l evidence/ledger.jsonl # every named run, with trace id and per-promise verdicts cd web && npm install && npm run test # 29 web tests
The numbers behind this page: EVIDENCE.md, STORY.md, TOOLS.md. Limits are said in each record: ten stories per configuration and five per drill are small samples; the judge is an AI, not a human; the live demo is https at the front door (Vercel) but http between Vercel and our small AWS server, tracing is off, real stories are capped per day, and nothing a visitor makes stays more than 24 hours.