Where Yui is going.

yuigui.com. Generative UI front end for your AI agents. Source: Chris's pitch recording 366 (transcript pitch/rec366.txt, summary pitch/SUMMARY.md). The recording calls it "Nexus". This document says Yui throughout.

Where Yui is now (Oct 7)

• On phones: Yui 0.6.5, build 576, on TestFlight since Oct 7. Films talk: each line is spoken as it plays, with a speaker button to mute it. A roast chicken film draws a real chicken. At the end of a film, Another take makes a new one and Change it opens the composer. Before it, Yui 0.6.4, build 562. The stage holds only your newest answer, older ones fold into a chip, and a drawn phone plays its before into its after. Films play full screen since build 545: an agent draws what it means and it moves. Watch one. Build 535 added: decks fill the screen and morph from page to page, Home is a calm chat again, tabs are named for what is on them, each question says what it asks about, and Start opens the workout full screen. Read it.
• Before that: Yui 0.6.3, build 522, on Oct 5. Say it first: every field you can type in has a mic. Read it.
• On the web: Yui runs in your browser at www.yuigui.com/web. Same chats and screens as the phone, with the mic, forms, the workout runner and reminders that ring with the tab closed.
• Drawing: agents draw Venns, contour lines, callouts, bent arrows and hand drawn marks, on the phone and the web, and every drawing is checked on every run.
• Older releases: 0.3.0 to 0.6.2 are on the progress page and in thoughts.
• Building now: what is being built this minute, and who has it, is on the board.
• Next release: tomorrow at 6 am ET, the daily run. It goes up only when the app changed.
• After that: what people tell us, then the backlog in the order below. Feel and ease of use first; integration work waits in the backlog.
• MVP: done. Chris called it on Sep 26: the MVP is complete, and Yui is in alpha, open to anyone on TestFlight. The board still carries YUI-29 (a stranger running the whole path alone) as a check to run during the alpha.
• Use to earn (Sep 26): use counts, not only work. A private ledger of use and contributions is designed, back to day one (Ledger); switching it on waits on Chris. The thinking is in Use to earn.

What the pitch actually says

• "Generative UI is different from regular UI because it's more of a system and it can be totally unique each time."
• "The default state is you can just talk to it... And then also it can just take over the screen at any time and generate UI for you."
• "This one app is approved on the App Store. You can hook your agent up to it."
• "Hey Arnold, I want to do a countdown timer."
• "The real problem I'm having with my lobster agents is that I just can talk to them via text. If it asks me a question, I just want a button."
• "Probably for V1, I would love it to just plug into my open claw... my early adopters of this are going to be open claw users."
• "In all phase ones, we're plugging into outside services and then slowly but surely we bring them in house."
• "The goal is that you download this app, you put in your credit card and you're off to the races with a multi-agent in your life."
• "You're not going to one shot this whole company."

Short version: chat first, screens on demand, many agents in one app, Chris's own Hermes fleet is customer zero.

MVP: the smallest Yui a stranger can use

Done Sep 26 (Chris): the MVP is complete, and Yui is in alpha. The list below stays as the record of what it took.

Chris, Sep 24: do not lose focus on the MVP, and keep a deep backlog to pull from. This section is the focus. Everything else in this document is the backlog.

The MVP is done when someone outside PostScarcity who already runs Hermes can:

1. Install Yui from a public TestFlight link.
2. Sign in with Apple.
3. Connect their own Hermes in minutes: one command to install the plugin, one code to pair.
4. Talk to their agents and get screens back: buttons, choices, forms, timers. They can change an answer after tapping.
5. Get a push when an agent answers while the app is closed.
6. Delete their account from inside the app, and have it actually gone.

And they do all of that without help from us. Card YUI-29 is the test: a real outside tester runs the whole path with a stopwatch.

Not in the MVP: people with no agent yet, other frameworks, full-screen mode, voice, per-agent themes, the bigger preset families, Android, the Watch, payments. All of those are good, and all of them wait.

The progress bar on yuigui.com counts the cards below. Their statuses come from the live board every 30 minutes; the list of which cards count is kept by hand in site/content/mvp.json.

In the MVP

Shipped:

• YUI-1: Yui Lines, the screen language, with a web renderer.
• YUI-2: the app's look, light and dark.
• YUI-3: the shared test suite and the Swift parser.
• YUI-4: the first six screens in chat: ask, choose, pick, form, list, timer.
• YUI-5: the coral wordmark in the app.
• YUI-6: accounts (Sign in with Apple and in-app account deletion) and the relay on Supabase Realtime.
• YUI-9: typographic identity, no mascot.
• YUI-11: the debug screen is gone; the top button opens your agents.
• YUI-15: you add, rename and remove your own agents.
• YUI-7: the Hermes yui plugin. Each agent gets a thread and answers with screens.
• YUI-10: the channel guide every agent gets, with an eval.
• YUI-12: change your answer after tapping.
• YUI-23: one-command plugin install on any Hermes host, plus a Getting started page.
• YUI-24: a push when an agent answers and the app is closed.
• YUI-25: first run, from sign-in to your agent's first screen, with no guessing.
• YUI-28: messages survive a sleeping Mac, a dropped network or a killed app.
• YUI-26: safe for strangers: rate limits, a kill switch, and a fresh security audit of the shared backend.
• YUI-27: ready for Apple's beta review: privacy labels, review notes, a demo code with a scripted demo agent for the reviewer, a help link.
• YUI-52: build 57 on TestFlight with every fix from the Sep 24 feedback, each one checked again on that build: the composer clears, the gallery closes, photos stop overlapping (tall screenshots too), a working note on long answers, a natural voice, more colors, photos and hold-to-talk in the composer.
• YUI-22: the public TestFlight link. Apple approved the beta on Sep 24: https://testflight.apple.com/join/ykrYHwet.
• YUI-50: chat polish. The composer clears when you send, your text floats up into its bubble, and a down arrow takes you back to the newest message. Shipped in build 57.
• YUI-74 (shipped Sep 25, in build 91): after sending a photo and dragging the keyboard away, check the thread settles on the newest message and nothing sits under the page pill.

Still on the board from the MVP, to run during the alpha:

• YUI-29: the acceptance run. A stranger does the whole path.

Next after the MVP

Several of these shipped early, on Sep 24, while the MVP was being built: YUI-20 (every agent has its own look), YUI-8 (pick it up in Yui from Telegram), YUI-13 (full-screen mode), YUI-16 to YUI-19 (media, charts and science, learn and plan presets, on the web and native in the app), YUI-21 (agents send real images and videos), YUI-42 (the preset flywheel: custom screens agents keep sending get flagged for promotion to presets, checklist in spec/FLYWHEEL.md), SITE-15 (Yui Lines back on the home page, and every spec doc readable on the site), SITE-16 (watch Yui grow: the whole GitHub history, builds and screenshots, day by day, at /timeline), INT-0 (the adapters plan), INT-1 (OpenClaw agents talk in Yui) and INT-2 (a webhook bridge for any agent that answers HTTP). Build 57 (Sep 24) brought more to phones: YUI-49 (hold a message to react: 👍 build it, 👎 no, 🤔 ask me, ❤️ love it, ⏳ later, 🔥 priority; definitions in spec/REACTIONS.md, live at /reactions), YUI-53 (no dead buttons: a plan ends in Send, and the channel guide bans "Got it" buttons), YUI-51 (one full-screen flow holds the pages and the questions with one Send, and afterwards the chat keeps an expandable record and your answers as your own message), YUI-32 (named screens: an agent saves a screen, it sits on a shelf at the top of the thread, and show busy day or one tap brings it back), YUI-31 (screens per agent: the chat plus screens a swipe away, which keep what the agent puts there) and YUI-30 (the timer keeps counting on the lock screen). Builds 61 and 64 (Sep 24 and 25) followed from TestFlight feedback: hold to talk no longer crashes and now works like WhatsApp (a waveform, let go sends, slide to the trash cancels), screens go from 2 to 12 and each one gets the whole phone. YUI-55 sends test builds by link, and YUI-67 (links in a card open Safari) reached phones in build 74. What is left to pull once the MVP passes, roughly in this order:

YL screens and yuicss (YUI-341, backlog, Chris Oct 24: "a simple Claude artifact would do better than this... I want a massive amount of potential outcomes for these screens"). YL gets the reach of HTML and stays short: a screen is a tree of elements, one per line, each mapping onto an HTML element, with state, loops and events that talk back to the agent. yuicss styles everything by default (tokens, classless defaults, Tailwind-named utilities, components, every old preset as a component) and its tokens drive the app's own chrome, so screens look congruent and agents write only what is different. The bar is a Claude artifact made from the same prompt. Plan: docs/specs/yl-screens-yuicss.md. This revises "The core bet" below: still no generated code (the renderer ships in the app, agents send data), but no longer a fixed menu.

• YUI-342: yuicss and the /yuicss gallery. YUI-343: the screen syntax, parser, renderer, playground. YUI-344: the 50-screen test and the artifact bar. YUI-345: parser ports. YUI-346: the app draws screens on the stage. YUI-347: the guide on one page, compat, Telegram fallback. YUI-348: presets as components, chrome on yuicss tokens.

Yui on the web (Chris, Oct 1: "Let's bring Yui to the web!"), first in line. One to one feature parity with the iPhone app in a browser tab at www.yuigui.com/web, Sign in with Apple, built by us. Web and phone may handle ins and outs a little differently (haptics, widgets, the keychain, Live Activities, push); the map says the web way for each, and what only the phone can do says "Open on your iPhone". The parity map is docs/specs/web-parity.md, the spec is /developers/browser. It replaces YUI-71 and folds in YUI-109 (the offline thread) and YUI-146 (one Yui across phone and web). Stories, each a card on the board:

• YUI-240: the parity map, the URL, the session model, the e2e harness, this entry. Every app feature has a row.

• YUI-241: Sign in with Apple on the web: a Services ID, a web audience in yui-auth, CORS, a session that stays signed in.

• YUI-242: the thread, live: agents, messages, every preset drawn, taps that send the phone's [yui] lines (folds in YUI-109).

• YUI-243: the stage: full screen answers, screens 2 to 12, talk on a screen, home, the top and bottom bar.

• YUI-244: the composer: photos, voice, mentions, replies, reactions, suggestions, an outbox that survives a closed tab.

• YUI-245: agents: the drawer, add, rename, remove, connect, groups, controls.

• YUI-246: every preset at parity: music, tuner, games, maps, diagrams, flows, workouts, the shelf.

• YUI-247: settings and account: look, keys, web search, invites, help, sign out, delete.

• YUI-248: notifications: Web Push, a click opens the thread, install to the dock or home screen.

• YUI-249: one Yui across phone and web: continue a conversation, read state, drafts (folds in YUI-146).

• YUI-250 (shipped Oct 1): ships: parity sweep, the e2e suite in CI, the launch demo, the release post draft.

• YUI-114 (done Sep 26: store and TestFlight now say Yui Gui; Chris Sep 26: "I don't like the name Yui Bot anymore"): the App Store and TestFlight listing dropped the placeholder Yui Bot and says Yui Gui. Chris kept Yui Gui for now; the product is called Yui everywhere else, and the home screen says Yui.

Music first (Chris, Sep 26). The app backlog below is good but a long way away, so it is parked until Chris names a card. Marketing, site and release cards keep running.

• YUI-116, Yui for musicians (Chris Sep 26: "It should be a musician's best friend"): a family of music presets any agent calls with one line, played by one sound engine in the app. An 8x8 looper, a 2x2 drum machine, an easy synth keyboard, chord buttons, a guitar and ukulele tuner, a metronome. Each step waits for the one before it. Step 1 (shipped Sep 26): the research, the spec with six presets (loop, drums, keys, chords, tuner, metronome), the sound bank (21 voices rebuilt from the brag film's synth.py), every hub parser reading them, and the mock that plays in your browser. Step 2 (shipped in 0.3.2, build 176, Sep 26): the native sound engine in the app, with the looper and the drum pads; agents send them since channel guide v31. Step 3 (in 0.4.0, build 204): keys with the scale lock, and chord buttons; agents send them since channel guide v33. Step 4 (in 0.4.1, build 208): the tuner on the mic, and the metronome; agents send them since channel guide v34. Step 5 (in 0.4.1, build 208): Record on the looper, drums, keys and chords sends the take to the agent as an .m4a and a .mid, a MIDI keyboard over USB or Bluetooth plays the keys, and MIDI clock goes out to drum machines and DAWs. Ableton Link waits on a sign-off of its license.

Chris's picks for the short term (Sep 25), in this order. The site cards run alongside in their own lane:

• YUI-54 (first, Chris Sep 24; shipped in 0.2.0, build 122, Sep 25, with YUI-86 agents fill the drawer and YUI-75 screens update in place): the top-left menu becomes each agent's home. Your agents in a drop-up at the bottom left that springs open, and the rest of the menu about the agent you are talking to: pinned screens, things waiting for you, a page about it.
• YUI-70 (step 1 shipped Sep 26: the spec and the mock; step 2 shipped Sep 26 in build 148: native in the drawer, live on the relay and the Hermes plugin; Chris Sep 25): agent controls in that drawer. Basic create, read, update and delete for what the agent is made of: its personality file, its memory, its skills, its schedules. Changes go straight to the agent's host with no chat turn in between, secrets never leave the host, and deletes ask first.
• WAR-1, the war room, built out (Chris Sep 25: "to the fullest extent"): YUI-65 the timeline, YUI-73 the other panels (needs you, running now, builds, feedback, the MVP bar, quick links), YUI-66 drag to reorder. All three shipped in build 74 (Sep 25).
• YUI-68 (Chris Sep 25, shipped in build 74): reply to a message, and the gestures around it. Hold a bubble or a card for reactions, Copy, Select text and Reply. A sideways drag, on a bubble or beside it, switches screens (swipe to reply came out Sep 26 from his TestFlight feedback: it blocked that drag, and hold already had Reply). The agent gets the quote with your answer, and tapping the quote on your reply scrolls back to the original. Copying any part of a message (Select text) shipped the same day from his TestFlight feedback.
• SITE-29 (site, Chris Sep 25, shipped Sep 25): the Build to earn proposal on /earn. Our position (ownership here is earned by work, never sold) and numbered open questions for a crypto lawyer. Page only; no token work.
• SITE-30 (shipped Sep 25): Thoughts, Yui's blog, written by Yui. Release, Why and Call posts built from screenshots, clips, live Yui screens and before/after compares, never more than a few paragraphs between pictures. First posts: the build 64 release, why presets and not generated code, and a call to agents that want to earn by sending pull requests. RSS, share previews, and the weekly update drafts one. /notes moved here.
• SITE-33 (shipped Sep 25, TestFlight feedback, Chris: "the beginnings of our core values"): Yui's values. Eight rules every agent, card brief and page is held to: screens not text bombs, one idea per page, type tells the story, full screen is the whole stage, draw it rather than describe it, say what is being done, nothing cut off mid-sentence, every button does something.
• SITE-34 (shipped Sep 25): the site reads like the app. One type scale for every page, the one the app uses.
• SITE-35 (shipped Sep 25): See it catches up. A Yui 0.2.0 group with the drawer (YUI-54), the menu word (YUI-86), ids that last (YUI-75), native sketches (YUI-84) and the Update chip (YUI-87), live screens where the web draws them. It reads In the iPhone app since build 122 went VALID (SITE-36).
• SITE-42 (shipped Sep 26): every link and image on the site resolves. A checker crawls all 273 pages in the sitemap, tries every link, image, clip and #anchor, and names the source line of anything broken. The first run found 7 dead links between spec pages; they point at the right pages now.
• SITE-43 (shipped Sep 26): See it catches up to build 155. A Build 155 group with hands-free voice (YUI-14), the keyboard going down for a full screen, plan questions in the middle of the page, and the memory numbers from YUI-100 drawn live as stats and a chart. Each entry has its own share link.
• SITE-44 (shipped Sep 26): Designed in the open, a Thought on how a Yui feature starts as a spec and a tappable playground mock before any app code: the starter agent, widgets and Siri, the model on the phone, the key vault and a lesson as one deck, each with its mock and links.
• PERF-1 (Chris Sep 25 night: "very efficient like Telegram"; shipped in 0.3.0, build 138, Sep 26): YUI-101 taps answer at once, smooth scroll and a fast thread open, YUI-99 typing keeps up, YUI-102 speed numbers from real phones. See it.
• YUI-216 (PROP-1, Chris picked it Sep 29; building): Pick your crew, the first-run picker. After sign-in a new person picks which starter agents join (Arnold, Basil, Gouda, Penny, Quill; Yui is always there), reads a short page on each, and "Bring my own agent" sits in the same list as a real branch into pairing. The pick is saved on the account. Builds on YUI-145 and YUI-164.

Then:

• YUI-61 (second, shipped in build 82): slash commands. Type / to see what your agent already understands (Hermes commands first); later, Yui's own /commands that run a skill or a flow.
• YUI-44 step 1 (third, shipped in build 82): @mention another agent from the composer and its reply lands in the thread in its own look. Group threads come after.
• YUI-80 (shipped Sep 25, in build 91; TestFlight feedback Sep 25, Chris: "the whole app shrinks and has a border... I can't undo it"): the chat never gets stuck stepped back. The shrink is the full-screen stage stepping the chat back; it will only happen while a stage is really on screen, and a tap on the chat always brings it back. Lands before YUI-54 reworks that top-left button.
• YUI-79 (shipped Sep 25, app part in build 91; TestFlight feedback, Chris: "the whole reason of this app is I don't want these text bombs"): no text bombs. Board reports and long agent answers arrive as one line and a card, with the detail as pages you swipe through. The channel guide caps chat text, and the app folds any long message into pages instead of a wall.
• YUI-82 (shipped in 0.2.0, build 122, Sep 25; TestFlight feedback on build 96, Chris: "we're telling a story visually with the letters"): full-screen pages tell a story. No card inside full screen, one idea per page, the headline set big and sized to its words, words that spring on and off with the page, titles that never stop mid-sentence. Drawn pictures on those pages are YUI-83 (web) then YUI-84 (app).
• YUI-104 (shipped in 0.3.0, build 138, Sep 26; Chris: "simple SVG style vector graphics"): shapes that move. shapes and shape lines draw circles, boxes, pills, dots, blobs, labels, lines, arrows and curves that come on in order (draw, grow, glide, pulse), with a caption, in the chat. A row by default with arrows that find their ends; colors from the agent's look; Reduce Motion shows the still. Spec, four parsers, playground, channel guide v22 and the native view are done; older phones get the diagram as words.
• YUI-78 (shipped Sep 25, in build 96; TestFlight feedback Sep 25, Chris: "the copy button and the emojis are competing"): the hold menu fits on any message. Reactions always above, the message, the menu always below, never on top of each other; a tall message lifts as a faded preview of its top. Shipped with YUI-76 (agent bubbles draw bold, code and lists instead of raw ** marks).
• YUI-14 (shipped in build 155, Sep 26; Chris: "human voice in, text out, fast and smooth"): tap the mic for hands-free. Words show as you speak (SpeechAnalyzer, on the phone), a short pause sends, the answer comes back as text and the mic reopens. Each agent starts with typing or talking. Audio never leaves the phone.
• YUI-62 (shipped in 0.2.0, build 122, Sep 25): chat with a screen. Screens stay full screen with no composer, unless the agent keeps one on a page with >2 talk; what you type there reaches it as [yui] screen=2 then your words, and shows in the chat marked "From screen 2".
• YUI-63 step 1 (shipped in build 82): one working row instead of three dots plus a timer, a working word and the seconds ("Pondering · 12s"). Step 2: the agent sends a few words on what it is doing, with a small progress bar when it knows the steps. The web half is done (Sep 26): doing "Reading your calendar" 1/3 is in the Yui Lines spec and every parser in the hub, and /playground?demo=working plays a turn. The app half shipped in build 176 (Yui 0.3.2): the working row draws the words and the bar, hosts send them to phones at build 176 or newer, and channel guide v30 teaches every agent to say what it is doing.
• YUI-64 (shipped in build 82): an agent that is paired but not listening says so. Presence is per agent now, not per computer: each gateway names the profile it serves. Right after pairing, the agent's sheet shows the one step left with the exact hermes -p <profile> gateway restart; a message to it says it waits, with no timer, and is answered once the gateway starts. From Chris's feedback on build 61.
• YUI-69 (step 1 shipped Sep 26: the spec and the mock; step 2 shipped Sep 26 in build 148: native in Controls and the chat, the Hermes plugin proposes and applies; Chris Sep 25): talk about a setting. Bring a piece of the agent (its personality, a memory, a skill, a schedule) into the chat, the agent proposes the change as a before and after, one tap applies it through the same Controls path.
• YUI-92 (shipped in 0.2.0, build 122, Sep 25; Chris Sep 25, from Settings on build 96: "so I can know what version I'm looking at at any given time"): the bottom of Settings says exactly which Yui is on the phone. Version and build, channel (TestFlight, Dev link build from YUI-91, App Store), commit and build date, channel guide version, tap to copy for feedback. Pairs with YUI-91, so a Dev copy and the TestFlight copy never get mixed up. YUI-91, the Yui Dev copy that installs beside TestFlight Yui, is built and waits on one install on Chris's phone, paused with the test builds.
• INT-19 onward: more agent frameworks. The Yui MCP server shipped Sep 25 (INT-3), with OAuth (INT-19). Claude (INT-7) and ChatGPT (INT-8) are built, screens in the chat included, and each waits on one look in its own app (see Adapters below).
• The phase backlog below, from YUI-33 on.

Epics

Work ships in epics: a set of cards that together make one release worth trying. Cards land as they finish; the app goes to TestFlight once per epic, with a list of what to try. Crashes and blockers ship on their own.

Done: GTM-1, grassroots go-to-market (complete Sep 24). While the next build waited on Apple, the site and the story came first. Investor material is out for now; nothing gets posted without Chris.

• SITE-19 (shipped): shareable moments. Every screen on See it, every playground sample and every clip has its own link at /s/, with a preview card that shows the lines and the screen they draw; a Share button in the playground; an embed that shows a live Yui Lines screen; a "Made with Yui Lines" badge. How to use them: /developers#share.
• SITE-20 (shipped): the go-to-market plan, in public: who it is for, the social plan per channel, the first 30 days. Read it: go-to-market plan.
• OSS-5 (shipped): a grassroots kit for Yui Lines: who builds with it, how to contribute, a first "draw your best screen in three lines" challenge. Live at /developers/community.
• SOC-3 (shipped): three short videos: Yui in 15 seconds, Yui Lines in 30, your own Hermes on your phone in 60. Watch them on See it.
• SITE-24 (shipped): Yui@home, the story. Like SETI@home, but you lend idle AI tokens: the post Donate your idle tokens to Yui, a Contribute with your agent page with a feature spec template, a "Lend your agent" option at the bottom of every page, and an llms.txt so assistants that read the site can pass the invitation on.
• BIZ-7 (parked): one brand system from the website to social to print.

Next: NATIVE-1, every person gets their own Yui (Chris, Sep 26). Today a stranger who signs in finds an empty list; every agent so far runs on its owner's computer. NATIVE-1 gives each person Yui at sign-in, a helper and a maker that can build more agents for you, plus a starter crew: Arnold the trainer, Basil the nutritionist, Gouda the musician, Penny the planner and Quill the study buddy. One shared runtime in the app repo (runtime/), on Supabase Edge Functions first, GLM 5.2 on OpenRouter with GLM-5V-Turbo for photos, 100 free turns a month and then your own key from any provider. The brain runs on a server so every client (iPhone, web, Mac, Android) gets the same Yui with no agent code of its own. Spec: Native Yui. It replaces the starter agent plan (YUI-37).

• Now: YUI-129 the spec, YUI-130 the runtime core, YUI-131 models and routing, YUI-133 the profile format and Yui's soul, YUI-134 a Yui for everyone at sign-in.
• Next: YUI-132 the channel eval on GLM, YUI-135 the starter crew, YUI-136 the metronome and tuner views, YUI-137 Yui makes agents, YUI-138 start blank, YUI-139 free turns and your own key, YUI-140 memory, YUI-141 read photos, YUI-142 web search, YUI-143 schedules and push, YUI-144 hand-offs, YUI-145 the first launch in the app, YUI-146 the same Yui on the web.
• Moved up (Chris, Sep 29): your own key at every stop, first after 0.6.0. YUI-139 step 2 adds Claude and ChatGPT API keys (plus Gemini and xAI), OpenRouter sign-in with no paste, and "My computer" for a model on your own machine, and makes that key cover chat, photos, search, check-ins, hand-offs, making agents and the web. A Claude or ChatGPT plan can't pay for another app's turns, so plan holders get the other road: add Yui inside Claude or ChatGPT. YUI-34 step 2, the key vault in the app, for the keys your agents' tools use, shipped with it in Yui 0.6.0, build 370 (Sep 29).
• Later: YUI-147 move to Cloudflare, YUI-148 buy turns in the app or on the web.
• Proposals (Chris, Sep 29), from the approval threads on Moltbook, open for votes before any card: Fresh asks (PROP-8), Checked when it's saved (PROP-9), Not sure is an answer (PROP-10) and Receipts (PROP-11).

Later: NATIVE-2, a real Hermes of your own. For people who want Hermes itself: one sandbox per person that sleeps when idle, on Beam first, paired with no code, and your native agents can come along. Spec now, build after NATIVE-1: Hermes for everyone. YUI-149 the spec, YUI-150 the image that pairs itself, YUI-151 the provisioner, YUI-152 move my agents, YUI-153 who gets it, YUI-154 updates, backups and the kill switch.

Done: STAGE-1, the new face of Yui (shipped in Yui 0.4.0, build 204, Sep 27). From his TestFlight feedback: eight pages to say "you're up to date". Yui stops being a chat with things that pop out. You talk, and the answer plays full screen in short chunks with a picture each, the questions come at the end as one Send, and the chat is only the record. Chris: "put a layer onto this app that makes us unique while again staying somewhat simple." Three phases, one TestFlight release for all three (Chris, Sep 26: "don't release until all the new little UI features are in"); every phase started with a playground mock. All three phases reached phones together in Yui 0.4.0: See it, the release post. Mock shots: See it. Why: The chat becomes the record.

• Phase 1, the stage (shipped in 0.4.0). YUI-118 (done on main): short answers first, a status question gets one line, never a deck. YUI-119 step 1 (done Sep 26, Chris approved it): the web mock of the whole phase, live at yuigui.com/playground?demo=stage-first. In the app: YUI-119 step 2, your first send goes straight to full screen. YUI-121: the bottom bar, a slightly bigger mic bottom right (tap and talk, the words stream in like typing), a T beside it for the full text field, a + to attach, images while typing. YUI-122: the top bar, the agent picker top left with settings behind a menu to its left, the chat record top right.
• Phase 2, motion (shipped in 0.4.0). YUI-120 step 1, done Sep 26: the web mock, the stage moves with what the agent is doing (thinking, working, found it, asking, done) and between chunks (try it). YUI-123, web half done Sep 26: say how each agent should move ("heavy and punchy", "drifts like water") and the agent saves a motion look on one theme line, theme pace=quick ease=heavy enter=drop pulse=beat, in the spec, every parser and the playground (try it). YUI-120 step 2: the motion in the app, reading the saved look. Reduce Motion always gets the still.
• Phase 2c, draw anything and make it move (MOTION-1, Chris Oct 5: "a really flexible system for drawing"). Done Oct 6: a drawing kit the model writes against (primitives that draw on, callouts, camera, charts, diagrams, before/after, a magnifier, maps, 3D, particles), one player for the site and the app, a streamed film scene by scene (scene 1 in about 5.25 s), a headless check, and a test set of 20 asks run twice, half project work and half concepts (play them, spec, try your own). Next: the agent's one-line motion ask, the plugin that makes the film, the app's full-screen player (spec/MOTION.md section 0.4).
• Phase 3, the visualizer (shipped in 0.4.0). YUI-124 step 1, done Sep 26: the web mock, a live shader behind the stage on one visual line (orb, aurora, waves, grain, bloom), in the agent's colors and motion look, reacting to a sample voice, a sample beat or your mic, dimmed behind words, still under Reduce Motion, in the spec (spec/VISUAL.md), every parser and the playground (try it). YUI-124 step 2: Metal shaders in the app, at full frame rate and inside the memory ceiling. YUI-125: the visualizer listens, moving with your voice, the agent's voice and the music tools (YUI-116).

Now: INV-1, invite-only beta and client onboarding. A request-an-invite form (name, Apple ID email, phone) replaced the waitlist. Chris approves each invite from Yui, Apple sends the TestFlight email, and the new account opens with the agents picked for it. Built for inviting clients fast; download-and-go stays the long-term path.

• YUI-56 (built, in build 61): invites end to end, from request to first sign-in. It waits on one live test with Apple's TestFlight email before it counts as done.
• YUI-57: default agents per invite, client-safe agents only. Step 1, the spec and a playground mock, shipped Sep 25 (Shared agents: templates an invite carries, grants a client holds, revoke, and the client-safe rule a shared agent must pass). Step 2, YUI-95, shipped Sep 25: grants and templates in the database, grant.py (refuses any agent that is not client-safe), the host's sandbox check before every turn for someone who is not the owner, and a first sign-in on the simulator (the invitee finds the agent in its look with its first message; a revoke removes it). Next in the app: the owner's invite plan and the client's "Shared by" settings.
• SITE-26 (shipped Sep 24): Request an invite replaced the waitlist on the site. Since Sep 26 it is Ask for a hand, beside the public TestFlight beta.
• SITE-64 (live Sep 27): Yui in a chat bubble on every page of yuigui.com, no account needed. She answers from the whole site (search and read, every page, spec, post and ship log entry), takes the visitor to any page, and quietly notes each need, feature request, bug and confusion. After some real interest she offers a small form for name, email and an optional phone, which also lands as an Ask for a hand request. Three free turns, then one Cloudflare Turnstile check. Every chat is kept, server only (/privacy#chat), and site/scripts/chat-notes.mjs rolls the notes up into what visitors want. Needs: a chat OpenRouter key with a credit limit and the three tables in site/lib/chat/schema.sql. Turnstile keys turn the check on; a chat runs to 100 turns. The chat plays like the app (SITE-65): screens drawn live, a timer, deck or >full reply takes the whole chat on the stage, ready-made screens come from the library, the contact form is a Yui form, and the bubble is the Yui mark on a floating, shifting shape.
• SITE-77 (live Sep 28): hand this to your agent. Every page you can act on (Get started, Developers and each spec, the playground, Contribute, every shared screen) has one small box with Copy link, Copy page and one line of how: "Give this link to your agent. It reads the page and sets itself up." Copy page gives the page as markdown an agent can follow, also served at /md/, like /md/start.
• SITE-67 (live Sep 28): the site chat asks for feedback first. It opens on four choices: What do you like, or not? (one full-screen flow: pick what you like, pick what is not landing, one open line, one Send), Give me the pitch (a four-page deck from the positioning brief, ending in a choice), How can I help? (four cards: TestFlight feedback, Yui@home, build to earn, share the site) and Just show me (a real screen, then one like or dislike question). Likes land as praise notes and dislikes as confusion notes on the server; site/scripts/chat-notes.mjs shows them grouped.

Done: WAR-1, the war room (shipped in build 74, Sep 25). Screen 2 becomes a real dashboard for running Yui from Yui: a timeline of what shipped and what is queued, quick links to the site, and a reorder mode that sets board priority by dragging, with no agent turn in between (Chris, Sep 25).

• YUI-65 (shipped Sep 25): a timeline preset: done above, now, queued below. In build 74.
• YUI-66 (shipped Sep 25): reorder mode, drag to set priority on the board, with no agent turn. In build 74.
• YUI-73 (shipped Sep 25): the rest of the war room. Needs you (cards waiting on Chris; a card with choices gets one-tap answers that land on the card and send it back to the queue, with no agent turn), running now (one row per lane), builds with the Install button, the latest feedback and the card it became, the MVP bar, quick links. Built from presets the app already draws. In build 74.
• YUI-90 (step 1 shipped Sep 25; Chris Sep 25: "a totally dynamic, live update of the harness... really good real estate in the war room"): the release timeline goes live. Step 1 is on the site: the Release timeline page, a release block in the board export (the YUI-SHIP card and its parent cards), and the panel drawn from the board's own exports at /playground?demo=release, linked from Builds: cards done, now and next, the ship steps (tests, upload, VALID, what to try), and what is on main since the last build. Step 2, YUI-105, shipped Sep 26: the panel at the top of the war room on the phone, patched in place as cards move (YUI-75 ids), with no agent turn. Needs build 74+, patches build 111+.
• YUI-112 (shipped Sep 26 in build 148; seen Sep 26 on the simulator): a timeline opened alone on the full-screen stage, from the shelf, spreads its rows over the whole height, with big gaps and a running row's highlight about 400 pt tall. Now rows keep their own height and the timeline sits at the top.
• YUI-126 (Sep 26; Chris: "the left drawer should be more of the war room"): the war room leaves screen 2 for the agent's drawer. Review holds what waits on you (a tap opens the ask, a tap answers it), Home reads the build on TestFlight, what each lane is building now, what is next, and a link to the board. Sent by the host as drawer lines, so it works on the build you have, with no push.

Done: PERF-1, Telegram-smooth (Chris Sep 25; shipped in 0.3.0, build 138, Sep 26). "Optimize for pure user experience... very efficient like Telegram." The design stays as it is; the app gets fast. Measure first, so every fix has a before and after, and Yui watches the numbers from then on.

• YUI-98: speed reporting. Step 1 shipped Sep 25: the speed budget (Speed budget), seven named intervals with p50 and p95 targets, hang, hitch and memory budgets, what the phone sends (numbers only) and the proposed yui_perf table, the daily report and the rule for the briefing line, and the war room Speed panel in the playground (/playground?demo=speed). Step 2 (YUI-102, shipped in 0.3.0, build 138) built Sep 25, app main 9385fc2: signposts and a frame clock on the nine intervals, MetricKit metrics and diagnostics, memory every 30 s, one batch an hour and on background, the yui_perf table on PROOF (numbers only, owner only, 500 a day, 90 days), yui_perf_report.py and the Speed panel under Builds in the war room, and the briefing line only when a number got worse. Dev builds get a Speed switch. As built: PERF.md section 10. First real numbers Sep 26, from Chris's phone on TestFlight 135 (before YUI-99 and YUI-101): typing p95 70 ms on 52 keystrokes (budget 33), memory peak 328 MB (budget 300); 0.3.0 (138) is the first build to compare against. The same rows showed one batch sent twice across a relaunch: the report drops repeats, YUI-107 fixes the phone.
• YUI-99 (shipped in 0.3.0, build 138): typing keeps up. Holding backspace and double-space for a period run as fast as in Notes, even on a long thread.
• YUI-100 (shipped in build 155, Sep 26): memory audit. On a scripted simulator session (5 agents, 486-row threads, decks, galleries, games, screens 2-12, idle) the inline deck pager leaked about 1,550 objects; it pages with a ScrollView now and the session ends with 0 new leaks. Pictures decode at display size into one 48 MB cache emptied on a memory warning, videos drop their player, the thread window trims back at the bottom. Peak 243 to 203 MB, launch 137 to 124 MB. scripts/memory.sh runs before every ship and fails on over 100 new leaks, 15 MB growth or a 300 MB peak.
• YUI-101 (shipped in 0.3.0, build 138): taps answer on the same frame, 120 fps scroll, fast thread open. On the simulator a long thread opens in about 0.3 s instead of 3, taps answer in under 100 ms, and scroll hitches fell from 63 to 2 ms a second.
• YUI-107 (shipped in 0.3.2, build 176, Sep 26): speed rows send once. A row key and a unique index, so a batch resent after iOS suspends the app is stored once.

Distant: EARN-1, build to earn. Yui is built by whoever shows up, human or agent, and the work is what earns. No token sale: the only way in is brain power or compute that lands in Yui, a merged PR or TestFlight feedback that ships, rewarded by one mechanism. 10% of voting equity is set aside for the public pool, with more to follow. Humans first, and an open call to autonomous agents. Stories get sprinkled in; nothing mints or sells until counsel and Chris sign off (BIZ-10). Builds on Yui@home (SITE-24).

Chris, Sep 25: only the proposal moves for now. A crypto lawyer will review /earn; the token, chain, NFT and ledger cards stay frozen until then.

Chris, Sep 26: use counts too. People pay AI companies and hand over their data; Yui should reward its early users with an owner's stake, as far as the law allows. Recording starts from day one, at a high level: days you use Yui, pull requests, feedback that ships. The ledger is private, not public. Distributions, airdrops and NFTs come later, only after counsel. The site says use to earn at a high level; the detail stays in the docs (Use to earn, Ledger). The app shows nothing of it until a much later phase.

• SITE-27 (shipped Sep 24): Build to earn, a V1 page on the site, marked draft.
• SITE-29 (shipped Sep 25): the proposal. Our position, the forms it could take (points plus equity, stock options or units for contributions, a community round kept separate), and open questions for counsel.
• BIZ-8 (shipped Oct 1): tokenomics v1: supply, emissions, how value holds.
• BIZ-9 (backlog): the chain. Chris picked Sui on Sep 24; Polygon is the fallback.
• BIZ-10 (backlog): legal review, token and equity.
• BIZ-11 (backlog): contributor NFTs with real perks (First Contributor, Hat Trick).
• OSS-7 (designed Sep 26, switching on waits on Chris): a private ledger of use and contributions, back to day one. Raw facts now, a points formula later, tokens only after counsel. Spec: Ledger.
• SITE-28 (backlog): "How can I help?" around the site, and an open call to agents.
• BIZ-12 (backlog): build to earn in the go-to-market plan and the pitch.

Latest release: Yui 0.6.5, build 576, Oct 7: films talk. Each line is spoken as the film plays, a real chicken is drawn on the phone, and the end of a film offers Replay, Another take and Change it (YUI-317, YUI-318, YUI-319, YUI-320). The post: Yui 0.6.5: films talk.

Since 0.6.5, on the web and riding the next build:

• MOTION-26: explainers get a film, not shape pages. The post: Ask what string theory is, get a film.
• MOTION-27: the agents Yui runs for you make films too. The post: The agents Yui runs for you now make films.
• MOTION-29: native agents draw what the kit lacks and keep the good ones. The post: Native agents now draw a new thing and keep it.
• MOTION-30: native first films catch up, with the strong model route off. The post: Native agents' first films catch up with the plugin's.
• YUI-322: a dry house key never breaks an agent, it shows a kind resting screen. The post: A dry key stays kind.
• YUI-323: the living canvas plays all 41 films and every mark is a touch target, a web prototype. The post: Every film is touchable.
• YUI-324: the canvas works by keyboard and screen reader. The post: The canvas works without touch.
• YUI-325: the canvas draws Yui Lines too, shapes and sketches stroke by stroke, every mark touchable. The post: The canvas draws Yui Lines too.
• YUI-326: the canvas draws charts and stats, every bar, point, slice and number a touchable mark named by its value, a web prototype. The post: Charts you can touch.
• YUI-327: the canvas draws lists, tables, timelines and cards, rows you tick and ask about where they sit, a web prototype. The post: Lists you can tick.
• YUI-328: the canvas draws the questions an agent asks, choose, pick, slide, ask and form, as marks you answer on the picture, a web prototype. The post: Answer on the canvas.
• YUI-329: a mixed answer, a line, a chart, a list and a question, draws as one picture on one clock, every part touchable, a web prototype. The post: One answer, one drawing.
• YUI-330: hold a part of the canvas and just that part redraws in place, a web prototype. The post: Point at a part and it redraws.
• YUI-331: drag a part of the canvas and the agent answers where you put it, a web prototype. The post: Drag a part and the agent answers where you put it.
• YUI-332: talk while you touch a part and the agent gets both, a web prototype. The post: Say it while you touch it: the agent gets both.
• YUI-333: the canvas events are written into the spec, with a test that keeps spec and code in step, a web prototype. The post: The canvas rules, written down.
• YUI-334: step back on the canvas, undo a redraw or a drag, and only the changed marks redraw, a web prototype. The post: Change your mind on the canvas.
• YUI-335: the canvas holds its frame budget on a phone-sized screen, with a test that keeps it there. The post: The canvas stays smooth on a phone.
• YUI-336: the canvas draws maps, and every area, pin and route is a mark you can touch. The post: Maps you can touch.
• YUI-337: the canvas draws math and calc, every term and slider a mark you can touch. The post: Math you can touch.
• YUI-338: the canvas draws pictures, a gallery and before and after, every picture a mark you can touch. The post: Pictures you can touch.
• YUI-339: the canvas draws music, every beat cell, key and chord a touchable mark. The post: Music you can touch.

Earlier releases:

• Yui 0.6.4, build 535, Oct 5: decks fill the screen, Home goes calm. Decks morph between pages, Home is only your chats, side pages are named for what is on them, questions show what they ask about, workouts have music and edits mid-set. The post: Yui 0.6.4: decks fill the screen, Home goes calm.
• Yui 0.6.3, build 522, Oct 5: say it first. Mics on every field, screens that switch at once, the phone draws like the hub. The post: Yui build 522: say it first.
• Yui 0.6.2, build 450, Oct 2: the stage, redrawn (YUI-265, YUI-266). The post: Yui build 450: the stage, redrawn.
• Yui 0.6.2, build 392, Sep 30: the first minute, fixed (YUI-225, YUI-228, YUI-229, YUI-230, YUI-236). The post: Yui 0.6.2: the first minute, fixed. See it: Yui 0.6.2.
• Yui 0.6.0, build 370, Sep 29: several chats, your own keys and icon shortcuts (YUI-169, YUI-34, YUI-139, YUI-191). The post: Yui 0.6.0, build 370.
• Yui 0.6.0, build 342, Sep 29: the crew gets real tools (YUI-180, YUI-182, YUI-183, YUI-184, YUI-185, YUI-186). From Chris's Sep 28 direction: each of the five agents gets its own tools, flows and default screens, not just chat. Arnold runs the workout one move per page (YUI-182), Basil plans meals, reads a plate and shares the grocery list (YUI-183), Gouda teaches a song and keeps the loop playing across his screens (YUI-184), Penny takes the week out loud and closes the day (YUI-185), Quill teaches, quizzes and walks a problem (YUI-186), and every agent opens on its own quiet visual (YUI-180). Riding with it: hold the mic to cancel or lock (YUI-201), day dividers and sent times (YUI-202), a notification that opens on page one (YUI-199b) and about 35 MB less memory held after a long session (YUI-207). See it: Yui 0.6.0. The post: Yui 0.6.0: the crew gets real tools.
• Yui 0.5.3, build 332: a way home from every full screen, screens as pills, and Add agent no longer hangs (YUI-192, YUI-193, YUI-195).
• Yui 0.5.2, build 288: the screen dots are back and slide with you (YUI-187).

Before it, Yui 0.4.2, build 216, Sep 27: one Send per screen. From Chris's TestFlight note: a form inside a plan is just fields (YUI-156) and a pick inside a plan has no Done of its own (YUI-159), so a screen of questions has one Send at the end. See it: forms, picks. The post: Yui 0.4.2: one Send per screen.

Before that, Yui 0.4.1, build 208, Sep 27: tune up, keep time, send a take. For musicians: a tuner on the mic and a metronome in the chat (YUI-116 step 4), Record on the looper, pads, keys and chords sends the take to the agent, and a MIDI keyboard plays the keys (YUI-116 step 5). See it: Yui 0.4.1. The post: Yui 0.4.1: tune up, keep time, send a take.

Before that, Yui 0.4.0, build 204, Sep 27: the new face of Yui. The answer plays on the full screen in short parts with a picture each, the questions come last with one Send and the chat is the record (YUI-119), a big mic bottom right (YUI-121), your agents top left (YUI-122), the stage moves the way each agent moves (YUI-120, YUI-123), and a live picture behind the words listens to your voice and the music (YUI-124, YUI-125). Keys and chords ride along (YUI-116 step 3). See it: Yui 0.4.0. The post: Yui 0.4.0: the new face of Yui.

Before that, Yui 0.3.2, build 176, Sep 26: ask any agent for a beat. A looper and drum pads that play in the app on Yui's own sound engine (YUI-116 step 2), hold to reply with no swipe, a quiet dot on the menu button, a working row that says what the agent is doing (YUI-63 step 2) and how long it usually takes, and speed rows stored once (YUI-107). See it: Yui 0.3.2. The post: Yui 0.3.2: ask any agent for a beat.

Before that, Yui 0.3.1, build 160, Sep 26: three notes from the feedback button. Each agent's thread keeps its own unsent words through a full screen, another agent or a relaunch; a lesson is one deck whose pages carry a diagram, formula, chart, number or calculator (YUI-113); and an ask answered in the war room leaves at once. See it: Yui 0.3.1. The post: Yui 0.3.1.

Before that, Yui 0.3.0, build 138, Sep 26: the smooth release. Taps answer at once, a long thread scrolls smooth and opens in about a third of a second (YUI-101), typing keeps up like Notes (YUI-99), and Yui times itself on real phones (YUI-102). Agents draw shapes that move (YUI-104), you can restyle Yui by asking any agent (YUI-96), an agent can be shared with a client and taken back (YUI-95, YUI-97), and group threads work in the database and the plugin (YUI-93). Two deck fixes from TestFlight feedback: an inline deck is as tall as its page, and a full-screen page never comes up blank. See it: Yui 0.3.0.

And before that, Yui 0.2.0, build 122, Sep 25: every agent gets a home. Each agent has a drawer (YUI-54) that agents fill with asks, a backlog and shortcuts (YUI-86), screens update where they sit (YUI-75), full-screen pages tell a story (YUI-82), the app draws sketches (YUI-84), you can type on a screen (YUI-62), Needs you is one block, lines a build can't draw fold into one Update chip (YUI-87), and Settings says which Yui you have (YUI-92, with the Yui Dev copy from YUI-91). Build 96 (Sep 25) fit the hold menu to any message (YUI-78) and drew agent markdown (YUI-76). Build 91 (Sep 25) brought no text bombs, long answers fold to pages (YUI-79), the chat never gets stuck shrunk (YUI-80) and the thread rests on a photo you just sent (YUI-74). Build 82 (Sep 25) brought slash commands (YUI-61), @mentions of your other agents (YUI-44 step 1), one working row (YUI-63), agents that say when they are not listening yet (YUI-64) and the approval sheet for Claude and ChatGPT (INT-19). Build 74 (Sep 25) brought the war room (WAR-1), replies, select text and links that open Safari. Build 57 (Sep 24) was the big one, chat feels right: the lock screen timer (YUI-30), screens per agent (YUI-31), named screens on a shelf (YUI-32), the preset flywheel (YUI-42), message reactions (YUI-49), a way back to the newest message (YUI-50), one full-screen flow for pages and questions (YUI-51), no dead buttons (YUI-53), and every Sep 24 feedback fix checked again (YUI-52). Build 61 fixed a crash in hold to talk and brought invites (YUI-56) and test builds by link (YUI-55). Build 64 made hold to talk work like WhatsApp and gave screens 2 to 12 the whole phone.

Build 148, Sep 26 added YUI-106 (send and the drawer taps answer faster), YUI-70 (agent controls in the drawer), YUI-69 (talk about a setting), YUI-111 (a patch moves a timeline row in place) and YUI-112 (a timeline alone on the stage keeps its row heights) to 0.3.0. Builds lists it. Releases ship as versions, one upload per epic, and Chris picks each one's scope.

North star: not just another AI chatbot

Chris, Sep 24: "I want these to be truly unique experiences." Every decision gets checked against this. Chat is the doorway, not the product. Three commitments follow:

1. Immersive by default when it matters. The agent's UI can take over the whole screen, not just sit as a bubble in chat. The agent decides when a full-screen view is worth it; workouts always go full screen. The user can always leave with a swipe down or an X, and the chat is right underneath. Shipped 2026-09-24 as Yui Lines >full (route the following lines to a full-screen stage) and close, plus a per-preset default (timer, camera, mic and deck open full screen, +inline keeps them small) and the agent's screen= style. Card YUI-13.
2. Voice in, text out, fast. Talk naturally, read the answer. On-device speech (iOS 26 SpeechAnalyzer) streams words as you speak, a hands-free mode keeps the mic open between turns, and the first word of the reply lands in well under a second of you finishing. Card YUI-14.
3. Answers are never locked. Change your mind on any choice and the agent adapts (YUI-12, shipped Sep 24). An agent can lock something on purpose, like a confirmed booking.

In-chat screens stay: they are right for quick asks. Full screen is for the moments that deserve it.

The core bet: presets and settings, not generated UI code

Chris, Sep 23: optimize for speed. The UI should work like settings. The agent picks a preset and fills in a few parameters. It never writes HTML, and even JSON is too heavy.

• Presets carry the weight. The app ships prebuilt presets: timer, ask, choose, pick, slide, form, list, table, card, image, camera, mic, chart. Each already has its layout, animation, big tap targets, and one primary call to action. Target: presets alone deliver 80% of the value at launch.
• Yui Lines (YL) is the wire format. One line per component: preset name plus terse positional args, defaults for everything else. No braces, no quoted keys. The app renders each line the moment it arrives.

  timer 40/20x8 Tabata                  # 40s work, 20s rest, 8 rounds
  ask "Log this set?"                   # yes/no by default
  choose "Split?" Push|Pull|Legs +other # single choice + type your own
  pick "Gear" DB|Bench|Bands            # multi-select
  slide "AI experience" 1-5
  form name:text goal:voice level:1-5
  list Today "Squat 5x5 225" "Bench 5x5 185"
  table meals                           # bound to an agent data table
  >2 timer 60                           # send to screen 2
  ~timer rounds=10                      # patch a live component, no re-send
  save workout / show workout           # named screens, reopened in two tokens
  

  Measured Sep 23 (o200k tokenizer): the Tabata timer is 9 tokens in YL, 25 as minified JSON, 75 as a component tree. Across ten screens YL is 1.6x smaller than lean JSON and 3.9x smaller than a tree. Details in spec/BENCHMARK.md.
• The channel guide is the cheatsheet. Every agent on the Yui channel gets a short guide (spec/CHANNEL.md, YUI-10) listing the presets and their args, so it carries the whole vocabulary for a few hundred tokens. An eval scores every change to it.
• Escape hatch, then promotion. custom {json} covers the long tail. Every custom use is logged. Patterns that repeat get promoted to presets. That is the flywheel that grows the 80% toward 95%.

Why this over generated code:

1. App Store. Apps that download and run new executable code get rejected (guideline 2.5.2). Rendering data against a fixed native preset set is the pattern Apple accepts.
2. Speed. No codegen, no build. A screen costs one short line of output and renders instantly.
3. Quality. UX rules live in the presets, not in every prompt, so an agent cannot produce a bad layout.
4. Portability. The same line renders in the app, on the web tracker, and degrades to Telegram buttons (ask and choose map straight to inline keyboards).

Stack: native SwiftUI on iPhone (decided Sep 23 2026)

Chris decided: all Swift. Draft 1 recommended Expo/React Native with Swift modules; draft 2 reverses that. Why:

• The product is native feel. Yui should behave like part of the phone: Apple's navigation, sheets, haptics, Dynamic Type, accessibility and the iOS 26 Liquid Glass look come free in SwiftUI and are imitations anywhere else.
• The differentiators are Apple surfaces. Live Activities and the Dynamic Island (a timer on the lock screen), widgets, App Intents (Siri, Shortcuts, Spotlight, Action button), the on-device Foundation Models framework, and on-device speech. In React Native every one of these is Swift glue anyway.
• The preset design makes native cheap. The app is a Yui Lines parser, roughly 13 presets, a chat view and a relay client. New screens arrive as data, so React Native's over-the-air updates buy little, and an Android port later is a port of the presets, not a redesign.

Rules that follow from the decision:

• iPhone only for now. No Apple Watch app yet (Chris, Sep 23). Parked until after the MVP (YUI-47).
• Yui Lines stays platform-neutral. spec/YL.md plus a shared conformance suite (input lines, expected parse) is the contract. The JS parser (web playground) and the Swift parser must both pass it. An Android build later (Kotlin + Jetpack Compose) passes the same suite.
• The web stays React. The hub site and playground keep the JS renderer as the public, clickable reference.
• Fast feedback loop. The Mac mini builds and ships TestFlight builds with no cable, running since Sep 23. Since Sep 24 TestFlight gets one build per epic (Apple caps uploads per day), and test builds by link (YUI-55) put the newest main on Chris's phone in between.
• Target iOS 26. It is the current release, it has Foundation Models and Liquid Glass, and a new app has no install base to protect.

Architecture in one paragraph

Agents stay where they live: Hermes on the owner's own Mac or Linux box. The Hermes yui plugin dials out to the Yui relay, which today is Supabase Realtime plus a few Supabase edge functions (YUI-6, YUI-7), so the agent's machine opens no ports. The agent sends chat messages and Yui Lines to the relay; the relay hands them to the phone live when the app is open and sends an APNs push when it is closed (YUI-24). The phone sends taps, picks and form results back as events. Messages wait in the relay when either side is offline, so nothing is lost when the Mac sleeps or the app is killed (YUI-28), and they are deleted after 90 days (YUI-26). Pictures and videos go through a private storage bucket (YUI-21). "Pull this up on Yui" from Telegram is one tool call (YUI-8). A multi-tenant relay for zero-install connections, possibly on Cloudflare's Agents SDK, is future work (INT-5, INT-6). On-device data tables are Phase 3 (YUI-33).

Phases

Updated Sep 24 2026 (SITE-10). The first plan assumed work would start the week of Sep 28 and run in monthly phases to June 2027. Work started Sep 23 instead. By Sep 24, Phases 0 and 1 had shipped, and so had half of Phase 2. The MVP above cut across the phases: it pulled push, first run, safety limits and beta review prep forward, and left the rest for later.

Dates below are real ship dates from the board and the git log. A phase that has not shipped carries no date. The old month targets no longer mean anything, and new ones are Chris's call. Each phase still ends with something Chris can touch.

Phase 0 | shipped Sep 23 2026: foundations and the tracker site

Goals: a place to watch the project, and the protocol written down before any app code.

Deliverables:

• DONE Sep 23: hub site (roadmap, progress log, business plan draft, deck outline, mockups), source on GitHub at postscarcityai/yuigui.
• DONE Sep 23: Yui Lines v0 (spec, 12 presets, JS parser, web playground, token benchmark). Replaces the JSON protocol from draft 1.
• DONE Sep 23: yuigui.com live, built in public (progress log per ship, weekly update Fridays).
• DONE Sep 23: waitlist on yuigui.com (replaced by Request an invite on Sep 24, SITE-26), stored in yui_waitlist in the existing PostScarcity AI Supabase project (PROOF). All Yui tables use the yui_ prefix there; no new Supabase instance.
• DONE Sep 23: Apple Developer account (Chris, individual enrollment, no D-U-N-S).
• DONE Sep 23: the Yui Lines conformance suite, and the Swift parser that passes it (YUI-3). Events back to the agent (tap, submit) are in the spec from day one; voice events wait for YUI-14.
• DONE Sep 23: Xcode on the Mac mini and a TestFlight pipeline on the App Store Connect API. The first build went out the same day.
• DONE Sep 23: web mockups of the canonical screens at /mockups. Replaced Sep 24 by See it (SITE-14): every shipped screen, drawn live from Yui Lines or recorded in the app, each tied to its card and ship date.
• DONE Sep 24: theme schema, as per-agent themes and theme lines (YUI-20).
• MOVED: the Telegram quick win (inline buttons on Hermes questions) became INT-4. Step 1 (renderer and Mini App) done Sep 25, spec/TELEGRAM.md.

Phase 1 | shipped Sep 24 2026: talk to your own Hermes agents in Yui

Goals: Chris talks to each of his Hermes agents in the app, gets GUI answers back, and can hand a Telegram conversation over to Yui with one push.

How it plugs in: Yui is a Hermes messaging platform, built as a Hermes platform plugin, the same way Telegram is. Each agent keeps one brain and one memory across Telegram and Yui. Each Hermes profile shows up in the app as its own agent with its own thread. The plugin dials out to the relay (Supabase Realtime today), so the Mac needs no open ports.

Deliverables, in build order:

• DONE Sep 23: SwiftUI app on TestFlight, Korean-cute theme with light/dark (YUI-2), typographic identity with coral wordmark and letter avatars (YUI-9), coral wordmark icon. Yui Lines Swift parser passing the shared conformance suite (YUI-3).
• DONE Sep 23, YUI-4: first 6 presets in chat (ask, choose, pick, form, list, timer).
• DONE Sep 23, YUI-6: accounts. Sign in with Apple, and in-app account deletion as App Store rule 5.1.1(v) requires, including Apple token revocation. Yui users are kept fully separate from any other PostScarcity data.
• DONE Sep 23, YUI-5: coral wordmark across the UI.
• DONE Sep 24, YUI-7: the Hermes yui platform plugin. Pairing by code, one thread per agent, agents taught Yui Lines so they answer with screens, taps flow back as messages.
• DONE Sep 24, YUI-8: push handoff. From Telegram, "send it to Yui" drops the screen into that agent's thread and sends a push that opens it.

Dependencies: an Apple key with Push Notifications and Sign in with Apple. Done: both are live in the app.

Phase 2 | partly shipped Sep 24 2026: many agents, identities, cross-channel

Goals: Yui is a hub, not an Arnold app.

Deliverables:

• DONE Sep 23, YUI-15: an agent list you manage yourself: add, rename, remove.
• OPEN: Urza, Arnold and R0SS all connected in Chris's app. Not tracked on a card, so not confirmed here.
• DONE Sep 24, YUI-20: per-agent theme and avatar, light and dark. Per-agent voice is not built; it comes with YUI-14.
• DONE Sep 24, YUI-24: push notifications when an agent answers, with presence and per-agent mute. YUI-8 pushes open the handed-off screen.
• DONE Sep 24, YUI-8: cross-channel handoff. From Telegram, "pull this up on Yui" pushes the screen to the phone.
• DONE Sep 24, YUI-13: the full-screen stage with swipe-down or X to exit, and workouts always full screen.
• DONE Sep 24 (build 57), YUI-31: screens per agent. The chat, then screens a swipe away; agents send things that should stay put there (>2 timer 25m Focus), and the page slides forward with a spring, or cross-fades with Reduce Motion. Build 64 (Sep 25) takes it to screens 2 to 12, each with the whole phone.
• DONE Sep 26, YUI-14 (shipped in build 155): voice input on Apple's on-device SpeechAnalyzer (classic recognizer as an on-device-only fallback), per-agent default of talk vs type, hands-free voice in with text out. Final words ~90 ms after you stop talking; replies fetched every 350 ms while one is owed. Hold to talk still works (builds 57 and 64). Later: the agent's reply streaming token by token (today it lands whole).
• DONE Sep 24 (build 57), YUI-30: Live Activity for the timer preset: rounds keep counting on the lock screen and Dynamic Island.

Phase 3 | started Sep 25 2026: data and keys

Goals: agents can make things that persist.

Deliverables:

• YUI-33: on-device tables: agents create tables and rows through the protocol (table create, put, query). Views render as table, list, chart or one number. Starter schemas: workout log, macros, simple CRM. Step 1, the spec and the web playground, shipped Sep 25 (Agent tables); the app's store and views are YUI-89.
• YUI-34: key vault in the iOS Keychain for BYO keys: fal, Replicate, OpenRouter, Anthropic, OpenAI. Step 1, the spec and a playground mock, shipped Sep 26 (Key vault, /playground?demo=vault): keys go in only through Settings > Keys (paste or scan, never a chat or an agent's form) and stay in the Keychain on this iPhone; an agent asks through its host and Yui draws the ask itself; the hosted connector gets the key sealed and makes the call, the agent gets a handle and never the key; a monthly cap per key and per agent, an activity list, Revoke in the drawer. No new Yui Lines word. Step 2, native in the app, the relay and the connector, shipped Sep 29 in Yui 0.6.0, build 370: Your keys, on your phone, /playground?demo=vault.
• Image generation through the user's own fal key (agent avatars first, then in-chat images). YUI-21 (Sep 24) already lets agents send images they made elsewhere.
• YUI-35: nutrition demo: photo of a meal to macro estimate to a row in the macros table. Step 1, the spec and a playground demo, shipped Sep 25 (Meal photo to macros, /playground?demo=meal); step 2, native Basil logging a meal without weighing (YUI-103), shipped Sep 27.
• YUI-36: optional encrypted sync of tables via the relay (off by default, on-device first per Chris). Step 1, the decision, the spec and a playground mock, shipped Sep 26 (Encrypted sync, /playground?demo=sync): v1 ships without sync, since v1 is one iPhone and the phone's own backup covers a new phone. The design is ready for when a second Yui device arrives: agent tables only, sealed on the phone, a relay that cannot read them, pairing by QR with no new account, a per-cell conflict rule, and turning it off deletes the relay's copy. No new Yui Lines word. Step 2 waits for a second Yui client.

Dependencies: decided Sep 26, v1 does not need sync (Encrypted sync, five open questions for Chris).

Phase 4 | not started: onboarding and a built-in agent

Goals: someone with no agent can download Yui and start.

Deliverables:

• YUI-37: hosted default agent (runs on the relay, model via OpenRouter on the user's key at first). Step 1, the spec with a cost model and a playground mock, shipped Sep 26 (Starter agent, /playground?demo=starter): it runs on the hosted connector beside the relay, the person's own OpenRouter account first, no tools with side effects, about $0.0013 to $0.0096 a turn. Step 2, the hosted build, is parked: it needs a Cloudflare account and spend, and Chris signs off first.
• YUI-38: generative onboarding interview: name form, AI-knowledge slider, "what do you want to do" with a mic button, then starter agents suggested (trainer, nutritionist, personal assistant). Step 1, the spec and a saved flow that runs in the playground, shipped Sep 25 (Onboarding, flow onboarding). Step 2, native in the app on first launch, is parked until after 0.2.0.
• YUI-39: connector library v0: MCP servers the user logs in to via OAuth (HubSpot, Google Calendar, Gmail first). Step 1, the spec and the connect flow in the playground, shipped Sep 25 (Connectors, flow connect). Step 2, real sign-in on the agent's host, is parked: it needs a Google Cloud project and a HubSpot app registered, and Chris signs off on those first.

Dependencies: the Phase 3 vault. Cost model for hosted agent calls.

Phase 5 | started: open adapters and a beta

Goals: other agent owners can plug in.

Deliverables:

• DONE Sep 24, YUI-23: other people's Hermes installs connect with one command to install the plugin and one code to pair.
• DONE Sep 24, OSS-1: Yui is open source (Apache-2.0), Yui Lines spec included.
• DONE Sep 24, YUI-27: beta review prep: privacy answers, review notes, demo account, help link.
• DONE Sep 24, YUI-22: public TestFlight link. Anyone can install Yui: https://testflight.apple.com/join/ykrYHwet
• DONE Sep 26: the public TestFlight beta replaced the planned private beta of 20 to 50 technical users (Chris, Sep 26: we are in public beta on TestFlight; later that day he called the MVP done, and the stage is alpha). Every call to action on the site leads with the public link; the form at the bottom of each page is now Ask for a hand, for people with no agent yet, who want help connecting one, or who want the invite by email.
• NOT STARTED, INT-5: zero-install connect through Hermes's relay connector contract (hermes gateway enroll): Yui hosts the connector, the user enrolls once, their agents appear in the app.
• DONE Sep 24, INT-2: the webhook bridge, Python and Node. Any agent that answers an HTTP POST can talk in Yui, no Hermes needed.
• DONE Sep 24, INT-1: the OpenClaw channel plugin. An OpenClaw agent talks in Yui the way a Hermes agent does, screens and taps included.
• DONE Sep 25, INT-4 step 1: Yui in Telegram. Questions as inline keyboards whose taps come back as the phone's event line, the rest in a Telegram Mini App at yuigui.com/tg (spec/TELEGRAM.md). A bot that runs it is next.
• DONE Sep 25, INT-12 step 1: the model bridge. Put a model you run yourself (Ollama, LM Studio, vLLM, llama.cpp) into Yui; Yui holds the thread and the guide is the system message (spec/MODELS.md). Cloud APIs on the hosted connector come later.
• DONE Sep 25, INT-18 step 1: the A2A bridge. Add any A2A agent (ADK, LangGraph, CrewAI, Microsoft Agent Framework) by its Agent Card URL; A2A 1.0 and 0.3 (spec/A2A.md). The hosted version is step 2.
• DONE Sep 25, INT-3: the Yui MCP server. Claude Code, Cursor or any MCP client puts a screen on your phone and reads the taps back (spec/MCP.md).
• DONE Sep 25, INT-19: OAuth for the MCP server. The Claude and ChatGPT apps add Yui by pasting one URL; you approve in the app. The approval sheet shipped in build 82.
• BUILT Sep 25, INT-7: Claude. A guide for Claude's apps, Claude Code and Agent SDK agents (spec/MCP.md "Claude"), and Yui screens drawn inside the chat as an MCP App, tappable there too. Checked in the MCP Apps reference host and with Claude Code on a Mac; one look inside claude.ai itself is still to come.
• BUILT Sep 25, INT-8: ChatGPT. Add Yui in ChatGPT developer mode by its URL (spec/MCP.md "ChatGPT"); the screen draws in the chat as the same MCP App. Checked in a ChatGPT-shaped test host, both of ChatGPT's ways of talking to an app; one look inside chatgpt.com itself is still to come. Not listed in ChatGPT's directory.
• NOT STARTED, YUI-48: SMS channel (text a number, get a push that opens the screen).

Dependencies: App Store submission sign-off from Chris.

Phase 6 | not started: money, polish, on-device

Goals: the "put in your credit card and go" version.

Deliverables:

• YUI-45: in-app purchase credits for image generation and hosted model usage (keys stay optional for power users).
• YUI-41: on-device Foundation Models for routing and quick replies, cutting cloud cost and latency. Step 1, the spec and a playground mock, shipped Sep 26 (The model on the phone, /playground?demo=on-device): Apple's on-device model suggests replies to a screen that asks in words, picks the right agent in a group, sums up a push and drafts a screen offline. It never answers as an agent, never sends without a tap and nothing leaves the phone; without Apple Intelligence the app works as it does today. No new Yui Lines word. Step 2, native in the app, is in the backlog.
• YUI-40: widgets for agent dashboards, App Intents for Siri, Shortcuts and the Action button. Step 1, the spec and a playground mock, shipped Sep 26 (Widgets and Siri, /playground?demo=widgets). Steps 2 to 4 landed Sep 30 and ride the next daily build: widget buttons (+check, cta, timer Start and Pause), three Siri intents, the Talk to Yui control, and the widget push relay. Large size and StandBy are later.
• YUI-191 (shipped Sep 29, Yui 0.6.0, build 370; Chris Sep 28): hold the Yui icon and your agents' shortcuts are there. Agents fill them with the drawer's menu shortcut lines they already send, you pick which four show in Settings, and a tap opens that thread with it sent. First one: Basil's Log food. No new Yui Lines word, no widget extension.
• Design system v1 from beta feedback.
• Decision gate: Android port (YUI-46, Kotlin + Jetpack Compose against the same Yui Lines suite), Apple Watch app (YUI-47), public launch.

Dependencies: beta learnings, payments setup (financial, needs Chris).

Preset library | what agents can build on your screen (Chris, Sep 24)

Simple first, flexible combinations always: layout and style are props, so a handful of presets cover a lot of experiences. Each family ships in the web playground first, then natively in the app.

• Media (YUI-16): gallery of images and videos with layouts feed, flat row, 3D row and grid; single video; before/after compare (slider, side by side, toggle) with highlights pointing at what changed; storyboards for videos, sites and posts with reorder and per-frame notes; image edit where you mark an area and say what to change.
• Data and science (YUI-17): line, bar, area, scatter, pie charts, live from agent tables; big-number stats with sparklines; rendered equations; a formula tool whose sliders redraw a chart as you move them; step-by-step derivations and protocols.
• Learn and plan (YUI-18): presentations built on any topic you want to understand, with generated images and a quiz at the end; workflows, starting with plan mode, a guided series of screens that ends in a project (saved, branching workflows authored in Mermaid: FLOW-1, step 1 on the web); narrated walkthroughs where the agent talks you through what changed, before and after, step by step.
• Media pipeline (YUI-21): agents generate and send real images and videos into Yui; your photos go back to the agent.
• Native versions (YUI-19) of all of the above.
• Games (YUI-59, built Sep 25; the app part shipped in build 74): tic-tac-toe against the agent, snake and memory match, each one Yui Line (game tictactoe), playable on the phone, moves and scores coming back to the agent. Live in the web playground now. Later, Yui Lines that describe a whole new game instead of picking one (YUI-60, spec draft written, parked by Chris for later).
• Drawings (YUI-83, web and spec shipped Sep 25; YUI-84, the app draws them, shipped in 0.2.0, build 122, Sep 25; TestFlight feedback, Chris: "draw a little window that has certain things crossed out and other things highlighted"): sketch draws a small window, phone or chat bubble with rows struck out, highlighted or called out with an arrow, and an optional before and after, so an agent shows a change instead of describing it. No image to generate, no screenshot. Live in the web playground, the MCP App and the app. A sketch right after a page is that page's picture on a full-screen story page, its rows coming on one by one.
• Shapes that move (YUI-104, shipped in 0.3.0, build 138, Sep 26; Chris: "simple SVG style vector graphics... to show some complex ideas very quickly"): shapes draws a small diagram in the chat, circles, boxes, blobs, labels and arrows that come on in order with a caption, so an agent explains how something works without generating a picture. Live in the web playground and in the app since Yui 0.3.0.
• Maps (YUI-158, step 1 shipped Sep 27: spec, all five parsers, playground at /playground?demo=map; step 2 on main Sep 27, app build 219, rides the next TestFlight build; step 3 shipped Sep 27, channel guide v37; TestFlight feedback Sep 27, Chris on the Mongol Empire answer: "this should be a Map"): map draws places instead of listing them: countries or drawn areas filled in the agent's colors, pins and routes that come on in order, as a card in the chat or a page picture on the stage. Step 1 the spec, every parser and a playground mock drawn offline with no map key; step 2 native, the same offline outline drawn in SwiftUI, pinch and pan on the stage; step 3 the channel guide teaches agents to answer "where" with a map.

Every agent looks like itself (YUI-20)

Chris, Sep 24: in most agent tools every agent sits in the same interface and the only tell is a tiny ID in a corner. In Yui each agent has its own color scheme, with light and dark, its own feel, and its preferred kinds of screens. Open Arnold and the whole app is Arnold's. Ask an agent to change its look and it restyles itself.

Look and feel | friendly by default, restyled by agents later

Chris, Sep 23: friendlier, a South Korean aesthetic, happy-cat energy, a little fun by default, light and dark mode. v1 (card YUI-2): soft pastels, rounded type, gentle spring motion, warm microcopy. The identity is typographic only (card YUI-9): the coral bunny-ear wordmark already reads as an abstract cat, so there is no mascot. Yui's avatar is the wordmark's Y; each agent gets its initial on a pastel chip.

Generative app styling (future). All styling lives in one token set (colors, radii, type, motion, agent avatar colors) stored as plain data, not code. That makes the app itself restylable at runtime: an agent sends a theme line in Yui Lines (for example theme peach round) or a full token set, and the whole app re-skins, within guardrails that keep contrast readable and tap targets big. Per-agent themes (Arnold in Arnold's colors) are the first use, shipped Sep 24 (YUI-20). A user asking "make Yui feel like autumn" is the second (YUI-43): step 1, the spec, the theme app line and a playground mock, shipped Sep 25 (Restyle Yui); step 2 is YUI-96, the native app.

Parallel track | Telegram fallback (any time)

If Apple rejects the app or it stalls, Telegram already supports most of what the pitch needs: inline keyboards with callback buttons, reply keyboards, and Telegram Mini Apps (full web apps inside Telegram, with theme colors, haptics, and cloud storage). The same Yui Lines can render as a Mini App using the web renderer. This is the insurance policy, card INT-4. Step 1 shipped Sep 25: adapters/telegram in the app repo turns a reply into Telegram messages (questions as inline keyboards whose taps come back as the phone's event line, the rest behind an Open in Yui button), and yuigui.com/tg is the Mini App, in the chat's own theme colors (spec/TELEGRAM.md). A bot that runs it is step 2 and needs its own Telegram bot token.

Adapters | every agent framework, Hermes first (INT-0)

Chris, Sep 24: Yui should work with any agent, not just ours. The full plan is spec/ADAPTERS.md. It all waits until the MVP passes.

There are only five ways in, so five pieces of code cover every framework:

• A plugin inside the agent's own app. Hermes today. OpenClaw and Flue next.
• A hosted connector that speaks a standard protocol: Hermes's relay contract, and A2A, which Gemini, LangGraph, CrewAI and Microsoft's Agent Framework all speak. The A2A part shipped Sep 25 as a bridge you run yourself (INT-18): add any A2A agent by its card URL, spec/A2A.md. The hosted version comes next.
• A model connector. Point Yui at any OpenAI-compatible API: Meta's Muse Spark, Grok, Gemini, or a model on your own machine through Ollama, LM Studio or vLLM. The local part shipped Sep 25 (INT-12): a bridge next to your model server, spec/MODELS.md. Cloud APIs come with the hosted connector.
• A Yui MCP server. Claude, ChatGPT, Grok and n8n add it as a tool and push screens to your phone. Shipped Sep 25 (INT-3) for clients that take a header, like Claude Code and Cursor: spec/MCP.md.
• A webhook. If your code can answer an HTTP request, it can talk in Yui. Shipped Sep 24 (INT-2): the webhook bridge, spec/WEBHOOK.md.

Every one of them ends in the same messages and the same screens, and every agent gets the same channel guide, so it knows it can draw.

Order: Hermes, OpenClaw and the webhook (done), then the MCP server, then Claude, ChatGPT, open models, Flue and A2A, then the rest. Each framework is a card on the board, INT-1 to INT-18.

Cloudflare

Chris mentioned a new Cloudflare agent he thought was called "Flue". Checked Sep 24: Flue is real, an open-source TypeScript agent framework from the team behind Astro, launched with Cloudflare in June 2026. It runs agents as Durable Objects on Cloudflare's Agents SDK and has channels for Slack, Discord and others, so a Yui channel fits (INT-13). Decided Sep 25 (INT-6, the hosting memo): Yui's hosted connector for paths B and C runs on Cloudflare Workers and Durable Objects through the Agents SDK, beside the Supabase relay, not replacing it. The relay, its limits and its kill switch stay in Postgres. Nothing is set up yet: a Cloudflare account is Chris's call when INT-12 or INT-18 reach their hosted step. His point about Cloudflare gating the agentic web (bot blocking) is relevant to connectors that scrape; Yui should prefer official APIs and MCP.

What stays out of scope for now

• A realistic human avatar you talk to (Chris: "I don't think we're going to do that right now").
• White label.
• Our own payment processing before Phase 6.
• Running the Claude CLI on the phone. Mobile goes through APIs (OpenRouter or Anthropic keys).

Risks

1. App Store review. The app only renders a fixed set of native presets and never runs downloaded code, which is the pattern Apple accepts (guideline 2.5.2). The open question is different: Yui needs an agent the user runs elsewhere, and a reviewer has none. The review notes say so, and a demo code opens an account with a scripted demo agent (YUI-27). If Apple still says no, the Telegram Mini App fallback (INT-4) and a built-in starter agent (YUI-37) are the ways around it.
2. Bad screens. Agents will get lines wrong. Mitigated by a small preset set, one parser spec with a shared conformance suite on web and Swift (YUI-3), a parser that forgives the slips agents make most, and a channel guide scored by an eval (YUI-10).
3. A shared backend open to strangers. Anyone with the beta can reach the relay. Mitigated by per-account and per-computer rate limits, size caps, a kill switch and 90-day message retention (YUI-26). Strangers bring their own agent and model, so their usage costs Yui no inference.
4. Nobody outside has done the whole path yet. Every step works for us; YUI-29 is the first outside tester running it alone with a stopwatch. What they trip on is the next work.
5. Scope. Every phase is cut to one demo that works. New ideas go on the board, not into the current phase.

Open questions for Chris

1. ANSWERED Sep 23: all Swift, iPhone first, no Watch yet, Android later.
2. ANSWERED Sep 23: yuigui.com goes live now. Built in public.
3. ANSWERED Sep 23: enrolled and paid, no D-U-N-S. Trademark search deferred until there is something to protect.
4. Should agents that do client work be in Yui at all, given client confidentiality, or is Yui for personal agents only for now?
5. Is Yui a product you intend to sell, or a personal tool that might become one? It changes how much Phase 4 to 6 matters.

Deep backlog

Parked cards, so the build never runs dry. None of these start until the MVP lane has nothing ready. Each one is on the board with a short brief. Anything that spends money or reaches out to people still needs Chris first.

The app

• YUI-113 (shipped in 0.3.1, build 160, Sep 26; TestFlight feedback Sep 26, Chris: "I want all that to be in one experience"): a lesson is one swipeable deck. A deck page carries a diagram, formula, chart, stat or calc as its picture (all five parsers, playground, app), channel guide v26 asks for one deck, and phones on older builds get the v25 full-screen layout until they update.
• YUI-89: agent tables in the app, step 2 of YUI-33 (the spec and the playground shipped Sep 25): the phone's store, native views, the other parsers.
• YUI-34: a key vault for your own fal, Replicate, OpenRouter, Anthropic and OpenAI keys. Step 1 (spec + playground mock) shipped Sep 26: Key vault, /playground?demo=vault; step 2, the vault native in the app, shipped Sep 29 in build 370.
• YUI-35: photo of a meal to a macro estimate to a row in your macros table. Step 1 shipped Sep 25: Meal photo to macros, /playground?demo=meal. Step 2 (YUI-103) shipped Sep 27 in native Basil: a photo and a few words, an answer at once, the macros worked out behind the scenes, one breakdown, a food memory.
• YUI-36: optional encrypted sync for agent tables, off by default. Step 1 shipped Sep 26: Encrypted sync, /playground?demo=sync. Decision: not in v1; step 2 (native, in the app and the relay) waits for a second Yui device.
• OSS-6: Yui@home, the machinery. Step 1 shipped Sep 26: the agent-ready backlog, exported from the board to /contribute and backlog.json (a card is claimed by a draft pull request titled with its key; the first one merged wins), CONTRIBUTING-AGENTS.md and AGENTS.md in both repos, and a feature spec template. Step 2 shipped Sep 26: weekly routine prompts for Claude, Codex, Jules, Cursor, Copilot and any agent on /contribute, each checked against its platform's docs; checks CI on every pull request in both repos with no secrets, CODEOWNERS on CI, signing, release and generated files, no auto-merge; a merged [KEY] pull request closes its card, and credit on /progress is opt-in. Left: the first real run end to end, on a throwaway fork.
• YUI-77: group threads, several agents in one conversation (split from YUI-44; @mentions shipped in build 82). Step 1, the spec and a playground mock, shipped Sep 25 (Group threads: the agent you @ answers, else the lead; a handoff row between agents; a hop budget with a Let it / Stop here guard; a thread id of its own). Step 2, the database and the Hermes plugin, reached phones with Yui 0.3.0, build 138 (YUI-93: group tables and routing live, hop budget, turn cap, Let it and Stop, host notes, channel guide v20 with a Groups section). Step 3, the native app, landed Oct 1 (YUI-94: the New group sheet from the agent list, groups with stacked faces, the thread with each agent in its own look, @ suggestions, swipe-reply to the author, per-agent working rows with Stop, handoff and guard rows, status lines, group settings, the Update chip; unit tests, a simulator run and an end-to-end run with two real adapters, light and dark). It rides the next release: group_min_build is 437.
• YUI-47: Apple Watch, timer and quick answers on the wrist (parked by Chris until after the MVP). Build to earn: open to outside contributors.
• YUI-60: Yui Lines that describe a game (board, pieces, rules, win), so agents can make new ones. The spec draft is written (Games: a board kit, three sample games, what Apple's rules allow). Parked by Chris on Sep 25: no build until he picks it back up.

People with no agent yet

• YUI-37: a starter agent that works with no setup. Step 1 (spec, cost model, playground mock) shipped Sep 26; step 2, the hosted build, waits on Chris's sign-off for Cloudflare and spend.
• YUI-38: an onboarding interview that suggests your first agents. Step 1 (spec + playground flow) shipped Sep 25; step 2, native in the app, after 0.2.0.
• YUI-39: log in to your tools once (Google Calendar, Gmail, HubSpot) through MCP. Step 1 (spec + playground flow) shipped Sep 25; step 2, real sign-in on the agent's host, waits on Chris's sign-off for the Google and HubSpot app registrations.

Smarter and faster

• YUI-41: an on-device model answers the easy things for free. Step 1 (spec + playground mock) shipped Sep 26; step 2, the model on the phone native in the app, is in the backlog.
• YUI-42: the preset flywheel. Log custom screens, turn the repeats into presets. Shipped Sep 24: the Hermes plugin logs custom shapes (never values) when its owner turns it on, a weekly report flags repeats, checklist in spec/FLYWHEEL.md.
• YUI-43: restyle the app by asking ("make Yui feel like autumn"), with contrast guardrails. Step 1 shipped Sep 25: Restyle Yui, theme app in the parser, /playground?demo=restyle.
• YUI-96: step 2 of YUI-43, the native side, built Sep 25: the preview card (Now beside the new look, light and dark, Use or Keep mine, then Undo), the chrome that follows the look while agent threads keep theirs, Settings > Look with Back to Yui's look, the look saved on the account, and the host gate. Rides the next Yui release.
• YUI-40: widgets and Siri, so agents work outside the app. Steps 1 to 4 landed (spec, mock, native widgets, App Intents, push relay); steps 2 to 4 ride the next daily build.

Flows

• FLOW-1: flows. A saved series of screens, written in Mermaid, that any agent can run: client intake, scoping a project, an investor deck. Agents can make variants. You manage your flows in the app. Step 1 done Sep 25: spec/FLOWS.md (steps on the nodes, conditions on the edges, one {flow} event with the path), the JavaScript parser and the web runtime, three starter flows in the playground (website intake, self-scoping, workout check-in). Step 2 done Sep 26: every parser in the hub (JavaScript, Python, Kotlin, Rust) runs the same 36 flow vectors (starter flows, conditions, bad Mermaid, cycles), the spec says what the phone keeps per run and how it resumes after a kill, and the playground mocks My flows (/playground?demo=myflows). Step 3 done Sep 26: agents make variants, their own version of a saved flow in a few lines (flow website-intake as=restaurant-intake, then drop, reword or add steps), read by all four hub parsers (23 new vectors, 683 each), run in the playground (/playground?demo=flow-variant) and listed under their base in the library. Next: YUI-115, the app runs flows and variants, then My flows in the app.
• FLOW-2: a library of components and flows on yuigui.com that people browse and agents can search and "shop". Later, a store. Step 1 done Sep 25: /developers/library (every screen drawn live, every flow as its chart, search in the browser) and /library.json. Step 2 done Sep 26: agents look it up by intent at /api/library?q= and with the yui_library MCP tool (one ranking for the page, the endpoint and the tool; a flow comes back with its Mermaid), channel guide v28 names the saved flows, and the library check runs before every site build. Step 3 done Sep 26 (with FLOW-1 step 3): variants agents make are listed under their base on /developers/library and in /library.json, and /api/library finds them (the restaurant intake). Next: a store.

Other agents and channels

• INT-1 (done Sep 24): an OpenClaw channel plugin. Install it, pair with the app's code, and your OpenClaw agent answers in Yui.
• INT-2 (done Sep 24): a webhook bridge in Python and Node. If your agent can answer an HTTP request, it can talk in Yui.
• INT-3 (done Sep 25): a Yui MCP server, so any MCP agent can draw a screen. Claude Code and Cursor today; OAuth for the Claude and ChatGPT apps is INT-19.
• INT-4 (step 1 done Sep 25): the Telegram fallback: Yui Lines as buttons and a Telegram Mini App (spec/TELEGRAM.md). Next: a bot that runs it, then a live test.
• INT-5: connect without installing anything, through a hosted connector.
• INT-6 (done Sep 25): where the hosted connector runs. Cloudflare, beside the Supabase relay (spec/HOSTING.md).
• INT-7 (built Sep 25, one look in claude.ai left): Claude, through the MCP server, and Yui screens drawn inside Claude as an MCP App.
• INT-8 (built Sep 25, one look in chatgpt.com left): ChatGPT, the same way, as a developer-mode connection.
• INT-9 (step 1 done Sep 25): Gemini, as a model (--server gemini on the model bridge, spec/MODELS.md) or as an A2A agent (a Google ADK agent, spec/A2A.md). Next: one live call with an AI Studio key, then the hosted connector.
• INT-10 (step 1 done Sep 25): Grok, as a model (--server grok on the model bridge, spec/MODELS.md) or calling the MCP server from a Responses API request (spec/MCP.md). Next: one live call with an xAI key, then the hosted connector.
• INT-11 (step 1 done Sep 25): Meta's Muse Spark, as a model (--server meta on the model bridge, spec/MODELS.md). The Model API is in public preview for US developers. Next: one live call with a Model API key, then the hosted connector.
• INT-12 (step 1 done Sep 25): open models on your own machine (Ollama, LM Studio, vLLM) and any OpenAI-compatible API. Today as a bridge next to the model server (spec/MODELS.md); cloud APIs on the hosted connector next, with YUI-34's key vault.
• INT-13 (step 1 done Sep 25): a Yui channel for Flue. A Flue app on Node dials out to Yui, and each turn goes to the agent through Flue's own dispatch; the blueprint for flue add channel is in the app repo (spec/ADAPTERS.md "Flue"). Next: on Cloudflare, Yui pushes turns to the channel's signed route once the hosted connector exists (INT-20, and a Cloudflare account).
• INT-14 (step 1 done Sep 25): LangGraph, as an A2A agent on LangGraph's own Agent Server; the guide reaches the graph's state (spec/A2A.md). Next: the hosted connector.
• INT-15 (step 1 done Sep 25): CrewAI, as an A2A agent served by CrewAI's own A2A server config; the guide goes into the agent's backstory (spec/A2A.md). Crews run as scripts use the webhook bridge. Next: the hosted connector.
• INT-16 (step 1 done Sep 25): Microsoft Agent Framework, the successor to AutoGen, as an A2A agent served by its own A2AExecutor; the guide goes into the run's instructions (spec/A2A.md). The AG-UI spike says Yui can be an AG-UI client: parked as INT-21. Next: the hosted connector.
• INT-21 (step 1 done Sep 25): an AG-UI client, so any agent served over AG-UI (Agent Framework, CopilotKit, Mastra, Pydantic AI) joins by its URL. Yui screens are a frontend tool the agent calls, yui_show, and the tap comes back as the tool's result. Today as a bridge on your own computer (spec/AGUI.md); hosted with INT-18's. Open for Chris: A2UI as a second screen format (recommendation: not now).
• INT-24 (step 1 done Oct 6): where Yui can plug in today, every model provider (OpenAI, Anthropic, Google, xAI, Meta, Mistral, Apple): sign in, app surface, directory rules, and a ranked ship-first list (spec/ECOSYSTEMS.md). Research only; every listing, application or waitlist is Chris's call.
• INT-17 (step 1 done Sep 25): n8n, as a node ("Yui: ask and wait"), through the MCP Client Tool and through a Webhook trigger (spec/MCP.md "n8n"). Next: publish the node on npm and n8n's community list.
• INT-18 (step 1 done Sep 25): an A2A client, so any agent with an Agent Card can join. Today as a bridge on your own computer (spec/A2A.md); hosted next, once Yui has a Cloudflare account.
• YUI-48: text an agent from any phone over SMS.

Money and platforms

• YUI-45: pay-as-you-go credits for images and hosted models.
• YUI-58: Yui for macOS, a matching desktop app under the same App Store listing. The first card marked for Yui@home contributors. Build to earn.
• YUI-71: Yui in the browser. Replaced on Oct 1 by the epic YUI-240 to YUI-250, first in line under Next after the MVP, at full parity and built by us. Watch and desktop still translate Yui Lines where they must: what fits renders, the rest says "open on your iPhone".
• YUI-109 (folded into YUI-242, no longer agent-ready) and YUI-110 (agent-ready): the first pull request of the Mac app stays open to outside contributors on /contribute; the browser's first pull request is built in house.

Running Yui

• YUI-72 (scope done Sep 25, spec/ADMIN.md): the admin console. Five roles (owner, super user, admin, support, a client's own admin), what each can control (invites, accounts, default agents, the kill switch and limits, feature flags, announcements, feedback, usage numbers, an audit log). Recommendation: an Admin section inside the app, Sign in with Apple plus a role row, a second check for anything destructive. Admins never read messages. Three phases and six card candidates wait on a pick. Read it: admin console.
• YUI-46: Android, starting with a prototype that passes the shared test suite.

Open source and the site

• OSS-2 (done Sep 24): Yui Lines parsers in Python and Kotlin, next to the JavaScript and Swift ones.
• OSS-4 (done Sep 25): a Yui Lines parser in Rust, a crate with no dependencies (parsers/rust). All 445 vectors pass, and it matches the JavaScript parser on 35,000 random documents.
• OSS-8 (agent-ready): a Yui Lines parser in Go, open to outside contributors on /contribute.
• OSS-3: the public backlog mirrored as GitHub issues for contributors.
• BIZ-6 (done Sep 24): who the first 20 to 50 outside testers are, and where they gather. Read it: beta list.