← Back to the app

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

1 traceper story in neatlogs; every promise is one quoted verdict span
97 checkpointsin Entire, one per change; 4 trails merged, each with runners and a review
67.8% vs 43.4%margin the cfo.ai model gave for painting half the pages versus all of them

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).

7,100+traces from our runs, sweeps, drills and experiments (dashboard home: 7,123 sessions in 7 days)
4 resolvedincident cards, each checked against the trace and closed with a note
10 detections, 7 alertsincluding a picture-words detection that fired on a drill, and email delivery

What we traced and what it led to

What neatlogs showedWhat we changedEvidence
One trace per story with a GUARDRAIL span per verdict (quoted text, pass or fail)The parent's receipt is built from the same verdictsTOOLS.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 cardOne 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 backHedged retry, tiered a false stop, a quiz detection on the right span type, alerts retuned with email deliveryincident review, HR-011
Error spans of a stronger writer (Claude Sonnet): 3 of 10 stories ended with a page-format errorA tolerant parser: 10 of 10 afterwardsHR-014, HR-015
Drills we ran on purpose (judge down, 503s, stalls, image 429s): none of 5 stories shipped with the judge downA judge from another family on failover (5 of 5), and a calm "try again" screen instead of a refusalHR-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 fixA 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 estimateReplaced the estimate in the cfo.ai modelcost file
Evaluations: a human reviews single judge verdicts (17 verdicts assigned)Measures human and judge agreement; no agreement number is claimed until it is answeredevaluation setup

Screenshots (neatlogs)

neatlogs incidents
N1. Incidents: one under investigation, found by neatlogs on its own (a Gemini 504 timeout).
resolved incidents
N2. Four resolved incident cards, among them "Resolve Infinite Repair Loop" and "Latency and Quota Exhaustion in illustrate" that we checked and closed with notes.
incident detail
N3. An incident's root-cause analysis, resolved by us: it was our own image-429 drill, and the agent recovered as designed.
investigation
N4. The investigation neatlogs ran: evidence, reasoning and a recommended action.
trace with detection
N5. A story trace opened from the detection "Execution Failed": the 504 error span of a Gemini call with its prompt and error.
trace with latency detection
N6. The suggested detection "High Latency LLM Monitor" (accepted from neatlogs's own recommendations) flagging a slow call.
detections list
N7. Our detections: oath violation, critical safety stop, quiz promise broken, picture has words painted in, and the suggested monitors.

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.

97 checkpointsin 132 commits (Entire analytics, 12 Oct), each tied to a commit with an Entire-Checkpoint trailer
4 trails mergedeach backed by a branch and a pull request, with six runners; reviews found 5, 8 and 7 real issues on three of them
7 graph diffsof the hardening changes, plus impact and verify runs on the safety words

Everything below lives on Entire: Overview Commits and checkpoints Trails Runners Sessions Analytics

Checkpoints: progress and key decisions

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).

Trails and reviews: what Entire found in our own work

ReviewWhat it foundWhat 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 28 issues, including a missing fallback that would have turned a gateway outage into failed storiesAll fixed. On Entire: trail 3 (review text)
PR 410 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 moreFixed with tests. On Entire: trail 5 (review text, HR-015)
Trail 5 runnerHigh: a stray chaos-injection setting could reach productionIt now does nothing unless a drill names itself (commit 5f9253b)
Trail 5 runnerHigh: autoplay against our "no autoplay" ruleDismissed 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)

trail 5
E1. Trail 5, merged: confidence, risk, drift and security scores from the runners, and the gates (approvals, findings, checks, up to date).
trail 4
E2. Trail 4 (workbooks, ages and languages), merged, with its gates passing apart from the solo approvals rule.
security runner
E3. The Trail Security runner: the prompt we wrote for it, with the project's own rules.
review runner
E4. The Trail Review runner, which received our previous findings as data so it does not repeat them.
session
E5. A session page: the hardening records session, with its prompts, responses and checkpoints.
analytics
E6. Entire analytics: 97 checkpoints, 4 trails merged, token use over time.
token usage
E7. Token use by contributor and peak hours (a solo builder with a coding agent).

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).

67.8% / 43.4%month-6 margin: half the pictures against all of them (Main scenario, estimates)
-70%margin with three video clips a story; the video scenarios are in the model
~2,490paying households to break even at $6.99 a month (launch plan, assumptions labelled)

Decisions the model made

QuestionWhat the model saidWhat 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 pointWe 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)

unit economics
C1. Unit economics by plan: gross margin by plan at month 6, Main against Growth and Downside.
policy table
C2. Verification and illustration policy: cost per story and gross margin for all pictures, half, and none.
margin chart
C3. The interactive chart: margin against pictures per story, with the 60% bar; the most pictures that clear it is 5.
evidence and method
C4. Evidence and method: what is measured (token counts) and what is assumed.
launch plan
C5. Launch plan: the real operating and one-time costs of a product, all labelled as assumptions.
version history
C6. Version history: the cost input edited to the neatlogs measurement.
version history policy
C7. Version history on the policy page: the scenarios and formulas built through the cfo.ai agent.

Recommendations and input from the tools, and what we changed

ToolIts recommendation or inputWhat we didLink
neatlogsTriage card: a Gemini call stalling 87 sHedged retry (send the call again after 45 s)HR-011
neatlogsTriage card: critical stops on "hurts"Mild words ask for a rewrite; the stop is kept for the severe onesHR-004
neatlogsSuggested detections ("Critical Violation Monitor", "High Latency LLM Monitor")Accepted both; they now fire on our traces (screenshots N6, N7)N7
neatlogsIncident cards of 12 OctFound the fragmented traces; fixed the span context; the other two refuted or explainedHR-016
neatlogsAlerts and email deliveryThresholds retuned (oath violation 40 an hour, slow story 450 s, expensive story $0.10), seven rules with emailretune
EntireReview of PR 1, 2 and 4, trail runners on 4 and 5Fixed 5, 8 and 7 defects, a high-severity chaos setting, and wrote the narration rule preciselyHR-015
Entiregraph impact on the safety wordsChanged the tiers only where the graph showed the callers were coveredimpact
cfo.aiMargin against pictures per storyThe agent chooses which pages to paint within a budgetHR-010
cfo.aiVideo AI scenariosVideo left out; motion is deterministic and checkedBUSINESS.md
cfo.aiMeasured cost replaces the estimateVersion history shows the editC6

What broke, said plainly

  1. A 40 s timeout for the stall: tried, did not hold up in an A/B, reverted (HR-005).
  2. 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).
  3. Trace-level regex detections on multi-line verdicts never fired until we moved them to the right span type (HR-011).
  4. Pictures and judge calls missing from the story's trace, and incident cards read the fragments as failures: our bug, fixed (HR-016).
  5. 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).
  6. 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.