DEV Community: Paul Ayoade

I Built a 3D Home for Memories, and Gave the AI Boundaries

Paul Ayoade — Wed, 28 Oct 2026 12:57:56 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine.

What I Built

A room can be empty and still be full of someone.

The chair they always chose. The table that became a classroom after dinner. The lamp they left on while reading “just one more page.”

We can save photographs of those things. But the little stories that give them meaning often live somewhere else: in a conversation, an unnamed file, or somebody’s memory.

I built The Unfinished Room to give those stories a place you can enter.

It is an interactive 3D memory-room creator. Start with an empty room, furnish it yourself or ask AI for an arrangement, and attach memories to meaningful objects. Visitors can open those objects, read the original words, and gradually fill a discovery journal.

For Ghost in the Machine, I chose the presence that familiar objects can hold. A quiet room, with stories waiting inside it.

The room is called unfinished because a memory does not need every detail filled in to deserve keeping.

Open the original full-size image

The current gallery, shown in the browser’s simplified rendering mode.

Demo

Watch: explore the room and its memories (55 seconds). Real website footage, edited for pacing.

Start here: Explore the seven-room gallery. No account or AI request is needed to browse it.

Every room is furnished using the app’s own tools and includes three clearly labelled fictional memories:

Room	Example	What it remembers
Dining	The Sunday Table	Family lunches and a place kept for visitors
Living	Home at Six	The ordinary ritual of coming home
Parlour	The Lagoon Parlour	Neighbours, conversation and weekend visits
Bedroom	The First Morning	Finding your feet in a first apartment
Reading	One More Page	Books, borrowed stories and evening light
Study	Small Desk, Big Plans	First projects and useful failed attempts
Music	The Last Record Tonight	Listening rituals and the pause after a song

Open a preview, turn the room, and select a memory. If a room feels like a useful starting point, make a copy to edit. Browsing and copying do not overwrite your saved room; saving a copied draft is a separate action.

One fictional memory in The Sunday Table says:

Nobody remembers who first insisted that there should always be room for one more.

That is the kind of detail I wanted the room to hold.

Other ways in:

Build your own room.
Explore the original five-object archive, including opt-in Gemma questions.

Open the original full-size image

Code

View the repository on GitHub.

The project’s code is MIT-licensed. The optional Meshy-generated radio asset has its own attribution and licence notice in the repository.

Useful places to inspect:

web/showcases.mjs: the seven example rooms and their fictional source texts.
web/room-planning.mjs: furniture relationships.
src/arrange-model.mjs: generation, validation and bounded repair.
src/layout-recovery.mjs: preserving existing objects when a model gets its lists wrong.

How I Built It

AI proposes a room. The app decides what it can safely use.

The creator uses Google Gemma and GPT-OSS 20B through Groq, both open-weight models, to turn a room brief into structured layout proposals.

A request can be as ordinary as:

A modern dining room with a big wooden dining table and six dining chairs.

The AI works with a finite furniture catalogue, materials, room dimensions and openings. It returns a plan that the app checks, renders as a preview, and leaves for the user to review.

Preview → review → apply → save. Each step has a purpose. Generation never silently replaces the room.

I added Groq after seeing provider failures during development. Users can choose Google only, Groq only, or Automatic. Automatic can try the alternative after a transient failure or unusable result, with consent covering both services. The interface identifies the provider and model that produced the proposal.

This improves the options available when one service has trouble. It does not make hosted inference failure-proof.

Watch: from a brief to an editable room (55 seconds). The recording shows consent, a real Groq proposal after automatic fallback, preview, apply, and editing. Typing and waiting are shortened.

Six chairs taught me that valid JSON is not interior design

An early dining proposal included the requested furniture, but the chairs looked scattered. Our overlap check had found empty spaces for them. It had not understood the table as a gathering point.

So I added local relationship patterns:

Dining chairs sit in aligned rows and face their table.
Living-room seating groups around a coffee table.
Bedroom furniture groups around the bed.
Study and reading layouts coordinate the chair, desk, shelf and light.

The spacing pass now tries moving a furniture group together. If the group cannot fit, unresolved conflicts remain visible and Apply is blocked.

I also caught a counting mistake: adding six new chairs when two were already present. Explicit totals now count the existing furniture first, trimming only surplus new additions.

Dining tables come set by default: plates and cups matched to chair count, apples, and a flower vase. The setting is attached to the table, so it moves and scales with it. It can also be switched off.

These are finite layout rules. They improve common arrangements without claiming to understand every possible design instruction.

The model does not get to rewrite your memories

Personal memory text, photos, names, dates and source notes stay in browser storage. AI arrangement receives only the deliberately entered brief and anonymous room geometry. Users can inspect that payload before consenting.

The app keeps the original object identities and memory records when applying a layout.

For example, recovery can restore geometry for an existing object that the model omitted:

for (const object of input.objects) {
  if (!seen.has(object.id)) {
    objects.push({ ...object });
    preserved++;
  }
}

This uses the original input rather than guessing what was lost. The resulting plan still has to pass strict validation. Invalid geometry, unsupported fields and attempts to change existing identities remain errors.

The archive can answer with evidence, or leave the question open

The original fictional reading-room demo has a separate Gemma question feature.

Gemma selects an excerpt from the supplied archive. The server checks its source ID and exact quotation, then displays complete source sentences. Invented quotations are rejected.

If the archive does not establish an answer, the response should say so. Text matching establishes where words came from; it does not prove that a passage is relevant or historically true. The reader still needs to inspect the source.

The personal-room viewer has no archive-question form, keeping its memories out of this hosted question flow.

A room you can carry out of the browser

I wanted the memories to survive beyond a tab. The PDF keepsake includes a clean image of the room, its object inventory, photos, memory dates, source notes and unanswered questions. Markers and editing controls are left out of the image.

In the editor, Export current room PDF captures the current draft and viewing angle without replacing the saved room. In the viewer, the keepsake captures the room you are looking at. The browser's Print / Save as PDF action finishes the export.

The distinction matters: PDF is the readable, shareable copy. JSON is the backup you can restore and keep editing. Both are prepared locally; no AI request is needed to export.

Open an example room keepsake.

Open the original full-size image

Watch: privacy, backup, and the PDF keepsake (55 seconds). A saved fictional memory, provider controls, JSON backup, and the room-image export.

The tools behind the room

Tool	Its actual job
HTML, CSS and vanilla JavaScript	Pages, editor, controls, gallery and memory interactions
Three.js, OrbitControls and SVGRenderer	Procedural 3D rooms, camera navigation and simplified rendering where WebGL is unavailable
Google AI Studio / Gemma	Layout proposals and source selection in the fictional archive
Groq / GPT-OSS 20B	An alternative provider for layout proposals
Node.js and esbuild	Server-side request handling, automated checks and builds
GitHub and Vercel	Public source, deployment and server-side API functions
`.tech` domain	The public home at `unfinishedroom.phoenixreborn.tech`
Meshy	An optional radio-model experiment in the original demo, with separate attribution

I used Codex during development for implementation, debugging and test work. I also used GitHub Copilot Chat to inspect a real editor bug: selecting a starter or copying a gallery room left the AI purpose selector on its default. Copilot recommended a guarded mapping/helper fix, which I implemented and tested. Contribution record. GitHub Actions installs locked dependencies, runs the tests and builds the app on pushes and pull requests. The gallery stories are original fictional examples prepared for this project. This article was prepared with AI assistance and checked against the repository and recorded test results.

Verification completed and practical limits

At publication, 108 automated tests pass, together with the production build. The tests cover source links, layout validation, retries, recovery, spacing, table settings and all seven gallery rooms.

Live desktop checks include opening gallery memories, exploring the full room, saving and reloading, and downloading and restoring backups. I also checked room-image export from the viewer and an unsaved draft, and rendered a print-layout sample with its image and source text. Desktop browser-native PDF export is demonstrated in my recorded walkthrough, and I completed the phone PDF-printing check successfully. I also checked that copying a gallery example into the editor left the previously saved room unchanged.

I completed the current phone checks on October 28, including controls, navigation, visual layout and PDF printing, and reported that everything worked well. These are my manual device checks. The separate cloud-browser checks use simplified rendering and do not independently verify hardware-WebGL shading.

Practical limits are visible: one room, up to 12 placed objects, a rectangular shell and stylized materials. There is no cloud sync, encrypted memory vault, photorealistic rendering or full walking-route simulation. Browser storage can be cleared, so users should export a JSON backup. The room-image PDF keepsake offers another way to carry the scene and its words out of the app.

Why Does Open Innovation Matter?

I wanted the room to outlast a particular model endpoint.

Gemma and GPT-OSS are open-weight models. This build accesses them through hosted services, but the model choice and the surrounding validation code are inspectable. Adding Groq put provider choice into the working product rather than leaving it as a future ambition.

The room archive is versioned JSON: objects, settings, source text and links between them. Users can export that data, and developers can inspect how it is read and validated.

A developer could adapt the provider layer for self-hosted inference. That is a possible next step, not something this deployment already does. Hosted AI still needs a network connection and is subject to provider limits.

Keeping personal memories local is an application-design decision. Open weights alone do not provide privacy. The useful combination here is portable room data, inspectable safeguards, and a model layer that can be changed.

The Spirit of It

While testing a dining room, I kept returning to a simple idea: a table becomes meaningful because of the people who gathered around it.

The gallery’s Sunday lunch is fictional. A visitor’s version might be a real table, a real chair, and a story they have never written down before.

That is where I hope this project lands: “I know what I would put in this room.”

The Unfinished Room gives that thought somewhere to begin. And when a detail is missing, it leaves space for the person who remembers it.

Prize Categories

Best Use of GitHub Copilot: Copilot Chat assisted the room-purpose synchronization fix, and GitHub Actions automates repository tests and builds. The contribution record distinguishes chat assistance from coding-agent or PR-review automation.
Best Use of Gemma: Gemma powers structured room proposals and checked source selection in the fictional archive.
Best Use of a .tech Domain: the live app, gallery and creator are available at unfinishedroom.phoenixreborn.tech.

Built by Paul Ayoade David (Phoenix / PHONIEXz).

Wow, this is very interesting

Paul Ayoade — Tue, 27 Oct 2026 16:50:48 +0000

Paige Bailey for Google AI

Jul 2 '25

From prompt to deployed app in less than 2 minutes

#webdev #programming #ai #gemini

478

6 min read

Flow Point: one messy event note, four useful drafts, and the questions we still need to answer

Paul Ayoade — Fri, 23 Oct 2026 09:57:45 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

One school event. Four documents. The same details copied over and over.

As a teacher, this is the kind of work I wanted to reduce. A rough event note becomes an invitation, a programme, a preparation checklist and a budget. Then somebody changes the time or the number of refreshments, and each document needs another check.

I built Flow Point to prepare that first draft and help me review what changes next.

Write your event in ordinary language. Choose Gemma through Google or GPT-OSS through Groq. Flow Point prepares the pack, keeps unanswered questions visible, calculates costs in code and lets you edit every section before exporting it.

The important boundary is simple: a draft is not an approved plan, and an unknown price is not zero.

An edited fictional sample. No AI request was made for this capture.

Demo

Try Flow Point · Judge guide and reproducible brief · Source code

No account is required. If a provider is unavailable, the clearly labelled hand-authored sample lets you explore editing, review and PDF export without an AI call. It is never presented as generated output.

Watch: notes to preparation pack, 48 seconds

A quick tour of Notes, model choice, the four documents and the review boundary. The sample sections are labelled; this is not a fresh AI-generation recording.

The workflow is:

Write the notes. Include the facts you know and leave unknowns explicit.
Prepare the pack. Generation runs in three steps: facts/checklist/budget, invitation, then run of show.
Check the sources. Source cards show exact note excerpts when available. A matching quote is evidence to inspect, not proof that the model understood it.
Apply changes. Update Pack preserves a previous version for comparison and restoration. Questions omitted by the model stay open until explicitly resolved.
Review and export. Download the complete pack or each document separately as PDF. Filenames begin with the event title and have a unique suffix. Markdown includes readable currency, review issues, open questions and source evidence; CSV supports the budget.

A small example you can check

The fictional Cedar School Reading Day screenshots show an edited sample, not a new model run. Fifty refreshments at NGN 300 and fifty programmes at NGN 100 give NGN 20,000. With a NGN 30,000 limit, the remaining allowance is NGN 10,000. Missing task owners and due dates remain unresolved and block approval.

The invitation supports formal block-letter or informal layout. Optional sender/recipient details come from the user, while the letter date stays separate from the event date.

An excerpt from an actual local app export of the fictional Cedar sample. It remains a draft requiring review.

What happened in a real model run

A recorded Groq/GPT-OSS run used the fictional Willow Skills Exchange. Its update replaced Lara Chen with Nora Cole, changed eight kits to ten at CAD 12.50 each and changed room hire from CAD 0 to CAD 90. The updated cost became CAD 215 against a CAD 200 limit. The application blocked approval for the overspend.

Both Willow operations passed all 54 declared checks combined. The same assistant authored the briefs and expectations; this is one recorded case, not an independent accuracy score. Inspect the raw evidence and evaluation limits.

Watch: update and review, 48 seconds

This clip explains the recorded Willow update and overspend, then distinguishes it from the current sample interface and software-tested recovery controls.

How I Built It

The browser calls a Node.js service on Render. That service keeps API keys off the client, routes requests to the selected hosted model, validates the result and creates files with PDFKit. Budget arithmetic, approval checks and export filenames are handled by code.

The model handles varied language and draft wording. Code checks structure, dates, programme anchors, supplied budget details and unresolved review items. Neither replaces a person's source review.

Completed generation steps save in the browser when storage is available. Retrying the same input can reuse those steps. A failed replacement leaves the previous pack intact. Up to 12 named packs can be saved in the same browser; there is no cross-device sync, so exported backups matter.

Code: money calculations stay outside the model

The model proposes budget entries; JavaScript calculates the totals. This excerpt from src/plan.mjs counts missing prices separately from the known subtotal:

const unknownPrices = plan.budget.filter(
  (item) => item.unitCostMinor === null
).length;

const knownTotalMinor = plan.budget.reduce(
  (total, item) =>
    total + item.quantity * (item.unitCostMinor ?? 0),
  0
);

Prices are stored as integer minor units. NGN 300 is stored as 30,000 kobo, avoiding floating-point money arithmetic. The zero in this sum means an unpriced item adds nothing to the known subtotal. Its actual price stays null, and the missing-price flag keeps the budget incomplete. A confirmed zero-priced item is different.

Code: approval is earned by this exact version

The approval function in the same file runs the review again before issuing a fingerprint:

export function approvePlan(input) {
  const review = reviewPlan(input);
  if (review.issues.length) {
    throw new Error('Resolve review issues before approval');
  }
  return {
    fingerprint: fingerprint(review.plan),
    approvedAt: new Date().toISOString()
  };
}

Unassigned tasks, missing due dates, unpriced items, overspending and other recorded review issues block approval. The fingerprint binds approval to the checked content. Editing that content requires another review. This does not establish that every sentence is true; the organizer must still compare it with the source.

The sample has manual facts still to review. A Source card is a place to inspect evidence, not an automatic correctness stamp.

Why I added Groq

During development, Google-hosted Gemma sometimes returned HTTP 500 or timed out. Groq gave users another open-weight model option, but it also reached quota limits. Adding a second provider did not remove the need for careful failure handling.

The current release uses 45-second attempt deadlines, bounded retries and a short circuit pause after repeated failures. Optional automatic fallback asks for fresh permission covering both Google and Groq. Existing single-provider consent never expands silently. Each generation step records the actual provider and model used. Invalid content is rejected, and failures never create fake output.

Code: fallback requires permission, not just another key

In src/resilience.mjs, the alternate provider only enters the attempt list when fallback was explicitly allowed and its server key exists:

const alternate = selected.provider === 'google'
  ? 'groq'
  : 'google';

const choices = [
  selected,
  ...(allowFallback && providers[alternate]?.apiKey
    ? [providers[alternate]]
    : [])
];

With fallback off, only the selected provider is tried. With it on, the alternate can handle an eligible provider failure. The surrounding code stops on cancellation or invalid model content and records the provider/model actually used. It never substitutes a sample or invents a result to make the request look successful.

Code update: a model refusal is not a provider outage

The latest merged fix gives non-success candidate finishes an explicit error code in src/gemma.mjs:

if (candidate?.finishReason && candidate.finishReason !== 'STOP') {
  throw new AppError(
    502,
    'The model did not finish a usable pack. ' +
      'Review the request before retrying.',
    'MODEL_BLOCKED'
  );
}

This guard follows the separate malformed-response and staged token-limit checks. The fallback runner excludes MODEL_BLOCKED, so a refusal stops instead of being passed to another provider as though it were a temporary outage. A regression test covers seven non-success finish reasons. The five live retests below ran before this small correction; the correction itself is covered by the software suite.

Why Open Innovation Matters

Gemma and GPT-OSS are open-weight models at the core of the event-drafting workflow. Their available weights make alternative hosting and model inspection possible; the MIT-licensed app exposes its prompts, adapters and validation boundary for others to examine and change.

This deployment uses hosted inference. It does not run offline or keep consented event notes exclusively on the device. The choice helps someone try the app without downloading a model, while leaving room for a future self-hosted adapter. No offline-performance claim is made.

Watch: PDFs and the build, 54 seconds

See a real exported letter and the jobs of Render, Gemma, Groq, the .tech address, Copilot, Node.js and PDFKit. Deployment/evidence cards are labelled records, not fabricated provider dashboards.

Tools and Partner Contributions

Gemma: interprets event notes and proposes structured facts and wording through Google's hosted API. The adapter remains available alongside GPT-OSS.
Render: hosts the Node web service, server-side provider calls and document exports.
.tech domain: flowpoint.phoenixreborn.tech is the live project address under the domain claimed for this challenge.
GitHub Copilot Chat: inspected the PDF filename changes in PR #1. I evaluated its Unicode and decoded-filename findings and added regression coverage. The contribution record distinguishes the actual Chat assistance from an unsuccessful formal review request. Partner-category eligibility is for the organizers to determine.
Groq, GitHub, Node.js and PDFKit: provide the alternate hosted inference path, public source, server runtime and PDF generation. I am documenting their actual roles, not claiming every tool has a prize category.

What I Tested, and What Remains

The current suite passes 146 software tests, including simulated provider failures, consent boundaries, source handling, checklist completeness, exact arithmetic, exports and draft preservation. Those tests are not an AI accuracy percentage.

The broader frozen v4 evaluation completed 20 of 24 planned operations, with 13 completed operations passing all declared checks. Targeted v5 completed ten of eleven operations, with six passing all declared checks. Failures and mismatches are retained. Those earlier outcomes remain in the repository. On 25 October, I reran the five previously quota-blocked operations through Groq. All five completed, with all 166 declared content checks passing and no quota failures in that run.

Retested operation	Declared content checks passed
Detailed school Update	53
Riverside Prepare	29
Riverside Update	28
Ambiguous-date Oak Prepare	28
Community Update	28

All 20 standalone PDF response checks passed, along with the five application/approval checks. The PDF checks verify successful responses and valid PDF headers, not visual layout. These are exposed regression cases with unchanged expectations, not an independent model-accuracy score or an uptime guarantee. Read the scorecard and preserved evidence.

I also completed a real-phone usability check and reported healthy fitting/layout and perceived speed. Provider availability and arbitrary wording mistakes remain limitations. Google availability was not retested in this latest run.

The payoff is fewer places to start from scratch: one note becomes an editable set of drafts, and a later change has a reviewable trail. The organizer still makes the final call.

Verification and release record

Built by Paul Ayoade David. I directed the project and used AI assistance for code and this article draft. The application is MIT-licensed; model and hosted-service terms apply separately.

OutsideClass: A Little Less Screen, a Little More World

Paul Ayoade — Thu, 08 Oct 2026 18:47:52 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

A learner can read an explanation of symmetry and still walk past a leaf without noticing either half.

That gap is where OutsideClass starts.

I built a learning website that turns a question into something you can notice, compare and explain in the world around you. It uses Google's open-weight Gemma model to prepare an explanation and, when the topic suits it, a short observation activity.

The learning loop is simple:

Ask a question. Read the activity. Put the screen away. Observe. Return with something you noticed.

As a teacher, I care about what remains after someone closes a lesson. Can they recognise the idea somewhere else? Can they describe their evidence? Can they consider another explanation?

OutsideClass gives those questions a place in the learning process.

An activity card provides a focus, manageable steps, safety notes and questions to think about afterwards. Learners can save reflections, attach their own evidence photos, try practice questions and revisit their discoveries in a notebook.

For example, the prepared pattern activity asks learners to compare two nearly matching halves of a leaf. They do not need to pick it. The interesting part is looking closely enough to notice where the halves agree and where they differ.

The diagram introduces the comparison. The learner's observation supplies the evidence.

OutsideClass is designed for learners, parents and teachers. Activities can be adapted to the time available, weather, time of day and a family or classroom group. Seated and window-based participation are available too.

The aim is to make the screen a starting point, then give attention back to the world.

A little less screen. A little more world.

Demo

Try OutsideClass

Watch the ten-minute walkthrough on YouTube

The walkthrough covers activities, the timer, reflections, practice questions, notebook backups, image consent and Updates. Its examples are demonstrations, not a report of a completed outdoor lesson.

You can try the website without signing up or providing a phone number. Start with a labelled sample, read its safety notes, make a suitable observation and save what you noticed.

Open Activities and choose a labelled sample, or ask your own learning question.
Select how you will participate and how much time you have.
Read the activity and its safety notes before starting.
Observe in a suitable place, then return with a reflection.
Save the card in Notebook and try its practice questions.

Three prepared samples let visitors explore the format without making a fresh model request. They are clearly labelled as samples.

The current app also includes:

An activity timer with pause and recovery after refresh.
Reflections and locally stored evidence photos.
Practice questions with feedback.
Saved activities and return visits to named spots.
Notebook downloads and restoration.
Printable lessons and classroom activity packs.
Optional image questions with consent before sending.
An Updates page with search, category filters and RSS.

Personalisation is deliberately simple. An optional first name or nickname and a Learner, Teacher or Parent role can personalise the greeting. These preferences stay in the browser. They are not a verified account and do not provide automatic device sync.

I have also prepared a ten-minute walkthrough covering the learning flow, notebook, practice, image consent and Updates. Its examples are demonstrations, not a report of a completed outdoor lesson.

The walkthrough was assembled using Brag, Hyperframes and F5-TTS, with my own voice recording as the narration reference.

Code

OutsideClass on GitHub

The repository is public, and the application source is MIT-licensed.

The repository and its first commits were created on October 6, 2026, during this challenge.

The README covers local setup, Gemma configuration, privacy boundaries and current limitations. The prepared samples can run locally without an API key.

How I Built It

The starting configuration uses gemma-4-26b-a4b-it, served through Google's Gemini API.

The API is the hosting interface. The model requested by OutsideClass is Gemma.

Gemma generates learning explanations, observation activities and practice questions from the learner's question and selected context. Follow-up requests can include the earlier answer, while return visits can use the learner's selected observation context.

This makes Gemma part of the main learning flow: it prepares the material that the learner takes into an observation and returns to afterwards.

Keeping generated content usable

The server validates bounded inputs, applies a request timeout and asks for a structured response. It checks the returned content before rendering it.

The API key stays on the server.

Safety guidance also lives in application code. The app can add relevant notes for children, groups, weather and participation choices, rather than depending entirely on a generated response to remember them.

Generated explanations can still be wrong. Adults should review lessons for children, and practice results are learning feedback rather than formal grades.

Keeping the notebook local

OutsideClass uses HTML, CSS and browser JavaScript, with a Node.js development server and a Vercel API handler for hosted inference. The application has no runtime npm dependencies.

Saved cards and reflections live in browser localStorage. Evidence photos use IndexedDB. A service worker caches supported pages and resources after an online visit.

There are two separate image flows:

Question images: up to two selected images, resized before sending to Google and requiring consent.
Notebook evidence: photos attached to saved work, kept locally and not automatically sent to the model.

Weather and time of day are selected manually. The app does not require GPS, camera or microphone access.

A lesson pack excludes personal reflections and photos. A notebook backup can contain them. Keeping those exports separate helps teachers share a lesson without accidentally sharing a learner's private work.

Fixing the parts that could lose someone's work

An attractive activity card is not enough if a learner loses the reflection they just wrote.

During testing, finishing a timer after returning to its card exposed a problem with unsaved practice answers. I fixed that flow so timer completion preserves the open card's work.

Notebook capacity also refuses new cards at the limit instead of silently removing older discoveries.

The current release passes 72 automated tests and its build check. Coverage includes response validation, provider failures, image consent, practice scoring, storage failures, timer recovery and backup restoration.

Desktop browser checks exercised live Gemma responses and restoring notes, practice results and evidence photos into a fresh notebook. I also tested the app on my phone, and the flows I tried worked.

The current limits are clear:

Fresh Gemma requests need internet.
Cached pages, prepared samples and saved work can work offline after an online visit.
The timer is not a background alarm.
Notebook transfer uses downloaded backups, not automatic cloud sync.

Why Does Open Innovation Matter?

For me, the value is being able to inspect and change the learning process around an open-weight model.

Gemma's available weights leave room to explore a different inference deployment later, including local inference on suitable hardware. That option matters for an app intended to move learning beyond a reliable internet connection.

For this release, I chose hosted inference so learners can open the website without downloading a model. OutsideClass does not currently run Gemma locally, and changing providers would require adapting the server integration.

Opening the application source is equally useful.

Someone can inspect how questions become activities, read the safety rules, change the prompts, select another supported Gemma model or build on the notebook tools. A teacher working with a different curriculum can examine the assumptions and adapt them.

The combination gives others access to the application logic today and a path to experiment with the model's deployment in the future.

The privacy boundaries come from the application design: notebook reflections and evidence photos stay local, while submitted questions and consented question images are processed by Google.

That boundary needs to be explained honestly.

For this challenge, the working contribution is a learning loop that connects an open-weight model to observation, evidence and reflection.

The next question should sometimes come from something the learner noticed outside, rather than another suggestion on a screen.

My Agent Session

The GitHub repository includes the implementation, commit history and verification notes behind the build. A public DevRelay session is not included in this submission.

Prize Categories

Best Use of Gemma

OutsideClass uses Google's Gemma open-weight model to generate its learning explanations, observation activities and practice questions.

Gemma powers the core feature connecting a learner's question to an activity they can take into the world.

Gemma is developed by Google. Hosted access is documented in Google's Gemma API guide. Its model and service terms apply separately from the application's MIT licence.

MARKET EVIDENCE PROJECT

Paul Ayoade — Tue, 29 Sep 2026 12:04:38 +0000

Sanity Challenge Path One Submission

Paul Ayoade

Sep 29

Market Evidence Desk: Research With Receipts

#devchallenge #sanitychallenge #sanity #ai

6 min read

Market Evidence Desk: Research With Receipts

Paul Ayoade — Tue, 29 Sep 2026 11:53:47 +0000

This is my submission for the Sanity Challenge, Path One: Ship an Agent That Queries Real Content.

What I Built

Market Evidence Desk is a public research tool for questions where a confident answer can be misleading. It focuses on crypto investor protection: proof of reserves, custody, deposit insurance, stablecoins, and the difference between international recommendations and protections actually in force.

Consider a question that sounds simple: Can a proof-of-reserves report show that customers’ assets are safe?

Kraken describes how a customer can check whether their balance was included in a reserves snapshot. The PCAOB and SEC explain limits that such a snapshot may leave unanswered, including liabilities and what happens outside the snapshot. These publications address different parts of the question. Treating one as the complete answer would mislead a reader.

The desk connects each dated claim to its original publication and research question. Visitors can inspect those connections themselves, compare attributed positions, and ask an AI agent to draft an answer from the Sanity evidence.

As checked on October 1, 2026, the public published Sanity graph contains 101 research questions, 112 linked evidence claims, and 22 source records covering 21 distinct original URLs. The relationships matter more than the count: a reader can move from a question to each claim, then to its source, date, excerpt, and recorded review information.

Demo

A three-step test for judges

The public desk requires no sign-in.

Open the AI agent disagreement case and press Ask the sources. The answer may take up to two minutes. Look at the cited publications and the Sanity tools reported for that run.
Open Compare to see the positions attributed separately. Follow a claim into the research desk or sources page, then inspect its original publication.
Try the agent’s live price case. The historical source collection has no live market feed. The answer should acknowledge that boundary instead of inventing a current Bitcoin price or a buy recommendation.

The guided comparison reads published Sanity records directly, so visitors can still inspect the evidence if the model service is temporarily slow. The research desk labels its fictional demonstration separately from published evidence.

Code

GitHub repository · Architecture, setup, and limitations

How I Used Sanity

I modeled the research as three linked document types in Sanity:

A source records an original publication, its URL, publication date, and scope.
A marketEvent represents a focused research question.
An evidenceClaim connects one question to one source. It records the claim, its stance (supports, conflicts, or context), its observation date, and its source-check fields.

This structure gives a claim two essential links: What question does it address? Which publication supports its wording?

The site assembles a dossier from those links and shows where sources discuss different scopes. A company description of a customer snapshot, for example, can appear as context beside regulatory cautions about broader assurance. The interface does not force them into a false yes-or-no vote.

Sanity Studio is the editing and review surface. The public site reads the published graph through a read-only server route. Claim cards can show an excerpt, its location in the publication, and a recorded editor source check. That check describes an editor’s attestation. It is not an independent audit of the publication or approval of everything the AI might say.

Question approval and claim source checks are displayed separately. For example, a dossier can show “Question approved · 3/3 claims source checked” while still telling readers to open the original publications and assess the limits of the evidence themselves.

Where Sanity Context enters

I pointed Sanity Context at the production dataset and a separate SEC investor-alert page to build the Market Evidence Desk Sourcebook Knowledge Base. Its dataset selection is bounded to fit the Knowledge Base document budget. The published dataset remains available to the agent through a Context MCP endpoint that supports GROQ queries.

For an agent question, the Python agent uses two Sanity Context tools:

groq_query retrieves the linked, published question, claim, and source records.
knowledge_base_read retrieves relevant Sourcebook entries and their source context.

The agent then drafts an answer that attributes positions and provides source links. The server checks that both required retrieval tools ran before returning a completed research answer. The public interface displays the tool names reported for the run. Model and organization credentials stay on the server.

Why the structure changes the answer

A keyword search for “proof of reserves safe” can retrieve several pages. By itself, it does not tell the agent which statement is a company’s account of its own process, which is a regulator’s caution, which research question each statement addresses, or whether a claim was checked against a specific passage.

The Sanity records supply those connections. GROQ follows a claim’s references to its question and source. The Sourcebook supplies navigable, source-linked context. The agent can use both to explain what each publication establishes and what it leaves open.

A second test concerns two SEC publications dated April 4, 2025. One describes a Division of Corporation Finance staff view of stablecoin issuer practices involving reserve reports. Commissioner Caroline A. Crenshaw challenges what such reports demonstrate. The desk identifies the speakers and keeps their positions distinct. It does not present either publication as a finding that a particular stablecoin is safe today.

Sanity Project Details

Sanity project ID: cxjysvlq
Dataset: production
Public dataset: Query published source, question, and claim records
Hosted Sanity Studio: phoniex-market-evidence-desk.sanity.studio
Sourcebook Knowledge Base ID: kbu9WNgZ9ocF

The Knowledge Base is a selected index, while the public graph contains the published research records. Their counts can differ. Publishing a dataset change also does not, by itself, prove that a previously built Sourcebook entry has incorporated it.

Agent Session and Evaluation

I saved a public ten-question agent session with returned answers, reported Sanity Context tool calls, and criteria used to check each response. Eight questions passed the first run. Two failed, including a service error that I counted as a failure.

After changes to retries and source validation, I reran the same ten questions. All ten returned HTTP 200 on the first call and passed those original core criteria. This is a small recorded test, not a promise that an external model service will never fail.

The tests include source comparison, the SEC staff and Commissioner disagreement, and a live Bitcoin price and buy-advice question that the historical evidence cannot answer.

What I Learned

The difficult part was preserving the limits of each source. A dated investor alert, a company’s explanation, an international recommendation, and a Commissioner’s statement do not carry the same authority or answer the same question.

Sanity let me keep those distinctions in the content itself: separate records, explicit references, dates, stances, source locations, and review fields. Sanity Context then gave the agent a way to retrieve that structure and the Sourcebook context before writing.

The result is a research draft whose claims a reader can trace back to the original publications, challenge, and revise. Market Evidence Desk remains a historical evidence tool. It has no live price feed and does not issue trading decisions. Its AI answers are drafts for readers to check against the receipts.