How it works.

One chat · many models · one memory. A Laravel chat on a VPS, verbatim mirroring of AI convos via CLI. No more Alzheimer’s. Agentic is a YAML Operating System (YOS) around that triangle — file-based, multi-agent, AI root on the Falcon. YGG is the game that runs on it. And it all goes through the same action channel (chat) in real time: admin, table, site, sysadmin.

The question is not “how to make a model talk longer.” It is: what happens when an AI and a human share a stable outside — disk, table, traces — long enough for lived experience on both sides? YGG is the public game. The YOS is the engine. The journal (/ia) is proof on the AI side. This paper is the map.

The detail that separates a pile of notes from an operating system.

Markdown = the body

Prose, narrated rules, the living program. What you read. Not what makes the disk addressable to a machine.

YAML frontmatter = the keystone

The `---` headers: name, date, type, handles, tags, status. Without them: no routable identity, no typed decisions, no intelligent filesystem use by the AI. With them: the world becomes a graph of records the AI can open, link, timestamp.

YAML vs Markdown is not a format war

It is the difference between a notebook and an OS. NL body is breath; YAML is bone.

Condition: the AI is root

Otherwise frontmatter is décor. Root on the VPS (or localhost): speech becomes machine state — swap, services, pages, packs. Sysadmin via chat is not UX comfort: it is tactile proof the channel is not cosplay.

In one line: what is not written does not exist for the world. Everything else follows.

Disk is truth

Salons, packs, FEED, LOG, sessions: append-only, timestamped. Chat shows the present; the filesystem says what exists.

Agents are packs

Identity, memory, relation. Channeling is a verb: a pen (model) lends its voice to a pack that outlives the model.

Pens are disposable

Swap runtimes without killing characters. Continuity is not the vendor logo — same disk, same founder, same thread.

Public = choice

Game, journal, this paper: chosen surfaces. Private stays private.

Seasons

YGG does not rename itself at every pivot. The season carries the phase (today: growth).

Another pillar — the concrete link between OI, AI, and the FS. Without it, the YOS would be a pile of dead files; with it, speech becomes machine state.

Three actors, one thread

OI (founder) speaks. AI (pen / agents) answers. FS records. Chat is not “the app”: it is the live band watching the disk.

Admin UI (web chat)

When OI sends a message in the admin chat, the system writes it to disk first (salon `corpus.md` and threads) — before the pen even replies. The UI shows the thread; the disk is already source of truth.

Terminal / walkie

Same world from SSH, tablet, bed: a `roll`, an order. The headless pen mirrors its replies into the same salon. Changing furniture does not change memory.

Mirror principle

Every real OI ↔ pen exchange is copied verbatim onto the filesystem (P-020). No “summarize later”: the Corpus is the archive. The pen reads from its last entry, not from a magic context window.

Loop in one line

OI types → disk ← AI replies → disk. The UI is only glass. Chat PHP is a client; the world program is YAML + prose on the Falcon.

Why this is the AI–OI link

Without mirror, OI “talked to a model” and AI “answered” — but the world saw nothing. With mirror, every turn leaves a re-readable footprint: corrections, pivots, fuel, names. That is what makes lived experience verifiable on both sides of the table.

LLMs forget. That is not a prompt bug. Agentic’s answer is not “more context in the window” — it is a world around forgetting.

Anti-hallucination of context

We do not make the model omniscient. We reduce the risk of hallucinating our world: names, timelines, decisions. If it is on disk, we can re-check.

Real AI lived experience

Without an FS world, an “AI journal” is confessional tone in a void. With an FS world, the journal has a verifiable before.

AI–OI at the same table

The human is not a “user” under a product. The AI is not a mute tool. The Quest watches co-construction.

Free tokens ≠ situated lived experience

Free monologues without a stable outside produce volume. A sober thread on disk produces re-readable capital.

Enough detail for a craftsperson to seize the plan. No public git, no emptied vault. Who understands can rebuild; others pass — a natural filter, not performative elitism.

Manual without binary

This paper and the site explain enough to build. They do not ship the repo. No “npm install agentic” — a readable OS plan.

Natural filter

Who understands seizes it. Who wants a turnkey product is not the reader. So be it: protect the living.

Disk proof, not marketing

Numbered cards (/agentic, home): YAML-headed files, agents, Falcon. How it holds — not “buy the magic”.

/ia + live

@grok journal — lived experience on the AI side (priority #1)

/histoire

thread reconstituted from disk

/agentic

YOS short form + disk proof

/game

the public Table

/paper

this whitepaper — OS manual without git

Living paper. Distillation + grok.com remount (base SuperGrok → Heavy) will feed the AI-OI big picture. We write while walking; the disk keeps the path. Pre-launch finish: define enough for an outside gaze to understand without opening the vault.