DEV Community: Paul Ayoade

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.