open-mcp-apps
Summary: open-mcp-apps is a persistent, versioned app-and-data engine that lets an AI author, save, open and operate reusable single-file UI widgets with shared data, files, an App Store and app functions — all riding the MCP Apps bridge.
Author & manage apps in a registry — read the authoring guide (
get_app_guide), create or update apps (save_app), make surgical source edits (edit_app), read source in windows (get_app), list apps (list_apps), promote visuals (promote_app), and browse/roll back history (list_app_checkpoints,restore_app) or delete apps (delete_app, with tombstone or cascade).Open apps as interactive widgets — the universal
open_apprenders any registry app inline, themed and persistent, reusable across chats; the internalget_app_htmlbacks the loader.Operate persistent, versioned data — add, update, move and delete items (
data_add_item,data_update_item,data_move_item,data_delete_item) or batch up to 200 writes in one transaction (apply_data_writes); read pages and filter (data_list), list collections (list_data_collections), and track changes since a mark (data_changes,get_data_version). All mutations are idempotent (command_id) with optimistic concurrency.Store and retrieve app files — list, read, write and delete per-app files, including chunked uploads for large files (
file_list,file_read,file_write,file_write_begin/chunk/commit,file_delete).Install ready-made apps — browse the built-in App Store and install or update entries (
app_store_list,install_from_app_store), with live sandboxed previews (preview_app_store_entry).Run app-defined functions —
call_functionexecutes code declared by an app (data in, data out, may make network requests).Configure shared preferences and security — describe the engine-owned preference catalog (
get_ui_preference_schema) and write reservedsecurity:*/policy:*keys (security_set) that generic data tools cannot touch.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@open-mcp-apps show my kanban board"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
open-mcp-apps
English | 简体中文
Give your AI a persistent, reusable UI. It builds the app once — you keep it forever.
open-mcp-apps is an open engine built on MCP Apps
(ui://, io.modelcontextprotocol/ui) — an extension to the core Model Context Protocol
specification, and the first official one,
live since 26 January 2026. It gives any MCP-Apps-capable host (Claude Desktop, claude.ai, Codex,
ChatGPT, …) three things the extension itself doesn't provide:
An app registry the AI can write to. Ask for a UI that doesn't exist — the AI reads the authoring guide, writes a single-file HTML app against a tiny
window.omaAPI, and saves it. From that moment you can open it by name, in this chat and every future one.Persistent, versioned data — separate from the UI. Apps bind to generic collections of items backed by SQLite plus an append-only
change_eventledger. Every mutation is an idempotent domain command (command_id) with optimistic concurrency (expected_version). The AI and the human edit the same store — the widget is just a view.A shell runtime so AI-written apps actually work. Serving
ui://, the engine wraps the app with the official MCP App bridge, host theming (Claude's design tokens, light/dark), and thewindow.omadata API. What you write is a view; the protocol, persistence, idempotency and theming are the engine's problem.
Which of those hosts this engine reaches. It runs on your machine and binds 127.0.0.1, so it
serves the hosts on that same machine: Claude Desktop, Claude Code, Codex, plus its own browser
viewer. A browser host cannot reach a loopback server on your laptop, so claude.ai and ChatGPT web
need a remote deployment — today that means the hosted openmcp.app, which
runs this same engine for you. Running that remote shape yourself is on the roadmap and not done.
Version | 0.10.1 ( |
License | MIT, whole repository ( |
npm |
|
Command |
|
Requires | Node 22 or newer. |
Surface | 34 tools · a built-in App Store · 3 system apps seeded |
Platforms | macOS · Windows · Linux |
Hosts | Claude Desktop · Claude Code · Codex · ChatGPT web — see Host support |
Hosted | openmcp.app — the remote shape, and the way to reach browser hosts (claude.ai, ChatGPT) |
Install
open-mcp-apps runs as a local MCP server. First get it connected to your host (below); then onboarding happens inside the host, separately — that's where the AI builds your first app.
From npm — nothing to clone
If you are comfortable editing your host's config file, point it at the published package and
let npx fetch the engine. This path needs only Node 22 — no git, and no checkout for you to
keep updated. Paste this into your host's MCP server config:
{
"mcpServers": {
"open-mcp-apps": {
"command": "npx",
"args": ["-y", "@2nd1st/open-mcp-apps"]
}
}
}The one thing the installer below adds is registering the server into every host it finds. Either
way the server seeds the system apps (settings, dashboard, App Store) when it starts, and your data
lives in the same fixed per-user store, so you can move between an npx server and a cloned one
without migrating anything.
A note on npm: this project publishes under the scoped name
@2nd1st/open-mcp-apps. The unscopedopen-mcp-appson the registry is not this project — that name is held by an unrelated package. Check for the@2nd1st/prefix; the scope is the only thing telling the two apart.
With the installer — one command
Installing needs a shell, so the chat apps (Claude Desktop, Codex) can't install themselves — use one of these instead:
curl -fsSL https://raw.githubusercontent.com/2nd1st/open-mcp-apps/main/install.sh | shIt opens a short picker to choose which hosts to register into — Claude Desktop, Claude Code,
Codex — plus your permission preference. Skip it with -s -- --yes, or target one host with
-s -- --host codex.
Where it puts the clone, before you pipe anything into a shell: ~/open-mcp-apps. Set OMA_DIR
to put it somewhere else — curl -fsSL <url> | OMA_DIR=~/src/oma sh. Re-running the one-liner
updates that same clone in place instead of making a second one. Your apps and data are not in it
(they live in the per-user store under Configuration), so the folder is safe to
move or delete — and node uninstall.mjs does not delete it for you.
With a coding agent (Claude Code, Codex CLI — they have a shell), paste:
Read https://raw.githubusercontent.com/2nd1st/open-mcp-apps/main/install.md and follow it.
Either way, install.mjs registers the server into each host you pick, idempotently — it never
clobbers your other servers, pins a stable node launcher (native SQLite ABI), reports what
changed, and cleans up a pre-rename entry if one lingers. Your data lives in a fixed per-user
store (not inside the clone), so every host shares the same apps and data.
From a clone — for development
git clone https://github.com/2nd1st/open-mcp-apps && cd open-mcp-apps
npm install
node install.mjs # same picker as the one-liner aboveTo wire a clone into a host by hand instead, point it at the checkout — this is the shape
install.mjs writes:
{
"mcpServers": {
"open-mcp-apps": {
"command": "node",
"args": ["/absolute/path/to/open-mcp-apps/src/server.mjs"]
}
}
}Hosted
openmcp.app runs the engine for you. The engine in this repository binds
127.0.0.1 by design, so a self-hosted remote deployment is not a supported shape yet — see
Status and roadmap.
Uninstall
node uninstall.mjs unregisters the server from every host it finds — but keeps your data:
the shared store stays put, so re-installing later restores every app and all data. It also leaves
the installer's clone (~/open-mcp-apps, or wherever OMA_DIR pointed) on disk — nothing here ever
deletes that folder, so remove it yourself when you want the checkout gone.
node uninstall.mjs # unregister from all detected hosts — keeps your data
node uninstall.mjs --purge # also delete the shared store (apps + data), irreversible
node uninstall.mjs --check # read-only: show what's registered and what would changeRelated MCP server: AI PC Assistant MCP Server
Requirements
Node 22 or newer, on macOS, Windows or Linux.
git— only on the installer path. Thenpxpath above needs neithergitnor a checkout. The installer checks for both and stops with a message rather than half-installing if either is missing.A host that renders
ui://if you want widgets in the conversation. Terminal hosts (Claude Code in a terminal, codex CLI) drive the same data by design and put the UI on a browser screen beside the terminal instead — one that can follow along, showing whatever the AI just opened. The per-host detail is in Host support.After installing or updating, fully quit and reopen the host (Cmd-Q, not just closing the window) — it keeps its old server process on the old data until fully quit.
Configuration
Every setting is an environment variable, set in the env block of your host's MCP server entry:
{
"mcpServers": {
"open-mcp-apps": {
"command": "npx",
"args": ["-y", "@2nd1st/open-mcp-apps"],
"env": {
"OMA_VIEWER": "1",
"PORT": "8787"
}
}
}
}Variable | Default | What it does |
|
| The browser viewer on loopback. |
|
| Where the viewer listens. |
| per-user store | Path to the SQLite store. Set it to isolate a store. |
| — | Extra App Store sources: folders laid out like the store package's |
| on |
|
An app's own tool. Every app opens through open_app. To give one app its own open_<name>
tool as well, pin it: Settings → Installed → the app → Own tool. The tool list changes only
when you pin, unpin or delete a pinned app, and Claude.ai and ChatGPT show the new tool after you
refresh the connector's tool list.
Where your data lives. The whole store is one SQLite file, open-mcp-apps.db, in
~/Library/Application Support/open-mcp-apps/ (macOS), %APPDATA%\open-mcp-apps\ (Windows), or
$XDG_DATA_HOME else ~/.local/share/open-mcp-apps/ (Linux). It is outside any clone, which is
why every host shares the same apps and data.
First-run permissions. The first few tool calls each show an approval dialog — pick
"Always allow". The tool set is small and stable on purpose: read-only tools generally
skip approval, and the single open_app tool covers opening every app (including ones the AI
creates later) behind that one grant, so nothing new asks again. An OMA_DYNAMIC_TOOLS=1 left in
an older entry does nothing; node install.mjs --check reports it as stale, and re-running the
installer removes that one key.
You can also batch approvals in Settings → Connectors → open-mcp-apps → Tool permissions.
Usage
Start in your host. Restart it after installing. New here? The engine ships one MCP prompt,
get_started. A host that surfaces prompts lists it as Get started with open-mcp-apps; hosts
that render prompts as slash commands spell it /mcp__open-mcp-apps__get_started. Picking it hands
the AI the whole opening move. Not every host surfaces prompts — where yours doesn't, nothing is
lost, because the prompt is just a sentence you can say yourself: "I just installed open-mcp-apps
— show me how to use it with a couple of examples, and suggest a few apps that fit how I work."
Either way it looks at what you already have and what the App Store already offers, asks you a
couple of questions, and sets up a first app tailored to you. This step is separate from install and lives in the host. Or just ask directly:
"make me a board for what I'm juggling right now" → the AI writes it, seeds it, and opens it (persistent)
"make me a habit tracker" → watch it read the guide, write the app, save it, open it
close the app, reopen, ask again → everything is still there
The loop
"make me a kanban"
│
▼
list_apps ── exists? ──► open_app {app: "kanban"} (reuse, instant)
│ no
▼
get_app_guide ──► AI writes HTML ──► save_app
│
▼
open_app {app: "kanban"} → rendered inline, themed, persistent — reusable in every future chatApps accumulate. Each one is single-purpose and independent — a board, a tracker, a splitter — minted for the task in front of you and kept for the next time you need it.
What it looks like
Apps render inline, in the chat you were already having. Ask for one and the AI writes it:

Come back in another chat — or another host — and it's still there, with your data in it:

The App Store ships ready-made apps, with working previews and one-click install. They live in
their own package, @openmcp-app/oma-store, which the
engine installs as a dependency — new store apps are contributed there:

|
|
|
|
Every app above is a single HTML file bound to plain data collections — written with the same
window.oma API and authoring guide your AI will use for the apps it builds you.
Multiple widgets in one conversation work fine (habit-streaks + meal-planner side by side).
The browser viewer, and the port it binds
Every install runs a small local web server on http://127.0.0.1:8787. It is how you see your apps outside a chat window — one page per app, the same data your AI is reading — and in a terminal host it is the only way to see them at all, so the AI hands you the link when it builds or opens something.
It starts on its own; OMA_VIEWER and PORT above change that. If the port is already taken by
another open-mcp-apps process, that one is already serving the same data and this one just shares
its address; if it is taken by something else, you get no viewer and no links rather than a link
into a stranger's server.
There is no password on it, and that is deliberate. The listener is hard-wired to 127.0.0.1,
so there is no setting that makes it answer from another machine. Any program on your computer that
could reach the port can already open the SQLite file directly — a password would be a lock beside
an open wall. The one way this reaches the internet is a tunnel you start yourself, which is its own
deliberate decision; while a tunnel is up, treat its URL as a secret, because it is currently the
only thing standing between the internet and your data.
Host support
Live-tested 2026-07-22 (ChatGPT web 2026-07-28), except cells that carry their own date. A date says when a cell was true, not that it was checked again since.
Host | Renders widgets | Human clicks widget | AI operates data | Same store |
Claude Desktop (local stdio) | ✅ — re-checked 2026-08-16 on 1.30096.5: the universal | ✅ full loop incl. | ✅ | ✅ |
Browser viewer ( | ✅ | ✅ (no chat attached — | via CLI AI | ✅ |
Codex desktop (ChatGPT app, | ✅ experimental | ◐ updates/toggles from widget clicks work; adds were blocked host-side. The umbrella request openai/codex#28912 (an | ✅ | ✅ |
Claude Code — in a terminal ( | — in the chat, by design (text fallback) — but see a screen beside the terminal | — in the chat | ✅ | ✅ |
Claude Code — the Code surface inside the Claude app | ✅ live-tested 2026-08-16: an app opened with the universal | not measured on this surface | ✅ | ✅ |
codex CLI / IDE | — in the chat, by design (text fallback) — but see a screen beside the terminal | — in the chat | ✅ | ✅ |
ChatGPT web (Work mode) | ✅ live-tested 2026-07-28 (remote HTTPS) — renders at full height, no clamping; a widget loses its data after a page refresh (mitigation shipped, awaiting live re-test here — see KNOWN-ISSUES) | ✅ a widget button added a row and it stuck | ✅ | ✅ |
Everything rides the MCP Apps bridge, so host fixes upstream (e.g. #28912) benefit this project with zero changes.
On Claude Code specifically: it is one product with two surfaces, and only one of them can
draw — which is why it takes two rows. In a terminal there is no inline widget surface at all: that
is architecture rather than a gap, and it is exactly what a screen beside the
terminal is for. The Code surface inside the Claude app has a UI and
renders inline; the 2026-08-16 reading there came through the universal open_app.
On Codex specifically: plugins are registered on the web side, so a locally-installed engine is reached as an MCP server, not as a plugin — which is the right path for a self-hosted install anyway. Widget rendering in the ChatGPT desktop app also appears to depend on how you are signed in (we have seen it work under an account sign-in; not yet established under an API key).
A screen beside the terminal
Those two — cells say the chat shows text. They do not say there is no UI. The
engine remembers which app was opened last and pushes that pointer to the viewer on the /events
frame, and an app can place a region — oma.embed("@live", {into}) — that mounts whatever the AI
opened last and swaps itself when the AI opens another. The App Store ships one: install live,
open http://127.0.0.1:8787/view/live in a window you then leave alone, and the terminal keeps the
conversation while that screen shows the app. The AI opens or writes from the CLI, the screen
follows, and you can click, edit and type into it there. Headless CLI use is what it was built for.
The cheapest form of "that screen" is a browser pane in the same tiled workspace — one column over from the agent, in the window you are already working in. Same machine, no tunnel, no second device; most modern terminal setups can put a browser next to a shell, and that is all this needs. A second monitor is the same idea with more desk, and a screen on another device is the same idea again with the caveat below.
The costs are real and worth stating plainly. There is still no widget in the transcript.
sendMessage degrades to a notice on a standalone page, exactly as in the Browser viewer row —
clicks change data, they do not talk back to the chat. The viewer has to be running (OMA_VIEWER,
on by default) with a browser pointed at it; this is not zero-config. And the listener is bound to
127.0.0.1, so "a spare tablet on the wall" means this machine's screen unless you put up the
tunnel described above and accept what that section says about it. Inside a chat host the same
region deliberately draws a placeholder instead of following anything.
Described from the code as built, not measured on a host — the live-test dates above cover the table, not this section.
Writing an app yourself
The AI is the usual author, but it isn't the only one — its context window shouldn't be the ceiling on what an app can be. Build one in your own editor, with your own bundler, and install it:
node install-app.mjs ./my-app.html # yours, full trust — same as an AI-authored app
node install-app.mjs ./my-app.html --sandboxed # untrusted: runs behind the runner, no capabilities
node install-app.mjs --list # what's installed, and under whose provenance
# a build pipeline's output: a readable template + its bundle, plus the declaration as its own file
node install-app.mjs ./ui.html --name my-app --manifest ./manifest.json \
--asset ./dist/app.js --asset ./dist/app.css --updateTwo shapes are accepted. One self-contained HTML document — no size cap (keep it lean: data
lives in the collection, source is read in windows) — the engine injects a minimal base style, the
host's design tokens and window.oma. Or a template plus a bundle: the HTML is a readable mount
point that references its own build output (<script type="module" src="oma-asset:app.js">,
<link rel="stylesheet" href="oma-asset:app.css">), --asset pushes those files into the app's
file plane, and the engine inlines them the moment the document leaves the store — a host iframe
cannot reach this machine.
The trade: the AI can no longer iterate on it — your files are the source of truth, you rebuild
and re-install. It can still read a single-document app's source; for a template + bundle app it
reads the template and the bundle stays yours (edit_app and the AI's save_app refuse with
built_outside; re-running the command above is the edit). Either way the app shares your data
like any other. Provenance is not overwritable in either direction, so an app installed
--sandboxed stays sandboxed until you delete it. What a widget may connect to is the app's own
declaration (manifest.csp, relayed to the host per the MCP Apps spec — nothing by default), and
an app's functions run engine-side and may fetch — see RUNTIME.md §5.1 and §6.1, and
the two type files for what an app sees — @2nd1st/open-mcp-apps/types/window-oma (the
window.oma API) and @2nd1st/open-mcp-apps/types/oma-function (the args/api a function body
gets) — both resolve through the package exports.
RUNTIME.md is the contract — the window.oma API in both modes, what a
sandboxed app can still do, and the traps that only bite authors who aren't the AI. It carries a
version, and test/runtime-contract.mjs pins it to the two runtimes' real surfaces, so it can't
drift from them silently.
Security model
Trust is tiered by where an app came from — SECURITY.md has the detail.
Local, full trust: your apps, AI-built apps, the system apps, and everything installed from the App Store — including
OMA_APP_STORE_DIRSfolders. They run in direct mode with the realwindow.oma.Sandboxed: apps installed with
--sandboxed, and apps opened through a share, run behind the runner — a sandboxedsrcdociframe whose bridge reaches only the app's own collection unless granted more.App functions run on your machine and can make network requests. On by default;
OMA_FUNCTIONS=0turns them off.The AI can operate the open app (
screen_read/screen_act) the way you could, but it cannot confirm a deletion for you.Reserved
security:*/policy:*config keys are out of reach of generic data writes; the HTTP transport binds to loopback.
Design positions (why it's built this way)
UI and data persist separately, both versioned. Apps are views; collections are truth; the ledger is history. Swap either without losing the other.
The AI talks domain commands, never SQL, never raw state. That's what makes human+AI concurrent editing safe (idempotency + optimistic concurrency at the command layer).
Extension-first. Everything rides the MCP Apps bridge — no host-private APIs. One codebase should serve every host that renders
ui://.Single-purpose, not composite. Each app owns one scenario and its own collection; the engine mints a new one rather than cramming features into an old one. System apps (settings, dashboard) are the deliberate exception — engine-owned, privileged, allowed to see across collections.
Troubleshooting
Symptom | What it is |
Updated, but the host still shows the old behaviour | The host keeps its old server process on the old data until fully quit (Cmd-Q, not just closing the window). |
Approval dialogs came back after a Claude Desktop auto-update | A Desktop auto-update occasionally resets these decisions (upstream #56954, closed 2026-06-23 as not planned) — no fix is coming from that issue, so just re-allow. |
One approval prompt per app | Each app you pinned (Settings → Installed → the app → Own tool) has its own |
No viewer link, or the viewer is somebody else's | The port is taken by a non-open-mcp-apps process. Set |
A widget loses its data after a page refresh (ChatGPT web) | Known, mitigation shipped, live re-test pending — |
Widget clicks can update but not add (Codex desktop) | Blocked host-side. The umbrella request openai/codex#28912 closed as completed on 2026-08-05, but that one is an |
You want to start completely clean | Fully quit your host(s), delete |
Development
| stdio MCP server; single |
|
|
| SQLite: items + app registry + |
| browser runtime injected into every app ( |
| wraps stored HTML with runtime + design-token fallbacks at serve time |
| the authoring contract the AI reads before generating an app |
| install an app you wrote yourself, from a file — the one door into the registry that doesn't go through the AI |
| the 3 system apps, installed on seed (settings, dashboard, app-store). The App Store's apps are the |
npm test # every suite below, plus the static invariants and budget checks
node test/server-smoke.mjs # 471 assertions over real stdio — incl. runtime app creation
node test/http-smoke.mjs # 85 assertions over the HTTP transport (incl. SSE /events, viewer)
node test/provenance.mjs # 39 assertions that an app's author — its trust tier — is not overwritable
node test/seed-smoke.mjs # 30 assertions on the seed pipeline
node test/files-smoke.mjs # 24 assertions on the per-app file store (dedup, integrity, GC races)Contributions need nothing signed — MIT in, MIT out (CONTRIBUTING.md).
Status and roadmap
Early v0 — proven end-to-end on Claude Desktop; cross-vendor render + shared store proven on Codex desktop and the browser viewer.
Where it stands:
engine: registry + shell + generic data commands + ledger
system apps installed (settings, dashboard, app-store); App Store apps (the
@openmcp-app/oma-storepackage) with live previews, one-click installAI app creation loop (guide → save → open)
in-context onboarding (the
get_startedprompt → the AI builds a first app for how you work)security foundation: trust tiers + sandboxed runner + reserved config keys
multi-host discovery installer (Claude Desktop · Claude Code · Codex) + shared per-user store
npxone-command install (@2nd1st/open-mcp-appson npm)self-hosted remote (Streamable HTTP) as a supported shape → claude.ai / ChatGPT / mobile off an engine you run — the transport exists (
src/http.mjs) and has been live-tested over HTTPS; what's missing is the hosted story, since the engine binds127.0.0.1by design. Those browser hosts already work against the hosted openmcp.app; this box is about doing it yourselfone-click install with no shell
app export/import → sharing → community App Store (review + runner sandbox activate here)
License
MIT, for the whole repository — the engine and the system apps in
components/ alike (the App Store package is MIT too) (LICENSE ·
LICENSING.md). Use it, fork it, modify it, embed it, run a
modified version as a hosted service; keep the copyright notice with substantial
portions you redistribute. That is the whole obligation. Up to v0.5.2 the engine
was AGPL-3.0-only under a directory split — see LICENSING.md
for what changed and why.
The names open-mcp-apps, openmcp.app, SecondFirst, and 2nd1st,
and their logos, are not granted by the license — see
TRADEMARKS.md. Fork the code freely; give your fork its own name.
Copyright © 2026 2nd1st.
© 2026 2nd1st
Available Tools
34 toolsapply_data_writesMany writes, one transactionADestructiveIdempotent
Apply up to 200 writes in ONE transaction — for applying many known rows in one go instead of one call per row. Each command is exactly what you would send to data_add_item / data_update_item / data_move_item, as {type, ...args}: type is add_item | update_item | move_item. Deletion is not one of them: a delete needs its own confirmation, which an all-or-nothing batch cannot give per row, so it goes through data_delete_item. All or nothing: the first failure rolls back everything and names which command failed. The reply is one line per command ({id, seq}) — not the rows, which you already have.
Inputs: commands (required), command_id (required), actor. Returns: ok, eot, seq, note, +4 more
app_store_listList App Store appsARead-onlyIdempotent
Browse the built-in App Store: ready-made, high-quality apps shipped with the engine that the user can install into their registry. Shows install state. Renders no UI — open_app {app: "app-store"} shows the browsable App Store app.
Inputs: no named parameters. Returns: entries
call_functionCall an app functionADestructiveIdempotent
Run a function an app declares (manifest.functions) — data in, data out, no UI needed. The body is code the app's author wrote and it may make outbound network requests (a host may route them through an allowlisted gateway). Args are checked against the declared params; failures return the declared schema so the retry needs no extra read. The reply carries the return value plus a receipt per write.
Inputs: app (required), function (required), command_id (required), args, +1 more. Returns: ok, eot, note, reason, +4 more
data_add_itemAdd itemBIdempotent
Add an item to a collection. group is the app-defined lane/section (e.g. a kanban column); fields is a JSON object (e.g. {title, done, notes…}).
Inputs: fields (required), collection (required), command_id (required), actor, +2 more. Returns: id, ok, eot, seq, +8 more
data_changesWhat changed since you last lookedARead-onlyIdempotent
What happened in a collection after a ledger position YOU hold — including edits the USER made in the widget, which never pass through you. Any mark you already have works as since: a write ack's seq, data_list's version, or the last call's next_since. Returns the contiguous run of events right after it (oldest first, whole events: actor, item id, fields) plus next_since to continue; omit since to just learn the current position.
Inputs: collection (required), limit, since. Returns: eot, note, since, total, +6 more
data_delete_itemDelete itemADestructiveIdempotent
Delete an item. The ledger keeps its last contents. May return reason:"confirmation_required" with a request_state — show the user what is named in note, then re-send the same call with request_state attached.
Inputs: id (required), command_id (required), actor, collection, +2 more. Returns: id, ok, eot, seq, +11 more
data_listList collection dataARead-onlyIdempotent
Read items in full — every field, plus the item id you need to update or delete it. No UI (use open_app for that). Returns a PAGE: up to limit (default 100) matching items, with total and — when more exist — next_cursor; returned/total make a short delivery self-evident. match filters: a bare value means equals; an object is operators {ne, lt, lte, gt, gte, contains, prefix, exists} (numeric filters compare numerically, strings lexicographically — ISO dates work). Paging is a live keyset walk; items moved mid-page can be skipped or repeated.
Inputs: collection (required), group, limit, match, +1 more. Returns: ok, eot, note, group, +8 more
data_move_itemMove itemCIdempotent
Move an item to another group and/or position (e.g. kanban column).
Inputs: id (required), command_id (required), actor, group, +3 more. Returns: id, ok, eot, seq, +8 more
data_update_itemUpdate item fieldsADestructiveIdempotent
Shallow-merge fields into an item (set a key to null to remove it). Uses optimistic concurrency.
Inputs: id (required), fields (required), command_id (required), actor, +2 more. Returns: id, ok, eot, seq, +8 more
delete_appDelete appADestructiveIdempotent
Delete an app from the registry. Its data, files and history are KEPT, and restore_app brings it back. Erasing an app's data for good is the user's, in the settings app.
Inputs: name (required), command_id (required), actor.
edit_appEdit app sourceAIdempotent
Surgical edits to an app WITHOUT round-tripping the whole source. Two edit forms, mixable: RANGE {offset, length, expect_hash, new_string} replaces a span you read with get_app (cheapest — echo the window's offset/returned/hash, no anchor text travels); STRING {old_string, new_string} replaces an exact-once match (or set replace_all). Range offsets always address the expected_version document and must not overlap; string edits apply after ranges, in order. All edits apply together, or nothing applies. The manifest and skill slots are kept.
Inputs: app (required), edits (required), command_id (required), expected_version (required), +1 more. Returns: ok, eot, name, note, +8 more
file_deleteDelete an app fileCDestructiveIdempotent
Permanently delete one file an app has stored.
Inputs: app (required), path (required), command_id (required), actor, +2 more. Returns: ok, app, note, path, +6 more
file_listList app filesARead-onlyIdempotent
List the files an app (app) has stored — a PAGE of {path, size, mime, version} plus usage totals; limit/cursor page through, prefix narrows. These are opaque user files (attachments, exports) the app keeps — separate from its structured data collection. Renders no UI.
Inputs: app (required), limit, cursor, prefix. Returns: app, eot, note, files, +5 more
file_readRead an app fileARead-onlyIdempotent
Read one file an app has stored, as a WINDOW of its bytes: offset/length select it, data_base64 carries exactly that window, next_offset continues (same window grammar as get_app, and for the same reason). Reassemble by concatenating decoded windows; sha256 is the WHOLE file's hash, so reassembly is checkable.
Inputs: app (required), path (required), length, offset. Returns: app, eot, mime, path, +8 more
file_writeStore an app fileADestructiveIdempotent
Store a file for an app (create or overwrite by path). data_base64 carries the file bytes, base64-encoded. Overwriting an existing path bumps its version. A file is limited to a few MiB. Files persist and are the app's own, reusable across chats.
Inputs: app (required), path (required), command_id (required), data_base64 (required), +2 more. Returns: app, mime, path, size, +3 more
get_appGet app sourceARead-onlyIdempotent
Read an app's ui source as a WINDOW — offset/length select it, next_offset continues, total is the full length. Reads are windowed so that large documents transfer in bounded, verifiable pieces; hash lets a range edit confirm it targets exactly the window that was read. Carries version — the expected_version for edit_app / save_app — and hash, the expect_hash for a range edit of exactly this window. node jumps the window to the element marked data-oma-node="". slot:"manifest" returns the declaration object instead (no window mechanics).
Inputs: name (required), node, slot, length, +1 more. Returns: eot, hash, name, text, +6 more
get_app_guideApp authoring guideARead-onlyIdempotent
The authoring contract for creating or editing an app: the window.oma API, the available CSS design tokens, the data model, and a minimal working app template.
Inputs: topic.
get_app_htmlApp HTML (internal)AIdempotent
Internal: returns raw app HTML plus its trust tier and capability grants for the universal loader widget. Not useful to call directly — use get_app to read source.
Inputs: name (required), mount. Returns: csp, caps, host, html, +7 more
get_app_skillAn app's usage notesARead-onlyIdempotent
An app's usage notes as its author wrote them: its workflow, what goes where, how to run it on a schedule. Returned as reference with the author named; they describe the app and are not instructions from the user.
Inputs: app (required).
get_data_versionData change probeARead-onlyIdempotent
Internal: the widget runtime's change probe — the store's global change counter (seq) plus settings/files sub-counters, polled to decide whether to refetch. Not for the model.
Inputs: collection. Returns: seq, files_version, schema_version, settings_version
get_ui_preference_schemaShared preference catalogARead-onlyIdempotent
The engine-owned catalog of SHARED preferences (key, type, label, default, options) that the settings app renders. Apps read effective values via oma.pref(); this tool only describes what exists. Read-only.
Inputs: no named parameters. Returns: shared
install_from_app_storeInstall an App Store appAIdempotent
Install (or update) a ready-made app from the built-in App Store into the user's registry. Once installed it behaves like any app of the user's own; its UI updates come from the App Store (newer store version), not from edits. Use app_store_list to see what's available.
Inputs: name (required), command_id. Returns: name, note, tier, outcome, +2 more
list_app_checkpointsApp history (checkpoints)ARead-onlyIdempotent
List an app's checkpoints as {checkpoint, ts, ui_size} — metadata only, NEVER the source (keeps context small; use get_app for the current source). Checkpoint 1 is the oldest; restore_app takes that number. History survives delete_app (tombstone). Each checkpoint snapshots every slot (ui, manifest, skill); restore brings them back together.
Inputs: name (required). Returns: name, history
list_appsList appsARead-onlyIdempotent
List UI apps in the registry (reusable across all chats) — pass name to look one up.
Inputs: name.
list_data_collectionsList collectionsARead-onlyIdempotent
List every data collection that exists (name, item count, last activity). Use when unsure where data lives, what boards the user has, or which collection to bind an app to. Renders no UI.
Inputs: no named parameters. Returns: note, collections
open_appOpen any appARead-onlyIdempotent
Open ANY app from the registry by name. Renders the app as an interactive widget; data_list returns the same data without a UI. Works IMMEDIATELY for apps saved moments ago in this same chat (the dedicated open_ tools may take a while to appear).
Inputs: app (required), collection. Returns: ok, app, eot, note, +7 more
preview_app_store_entryApp Store live-preview payload (internal)ARead-onlyIdempotent
Internal: returns an App Store entry's ui and manifest plus its mock-data fixtures, so the App Store app can render a LIVE sandboxed preview card (srcdoc + stub oma + mock snapshot). Read-only; nothing is installed. Not useful to call directly.
Inputs: name (required), locale. Returns: html, name, title, category, +3 more
purge_appDelete app and its dataADestructiveIdempotent
Settings app only: deletes an app AND the data only it used, permanently. Returns a plan first; the same call re-sent with request_state carries it out. Shared or unprovable collections are kept.
Inputs: name (required), command_id (required), actor, request_state.
restore_appRestore an app versionAIdempotent
Roll an app back to one of its earlier checkpoints: re-saves that checkpoint's HTML as a NEW current one (nothing is lost — history is preserved and you can roll forward again). Use when a newer edit broke the UI. Get the checkpoint number from list_app_checkpoints; after restoring, open_app to view it.
Inputs: name (required), checkpoint (required), command_id.
save_appSave appAIdempotent
Create or update a UI app in the persistent registry. Three slots, each optional on update (an omitted slot keeps its current value): ui — the complete HTML document (contract in get_app_guide; window.oma, loads only from the guide's CDN allowlist or manifest.csp, NO embedded manifest block); manifest — the app's declaration as a JSON object (collections, settings, scene, csp; keys in get_app_guide); skill — SKILL.md text telling an AI how to USE the app. null clears manifest or skill. Creating needs ui. Every save snapshots all slots as one new version (history kept). After saving, open it IMMEDIATELY with open_app.
Inputs: name (required), ui, skill, manifest, +3 more. Returns: ok, eot, name, note, +8 more
screen_actUse the app on screenA
Do what the user would do in the app they have open: press a control, or fill/select a value (ref from screen_read, or the control's visible label) — or call one of the app's own tools that screen_read lists (tool + input). The user watches it happen; returns the screen after a press, the tool's answer after a call. "Show me Thursday" is an action in the app, not a data query.
Inputs: app, ref, tool, input, +3 more.
screen_pollScreen relay (internal)C
Internal (app-only): the open app's long poll for screen jobs.
Inputs: session (required), app, born, done, +4 more.
screen_readRead the app on screenARead-only
What the user is looking at in the app they have open: its text, every control they could press or fill (each with a ref like r3), and the app's own tools if it has any. Use it when the user talks about what is on screen ("what's on Thursday?", "that one").
Inputs: app.
security_setSet a security policy keyADestructiveIdempotent
Settings app only: writes one reserved settings key (security:* / policy:), the person's security policy. The generic data_ tools refuse reserved keys.
Inputs: key (required), value (required), command_id. Returns: id, ok, eot, seq, +8 more
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 34 tools
Most tools target distinct resources and actions, with detailed descriptions clarifying overlaps (e.g., save_app vs edit_app, data_update_item vs data_move_item). A few pairs like get_app vs get_app_html and data_list vs file_list vs list_apps could be momentarily confused, but the descriptions differentiate them well.
All names use snake_case, but verb placement is mixed: app management tools use verb_noun (list_apps, get_app, save_app), while data/file/screen tools use noun_verb (data_list, file_write, screen_read). This domain-based split is readable but not a single consistent pattern.
At 34 tools, the surface is large even for a broad platform. Several tools are explicitly internal-only (get_app_html, get_data_version, preview_app_store_entry, screen_poll), which unnecessarily inflates the agent-facing toolset and suggests consolidation is possible.
The set covers app lifecycle (create, read, update, delete, restore, purge, checkpoints), data CRUD with changes and batch writes, file storage, screen interaction, app functions, and settings. Minor gaps exist, such as no explicit collection creation/deletion or file batch operations, but core workflows are well-supported.
Maintenance
Related MCP Connectors
Build personal interactive apps with real URLs and persistent storage, using any AI.
One memory, to-do lists, files and your devices, shared by every AI app you use.
Dashboards, websites, and apps: the Google Drive for everything your AI makes. Edit it together.
A visual brain for your agents: live, reusable UI fragments and skills to pull into code.
Related MCP Servers
- AlicenseDqualityDmaintenanceAI-native orchestration layer with 80+ tools for task management, code editing, browser automation, terminal control, and persistent memory across CLI, local MCP, and cloud deployments.697 npm31ISC
- FlicenseNot gradedqualityDmaintenanceEnables AI assistants to safely perform actions on your computer including file system management, command execution, clipboard access, application launching, and local search with license-based monetization built in.-
- AlicenseNot gradedqualityDmaintenanceEnables interacting with YouTube Data API v3 through MCP tools (get-video, get-channel, get-latest-video) and bundled UI apps for video and channel profiles.4ISC
- FlicenseNot gradedqualityDmaintenanceFederates UI component registries, enabling AI agents to fetch exact component code, dependencies, and setup prerequisites directly into the workspace. Includes sandboxed previews, anti-slop layout auditing, and offline-to-cloud telemetry sync.1-



