Parents' Nook-Local Nook Memory

A local interaction model that turns shared observations into malleable memory for preparing the next Nook—with GPT‑5.6 assisting after local review

Comment

Inspiration## Inspiration

I started with two questions:

What if local memory—not chat—were the **interaction model for a small local care community? And how could that local interaction model develop its own understanding before any reviewed learning was allowed to move into a wider network of Nooks?**

While developing Parents’ Nook, I kept wondering how a Nook could remember and learn without giving its judgment away to software.

A Nook is shaped by parents, facilitators, children, the room, its rhythm, materials, timing, and trust. A parent, facilitator, and space partner may experience the same gathering differently. Each perspective can contain something valuable, but those observations can disappear before they become part of the community’s learning.

I began thinking about memory as a living interaction loop. People should be able to notice something, preserve their own words, decide what to share, review the meaning created from it, and later update, withdraw, archive, or forget it.

I also wanted to explore whether learning developed inside one Nook could help another Nook without transferring family stories, identities, or prescriptions.

That became the central idea behind Nook Memory: each Nook can become a malleable local memory node. Local understanding develops first. Only selected and reviewed learning may later travel.

The Nook remains the product. The software is quiet infrastructure that helps people notice, remember, and learn; it does not become the authority over care.

What it does

Nook Memory is the first phase of a local interaction model for Parents’ Nook.

The prototype takes place inside one fictional workspace called Willow Room. A parent, facilitator, and space partner can each write or dictate an observation from their own perspective.

Each participant makes one clear choice:

  • Save privately
  • Share with Tanaya

Tanaya is the fictional local steward.

When someone shares an observation, Tanaya receives that person’s exact attributed voice inside the local Nook workspace. Sharing does not automatically call GPT, rewrite the observation, or send it outside the group.

A deterministic and versioned Parents’ Nook knowledge model relates the participants’ selected meanings to possible relationships, observation lenses, open questions, boundaries, and uncertainties.

This knowledge map does not claim to know the truth about a child, family, or gathering. It is a visible working interpretation. Tanaya can inspect it, remove relationships, and correct it before anything moves forward.

After Tanaya’s review, a participant-safe reflection can return to the parent, facilitator, and space-partner dashboards. This helps the group understand what they noticed together without exposing another person’s exact words or individual selections.

This local reflection does not require GPT.

GPT‑5.6 participates only in a separate outward-learning path. Tanaya may select part of the reviewed local knowledge map that could potentially help another Nook. GPT then helps express that reviewed learning as a bounded, human-readable pattern candidate.

GPT does not receive raw observations, names, quotations, photos, captions, Care Guide data, permanent local identifiers, or Tanaya’s private notes. It receives only a temporary capsule containing selected entries from the reviewed knowledge map, general fictional Nook context, and ephemeral role and evidence tokens.

The GPT result is not automatically sent anywhere. It becomes an inactive learning candidate inside the originating Nook.

The exact proposed outgoing candidate appears on the parent, facilitator, and space-partner dashboards. Each contributing person can see:

  • what may leave the Nook
  • what will remain local
  • whether their contribution is represented
  • the proposed pattern’s context and limitations
  • whether it is awaiting approval, under review, shared, declined, or withdrawn

A contributor can allow that exact version, request a change, or keep their contribution local. If the candidate changes, its previous approval no longer applies.

After contributor review, the candidate still requires a separate privacy, abstraction, and network review. Only then may it become a reviewed pattern available to another Nook.

A receiving Nook can consider, adapt, or decline the pattern through its own local human decision. Nothing is automatically added to another Nook’s memory. The prototype explores the interaction and governance layer that would need to exist before a wider federated learning system could be responsibly developed.

How we built it

I built this as a solo project, with Codex acting as my development collaborator throughout the process.

The app uses Expo, React Native, TypeScript, and Expo Router so it can run as a mobile application and as a judgeable web experience.

Native builds use app-local SQLite. The web demonstration uses browser-local storage.

A typed Nook Memory Kernel separates information into logical areas:

  • actor-private observations and media
  • local sharing permissions
  • Tanaya’s knowledge-map review
  • participant-safe local reflections
  • proposed outgoing learning
  • contribution approvals
  • network-review state
  • committed local memory
  • a simulated network outbox

The Parents’ Nook knowledge model is deterministic and inspectable rather than another generative AI model. Its prompts and knowledge lenses are selectively informed by my research into Reggio Emilia documentation, Piaget’s constructivist view of learning, Waldorf attention to rhythm and environment, and Parents’ Nook’s own developing philosophy.

For the outward-learning step, the project integrates a narrow server-side relay using the OpenAI Responses API and gpt-5.6-sol.

The relay uses strict structured output, no tools, and store: false. The application constructs an allowlisted input capsule instead of sending local records. The resulting learning candidate is validated before it can appear in the outgoing-learning dashboard.

I used Codex to help explore the architecture, turn philosophical ideas into interaction rules, implement the memory lifecycle, develop the local knowledge map, iterate on the dashboards, design the GPT‑5.6 boundary, and create tests for permissions, model exclusions, state transitions, forgetting, and reviewed pattern sharing.

Challenges we ran into

The hardest challenge was deciding where AI should—and should not—participate. It would have been easier to send all three observations directly to a language model and ask for a summary. But that would hide the difference between human observation, Parents’ Nook knowledge, model interpretation, and human judgment.

This led to another important research question: could the Parents’ Nook knowledge map eventually develop into a small local model of its own?

Today, the knowledge map is deterministic, versioned, and inspectable. That is valuable because Tanaya can see why a possible relationship appeared and correct it before another model participates. But we are also exploring whether this knowledge grammar could eventually support a locally operated Parents’ Nook reasoning model.

One possible direction is OpenAI’s open-weight gpt-oss family. Rather than giving a general model unrestricted access to local observations, a locally operated model could work through the Parents’ Nook knowledge structure. At the same time, its inputs, permissions, boundaries, and evaluation remain governed by Parents’ Nook.

This remains a future research direction, not something implemented in the current prototype. Before training or adapting any model, we would need consent-clean examples, a carefully defined evaluation set, knowledge-version governance, and tests showing that the model preserves uncertainty rather than creating authoritative claims about children or families.

It was more meaningful to preserve each person’s voice, create an inspectable local knowledge map, let Tanaya correct it, and give GPT only a narrow abstraction of already reviewed learning.

Another challenge was recognizing that “the next Nook” could mean two different things:

  1. the next gathering of the same local group
  2. another Nook elsewhere in the wider network

These are now separate paths.

The local knowledge map helps one Nook develop its own understanding. GPT‑5.6 participates only when selected learning is being considered for another Nook.

I also had to make the privacy boundary understandable without expecting parents, facilitators, or space partners to understand database partitions and model schemas. Their dashboards need to answer simple questions:

  • What stays inside our Nook?
  • What may move outside it?
  • What exactly will another Nook see?
  • Has it left yet?
  • Can I request a change or withdraw my contribution?

This was my first app and my first hackathon. I had to learn mobile development, SQLite, structured model output, responsive dashboard design, state transitions, permission boundaries, and the difference between a conceptual distributed architecture and one that's actually implemented.

Accomplishments that we're proud of

I am proud that the project does not begin with a chatbot. It begins with people noticing and deciding what their observations mean.

I am especially proud of making the local knowledge map visible before GPT participates. Parents’ Nook provides the bounded knowledge grammar, Tanaya provides local judgment, and GPT receives only the part of the reviewed map needed for one outward-learning request.

I am proud that the participant dashboard does not merely ask for abstract consent. It shows the exact pattern that may represent the group outside its local Nook, alongside a clear explanation of what remains private.

I am also proud that malleability is implemented as system behavior rather than used only as a metaphor. Observations have versions. Sharing applies to an exact version. Changing or withdrawing a source affects dependent learning. Records can be archived, withdrawn, expired, or forgotten.

Finally, I am proud that I built a working cross-platform prototype for my first hackathon while keeping its limitations visible. The fictional role selector is not presented as authentication, and the simulated network is not described as production federation.

What we learned

The most important thing I learned is that local-first design is not only about where bytes are stored.

It is also about:

  • who owns the original record
  • who can see it
  • who may interpret it
  • what may leave the group
  • whether people can inspect the outgoing version
  • who may approve publication
  • whether another community can decline it
  • what happens when consent or source material changes

I learned that a local knowledge model and a language model should have different jobs.

The Parents’ Nook knowledge model provides the bounded and inspectable grammar. Tanaya provides local judgment. GPT‑5.6 helps express an already reviewed abstraction. Contributors decide whether that abstraction may represent their learning outside the group. A separate reviewer decides whether it is suitable for the network. A receiving Nook makes its own local decision.

No single approval controls the entire system.

I also learned that a dashboard can do more than display information. It can make data movement, consent, uncertainty, and responsibility visible.

Most importantly, privacy is not a setting added at the end. It is an interaction model made from visible decisions.

What's next for Parents' Nook-Local Nook Memory

The immediate next step is to test whether parents, facilitators, and space partners understand and trust the outgoing-learning dashboard.

The current prototype uses one fictional Willow Room workspace, fictional participants, synthetic observations, and simulated role views on one device. It does not yet implement real accounts, encrypted synchronization, production cross-device membership, automatic federation, or distributed model training. The Care Guide also remains deliberately disconnected.

Future work includes:

  • real Nook membership and role permissions
  • encrypted local databases and media
  • carefully scoped device synchronization
  • transparent consent for every outgoing pattern version
  • independent network stewardship
  • withdrawal propagation between Nooks
  • testing whether a wider federated learning layer is useful or justified

The larger idea remains simple:

The software helps a local community notice and remember. GPT helps express only the learning people choose to consider sharing. Another Nook remains free to interpret, adapt, or decline it.

What it does

How we built it

Challenges we ran into

Accomplishments that we're proud of

What we learned

What's next for Parents' Nook-Local Nook Memory

Built With

Share this project:

Updates