Small context. Total recall.
An AI agent pays for its memory the expensive way: every step, it re-reads everything it has ever seen. PMO gives Muse Code a permanent memory of the project instead. Same work, same quality, less than half the tokens. The story in ten pages with a voiceover, about three minutes:
Try it in the dashboard: four things worth doing.
Open a chat and give it one of these. Each one wakes a different skill. You will see which one fired in the reply.
Just chat, or run a project
Talk normally, ask questions, or point it at a project folder. This is the everyday chat skill. No trigger word needed.
Try: "Here is my project folder. What does it do, and what should I work on next?"Just ask it to code
Give it a coding task in a folder with code. It reads the files, makes the change, and runs the checks.
Try: "Add a new feature to this repo and run the tests until they pass."Say research and debug
Include the words research and debug and watch it use the reasoning skill: it researches with sources instead of guessing, and debugs by measuring.
Try: "Research the best way to fix this bug, then debug why it happens. Show your sources."Attach a picture, get a model
Attach a reference image like the one below and ask for a game-ready model. The picture gives the AI a head start on a high-quality build. Front, side and back views work best.
Try: "Build this as a game-ready 3D model, textured and rigged." + attach the image.jpg)
Why it matters globally
Long context was the workaround. Memory is the fix.
Today every step re-reads the whole history. PMO keeps memory outside the chat instead: a ~3k card, roll over at 50k. The bigger window stops mattering.
Meta’s Llama 4 now advertises a 1M token window (Maverick) and 10M (Scout). That window is a model limit, not GPU memory: on a 70B class model, filling 1M tokens needs about 328 GB of KV cache at full precision, more than one modern GPU holds. PMO sends a ~3k card instead: −73% input tokens at the same quality, so one GPU serves about twice the users.
PMO halved pooled cost. At that rate, one frontier lab’s projected ~$14B inference bill for 2026 falls by about $7B.
Data-centre demand nearly doubles by 2030. Halve the re-reads and every answer costs half the power: AI a school or clinic can afford, not just a $20/mo luxury.
Not a bigger window. No need for one.
Sources and estimates
- PMO −51% and −73%: measured paired runs. Full data in Test Data, at the bottom of this page.
- Meta windows: Meta Llama docs: Llama 4 Maverick 1M tokens, Scout 10M tokens. A window is the most the model accepts, not memory on one GPU.
- ~328 GB cache: standard KV-cache maths, 2 × layers × KV heads × head size × bytes. Llama 3 70B (80 layers, 8 KV heads, 128 head size, BF16) is 320 KiB per token: about 40 GiB at 128k, about 328 GB at 1M. Full precision and full cache; compression, chunked attention (Llama 4 iRoPE) and FP8 cut the effective figure, and serving spreads it across GPUs.
- One GPU holds 80 to 192 GB: NVIDIA: H100 80 GB, H200 141 GB, B200 about 192 GB, before model weights.
- ~$14B → ~$7B: reported 2026 inference projection for one lab, with PMO’s −51% applied. An illustration of scale, not a promise.
- 415 → 945 TWh: IEA, Energy and AI (2025), 2024 to 2030.
02 / The engineering, in one picture
How it works, and why it works so well.
Three design choices do most of the work: capture from what Muse already wrote (no extra model calls), memory outside the project (nothing in your folder changes), and a fresh session instead of a compacted one (the rules survive; the landfill does not). Click any box for the engineering detail.
Click a box for detail. Numbers are the order of one message.
Standing rules verbatim, facts from chapters read sessions earlier, decisions taken: searchable across handovers, surfaced only when a message needs them.
A live file map with functions and tests, the commands that ran, the failures and the fixes; open issues close when a fix passes. Pointers to the functions a request will touch, ranked by a reranker over change frequency and the call graph.
The reading plugin maps long manuscripts from their bytes (headings with line numbers, encoding, where the writing stopped) but only at a handover that touches long prose.
03 / The control room
The dashboard, in thirty seconds.
A local, ChatGPT-style front end for Muse Code: it drives muse serve through the official SDK and keeps everything on your machine. It was built to make PMO's memory visible and measurable, and it grew into the control room around it.
- Live cost + token meters
- Fresh vs cached input and output per turn, per chat, per project, priced from Meta's own catalogue in API-key mode.
- Memory handovers, on screen
- Handover dividers in the chat, a PMO chip in the header, and Load earlier walks back across sessions.
- Files + preview panel
- Every file a reply names becomes a chip: pages run on their own origin, 3D models (GLB, FBX, OBJ, STL, PLY) open in a viewer, PDFs, Word and Excel render in the page.
- Snapshots + undo
- One click saves the folder before risky work; Undo restores it byte-exact without touching your branches. Deletions go to the Recycle Bin.
- Queue, nudge, push
- Talk while a reply runs: queue a message, nudge it live, or push it through; attachments survive chat switches.
- Connect, approve, schedule
- A Connect dialog for sign-in or an OS-encrypted API key; approvals as cards; scheduled jobs wake chats on their own; Blender and the background remover are found for the skills.
04 / For the engineers
Built to be trusted, not just demoed.
Plain Node and plain Python, no framework, no build step, nothing loaded from a CDN. Every claim on this page has a test or a logged run behind it. Open a card for the detail.
Images are the hole in the token budget.
PMO counts text carefully. Images are not counted yet, and they should be: a picture is not free context. On public vision models an image costs roughly 1,200 to 2,600 tokens at the sizes this page itself uses, it is paid again on every later turn while it stays in the chat, and at a PMO handover it forces a bad choice: drop the picture and lose it, or attach it again and pay again. That is the next place PMO can save, and the next skill to test.
Measured on this page's own stills (1,168×784 to 1,712×1,152) with the public 28×28 patch formula. One image can equal PMO's whole ~3k memory card.
A 1,560-token screenshot kept for 20 more turns is about 31k token-reads, plus the GPU cache held for every one of those tokens while the chat lives.
Resize or crop for the task, describe once into PMO memory, and re-attach full detail only when a task truly needs it. Promising, unproven, and not claimed as a saving until it is measured.
Research needed before we build it: first measure how Muse itself counts and re-sends images in a real PMO chat, because the figures above come from public vision-model pricing, not from Muse. Then run paired tests: right-sizing and cropping against quality, a written description in memory against keeping the pixels, and the 3D reference case where detail is the whole point. The skill ships only if quality holds at a stated check, the way every other number on this page had to.