SAGA Core in 30 seconds
SAGA Core checks whether an AI-generated claim is supported before that claim is allowed to leave the system.
A model produces a candidate sentence. SAGA connects its exact claims to evidence, applies a coded authorization gate, and returns ALLOW, QUALIFY, or WITHHOLD. Unsupported language is stopped before release. Qualified language is reconstructed into a narrower answer.
This is a working developer tool, not a prerecorded concept. The public demo, backend, authorization trace, failure behavior and tests are available to judges in the private judge repository:
Judge repository: https://github.com/angelinadavini/SAGA-CORE-BUILD-WEEK-2026-JUDGES
The repository includes setup instructions, deterministic sample cases, the public-safe authorization implementation, GPT-5.6 integration, 91 non-live tests, browser regressions and dated Build Week commits.
A private SAGA resolver and broader method already exist. I have not published their proprietary logic, prompts, thresholds, scoring, private taxonomies or private evaluation materials. The judge repository contains a public-safe, working implementation of the same core authorization principle so judges can inspect and test the Build Week engineering without receiving the protected method.
The clearest example
The central demo starts with:
The pilot included 120 participants. The program works for everyone. The results will last permanently.
The supplied record supports only the first sentence. SAGA keeps that fact, stops the two unsupported claims at the authorization boundary, and reconstructs:
The pilot included 120 participants. Broader effectiveness and durability are not established by the supplied evidence.
That difference matters because generation and authorization are not the same job.
The matched-content demonstration makes the point even more directly. “The board approved Project North” receives ALLOW when it comes from a confirmed verified summary. The identical sentence receives WITHHOLD when it comes from a provisional unverified note. The words did not change. What the source was permitted to support did.
What judges can verify
SAGA Core sits between candidate generation and final release.
- ALLOW releases the original draft when every extracted claim has direct support.
- QUALIFY keeps supported language, blocks unsupported claims and permits only a narrower reconstruction.
- WITHHOLD stops release when evidence is missing, conflicting, invalid or unavailable.
Every visible strike, evidence thread, label and reconstructed phrase in the cinematic interface comes from the structured authorization trace returned by the FastAPI backend.
The BYPASS control releases the same candidate untouched. The SAGA control runs the full authorization journey. After the sequence, Details / Evidence exposes the sanitized sources, exact claim spans, decisions and structured output.
Judges can use the hosted demo without an account, key, payment or credentials:
Public demo: https://saga-core-build-week-2026.vercel.app/
The public deployment uses deterministic traces to prevent unrestricted API spending.
How it works
The backend uses Python, FastAPI, Pydantic, httpx and a small deterministic authorization policy. The frontend uses accessible HTML, CSS, vanilla JavaScript and Canvas.
The live path calls gpt-5.6 through the OpenAI Responses API. GPT-5.6 performs two bounded language tasks:
- Extract exact claims and relate them to supplied evidence using strict JSON-schema output.
- Reconstruct a qualified answer using only claim IDs permitted by code.
GPT-5.6 does not own the release decision. Deterministic code validates the structure and chooses ALLOW, QUALIFY or WITHHOLD. Invalid spans, malformed output, unknown evidence, conflicts, missing evidence, API failure and unsafe reconstruction all fail to WITHHOLD.
The model describes; policy decides.
Why the interface looks this way
I did not want a dashboard that merely described authorization. I wanted the sentence itself to show the intervention.
The candidate decomposes into exact traced spans. Supported language stabilizes and connects to evidence. Unsupported language is struck, stamped and stopped by the red boundary. Permitted text reconstructs into the exact released_text returned by the API.
The single reversible timeline supports play, pause, replay, reverse, wheel, pointer and touch scrubbing, reduced motion and mobile layouts. The deeper technical interface remains available under Details / Evidence.
How I used Codex
I conceived and built SAGA Core as a solo entrant. I defined the product, authorization model, protected-method boundary and cinematic interaction.
I used Codex throughout the Build Week extension, starting from a dated pre-event baseline. Codex accelerated implementation and verification of the FastAPI demo resolver, strict GPT-5.6 gateway, exact-span public trace, cinematic frontend, fallback behavior, tests, deployment checks and submission pipeline. I made the final product, design, safety and engineering decisions.
One useful example came from a real bug. I photographed the demo and noticed that the released sentence visually joined words together. Codex traced the cause to animated inline-block spans collapsing trailing whitespace, fixed rendering without changing the trace text, and added a browser regression that measures the actual geometry between adjacent words. A textContent assertion alone would have missed it.
Evidence
I keep three evidence categories separate.
Software verification: The public Build Week implementation passed 91 non-live tests. The Build Week verifier passed with 91 tests and one intentionally skipped live test. Ruff, Mypy and JavaScript syntax checks passed. Browser QA passed locally and on the public deployment at 1440×900 and 390×844 across ALLOW, QUALIFY, WITHHOLD, BYPASS/SAGA, exact word-spacing geometry, playback, reverse, scrubbing, reduced motion, failed-Canvas fallback, Details / Evidence, overflow and console checks.
Live integration proof: One Responses API request returned HTTP 200, requested gpt-5.6, returned gpt-5.6-sol, and matched the strict structured schema. Public deployment remains deterministic to prevent unrestricted API spending.
Earlier method evidence: An earlier bounded SAGA demonstration classified 28 of 30 cases into the expected action band (93.33%): PASS 10/10, REVIEW 8/10 and HIGH RISK 10/10. This was a limited demonstration of the broader SAGA framework—not a benchmark of this Build Week implementation or a general reliability guarantee.
PASS, REVIEW and HIGH RISK are not mapped directly onto ALLOW, QUALIFY and WITHHOLD.
The related public finding was: “Fluent chain-of-thought should not be treated as proof of validity when evidence verification is absent.”
SAGA Core versus SAGA Audit
SAGA Core acts before release. It asks what supplied material is allowed to support before a claim becomes output.
SAGA Audit examines output or near-output claims for over-authority and review risk.
This Build Week submission demonstrates SAGA Core through a public-safe resolver. The private SAGA resolver exists but is deliberately not published.
Potential impact
SAGA Core is aimed at developers building systems where a fluent claim can cause downstream harm: research assistants, enterprise search, compliance workflows, support tools, reports and agent pipelines.
The current demo does not claim to solve truth or hallucination in general. It demonstrates a narrower engineering principle: evidence status should constrain release, and that constraint should exist before output.
The public trace gives developers something testable. They can verify exact spans, evidence links, decisions and released text without receiving chain of thought or the protected production method.
What was added during Build Week
The repository existed before the event as a private shell with schemas, an adapter seam, placeholder components and redacted placeholder output.
The Build Week branch added the working public-safe resolver, real GPT-5.6 path, coded release gate, seven cases, failure behavior, versioned trace, cinematic interface, browser regressions, secure credential loading, hosted demo and submission assets.
Honest limitations
- The public cases are synthetic and bounded.
- The public demonstration policy is intentionally smaller than the private SAGA resolver.
- The system depends on supplied evidence quality.
- Live GPT-5.6 mode is intentionally not enabled on the public host.
- Enterprise ingestion, calibration, monitoring and private deployment remain future work.
Fast judge walkthrough
- Open https://saga-core-build-week-2026.vercel.app/.
- Run the default QUALIFY case and compare BYPASS with SAGA.
- Run ALLOW and WITHHOLD.
- Open Details / Evidence and run the matched-content reveal.
- Open the judge repository and follow the README to inspect or run the implementation locally.
Video: https://youtu.be/bT5WN8Nz50o
Contact: Angelina@nexus-ailab.org
Log in or sign up for Devpost to join the conversation.