Local engine and web: what matches what
The local Myriaxon engine registers 53 tools and has about 150 modules. This page lists every one and what its counterpart on the web is today, what it will be, and what it needs first. It is generated from a ledger that a test checks against the engine itself, so it cannot quietly drift.
Where we are. Of the 53 tools, 26 are live on the web and 17 partial; 10 are planned. Of 58 other features, 17 are live and 17 partial. Features that need a real machine (a shell, git, a language server) will run in an engine: the same Python harness, on your own computer or container, with the web as the orchestrator. They are not being rewritten.
What unlocks what
Rows that are planned or partial, by what has to exist first.
| Needs | Rows | What it is |
|---|---|---|
link | 20 | the engine bridge |
runner | 17 | a server-side agent runner (turns that run with the browser closed) |
loop | 5 | the shared loop-quality core (context budget and compaction, model profiles, steering) |
store | 5 | new tables for your data |
mcp | 0 | connector infrastructure (server-side MCP client, secret vault) |
wasm | 1 | an in-browser runtime (Python in WebAssembly) |
ui | 3 | interface only; the data exists |
Files and editing
| Capability | Route | On the web | Needs | Note |
|---|---|---|---|---|
read_file | native | live | - | Same tool over the project's files; line ranges as start_line / end_line. |
write_file | native | live | - | Asks first at "Ask before every change". |
edit_file | native | live | - | The tolerant matcher (indentation, quotes, trailing spaces, literal \n) is ported from edit_match.py. |
grep_search | native | live | - | |
glob_search | native | live | - | |
checkpoint_list | native | live | - | A file-version table filled on every overwrite (bounded), plus a Rewind control. |
checkpoint_restore | native | live | - | Same table as checkpoint_list. |
edit_notebook | native | live | - | A notebook is JSON: replace, insert or delete a cell. Pure data, no runtime. |
design_poster | native | planned | wasm | A pure-Python SVG writer (PNG needs Pillow): run it in WebAssembly or port the layout code. |
Running things on a machine
| Capability | Route | On the web | Needs | Note |
|---|---|---|---|---|
run_bash | engine | partial | link | Through an engine (the Link is built and tested, and dark until an administrator turns engines on and a person pairs one): the engine's own agent runs the shell on that computer, and the page shows the command and asks first, with the approval bound to the exact text. Confined only when the engine is ("autonomous" is held back otherwise). Missing: a way to run a command yourself from the page. |
bash_output | engine | partial | link | Through an engine: the engine's agent reads a background command's output and the page shows the tool call and its result. Missing: live streaming of a long job into a pane. |
kill_bash | engine | partial | link | Through an engine: the engine's agent can stop a job. The page's Stop ends the whole turn, and stopping the connector ends the agent and everything it started. Missing: a Kill button for one job. |
bg_jobs | engine | partial | link | Through an engine: the engine's agent lists its jobs. Missing: a jobs panel in the page. |
bg_wait | engine | partial | link | Through an engine: the engine's agent waits on its own jobs. |
terminal | engine | partial | link | Through an engine: the engine's agent drives a persistent shell. Missing: a terminal pane the person can type in. |
run_code | engine (alt: wasm) | partial | link | Live in the browser for JAVASCRIPT: run_js runs it in QuickJS (WebAssembly) inside a fresh Web Worker, with no network and no access to the page, only a copy of the text files the agent lists; time, memory and stack are limited; it is read class because it changes nothing outside itself. Through an engine: the engine runs any program. Python is live too (run_python, Pyodide in a worker with no network: the standard library, numpy and pandas). |
git_status | engine (alt: snapshot diff) | partial | link | Without an engine, checkpoint_list (no path) shows the latest versions of every file: what was overwritten or deleted. Real git status needs a repository, so an engine. |
git_diff | engine (alt: snapshot diff) | partial | link | Without an engine, diff_file compares a file with an earlier version, as a unified diff. Diffs against git (staged, a commit) need an engine; git_view.py already returns structured diffs built for a UI. |
lsp | engine | partial | link | Through an engine: the engine's agent uses the language servers installed on that machine. Nothing to configure from the web. |
The web
| Capability | Route | On the web | Needs | Note |
|---|---|---|---|---|
web_search | native | live | - | Run by the server. DuckDuckGo then Wikipedia; the keyed providers (Brave, Tavily, Serper) are not wired. |
web_fetch | native | live | - | Public pages only; every redirect re-checked; a new "network" autonomy class. |
Delegation and sub-agents
| Capability | Route | On the web | Needs | Note |
|---|---|---|---|---|
task | native | live | - | The types general-purpose and read-only explore, plus types a project defines in .myriaxon/agents/*.md. A sub-agent is the same loop with its own empty conversation: every call it makes is judged at the person's current level and asked about like the parent's, and it cannot start another. Not in the engine: one message may start 8, and they share 40 model calls. |
parallel_tasks | native | live | - | At most 3 work at the same moment, the rest wait, as in the engine; each sub-agent has its own transport, so its own count of model calls on the server. |
send_to_subagent | native | live | - | Continues a sub-agent with its own memory. It lives in the page for the length of one conversation: closing the page ends it (the engine keeps them for the process). |
session_status | native | live | - | Model, endpoint, level, tools in force, context left. |
branch_session | native | live | - | Copy a conversation up to a message into a new one. |
request_tools | native | planned | loop | Only matters when the catalogue is large, that is, when an engine is linked. |
tool_search | native | planned | loop |
Context and long conversations
| Capability | Route | On the web | Needs | Note |
|---|---|---|---|---|
check_context | native | live | - | How much of the model's window the conversation uses (the provider's own count of the last call, or an estimate), what was shortened, how much was summarised. Also a section of session_status. |
recall | native | live | - | A tool result that was shortened to save space ends with its handle (the call's id); recall(handle) reads it back whole, or only the lines that contain a word, from the conversation itself (it works while the page stays open; after that the file can be read again). |
declare_uncertainty | native | live | - | Bookkeeping plus a "checked / reasoned" badge in the transcript. |
compaction + context budget | native | partial | - | Live: what is SENT to the model is kept inside its window (the transcript and the stored conversation stay whole): old tool results and old long arguments are shortened with a handle (free, always on); at 75% of the window (the provider's count of the last call, or an estimate for a conversation just reopened) the oldest part is replaced by a summary the model writes (one tool-less call, counted in the limits); a refusal as too long compacts once and retries; sub-agents and locus runs have a context of their own. The window is a GUESS by model name (a device model uses the num_ctx the page asks for). Not built: the engine's compaction audit, a window learned from the provider, a context meter on the page. Before this the web resent the whole conversation on every step, the largest reliability gap in the web agent. |
spill | native (alt: write_file + recall) | partial | - | There is no single tool. The agent can put a large result in a project file with write_file, and an old result that was shortened to save space can be read back with recall. A spill tool would do both in one call. |
Skills and memory
| Capability | Route | On the web | Needs | Note |
|---|---|---|---|---|
use_skill | native | live | - | A per-person and per-project skill library; the listing goes in the system prompt. |
search_memory | native | live | - | Full-text search over the person's saved conversations (FTS5 in D1). Cross-project, like the engine. |
save_skill | native | live | - | Prose skills: a proposal the person reviews (the engine's skill workshop). A skill that ships executable code stays with an engine. |
memory_share | native | planned | runner, store | Collective memory between a person's loci. |
memory_recall | native | planned | runner, store |
Asking the person
| Capability | Route | On the web | Needs | Note |
|---|---|---|---|---|
ask_user_question | native | live | - | A question with options in a dialog; the run waits. Declined when nobody is there (a woken locus). |
todo_write | native | live | - |
Scheduling and always-on
| Capability | Route | On the web | Needs | Note |
|---|---|---|---|---|
schedule_prompt | native | planned | runner | A scheduled turn that runs with the browser closed. In the engine it is session-scoped; in the cloud it can be durable. |
list_scheduled | native | planned | runner | |
cancel_scheduled | native | planned | runner |
Persistent agents (Loci)
| Capability | Route | On the web | Needs | Note |
|---|---|---|---|---|
loci: identity, goals, modes, goal authority | native | live | - | Created, edited, run, with the agent unable to mark a goal done. Runs while a tab is open. |
automations: an agent that works with no tab open | native | live | - | A Cron Trigger every minute and one Durable Object per person run the SAME agent loop on the server, as the person: schedules (every N minutes, daily, weekly in their own time zone), a secret web address (webhook; its data is fenced as untrusted and the run has no web or connector tools), Telegram and email (Cloudflare Email Routing; listed senders that passed DKIM or SPF only). Never above the person's level; approvals nobody can give are declined; five failures switch it off; one run at a time per person; at most 20 model calls and 10 minutes. Not built: results by email, a locus inside the runner, replies to WhatsApp or Slack. |
locus_list | native | live | - | The chat agent lists the person's loci (role, mode, open and blocked goals, last outcome) and, for one locus, its goals with their ids. |
locus_create | native | live | - | From chat, in the current project, with the person's approval at "Ask before every change". A locus made this way is assisted and does NOT run on its own: those two are the person's to switch on (the engine's tool takes autonomy and proactive as arguments; the web does not let the agent grant itself either). |
locus_goal_update | native | live | - | Add a goal, move one between pending, active and blocked, add a note: from chat, and (as goal_update) inside a Loci run, where the agent can never mark done. Closing a goal from chat (done, obsolete) shows the person the goal and only their click closes it. |
always-on loci (supervisor) | native | partial | - | The cloud runner now exists (Automations: schedules with no tab open). A LOCUS still wakes only while a tab is open: moving the locus supervisor onto the runner is not built. The engine's own supervisor through the Link is the other route. |
chat-app bot (WhatsApp, Telegram) and its tunnel | native | partial | - | Telegram is live (Automations): the person's own bot, its webhook set by the server with a secret header, ONE private chat paired with a code, the answer sent back, earlier messages as context. No tunnel: the Worker already has a public address. Not built: WhatsApp, Slack and the other chat apps, and answering a locus rather than an automation. |
locus_run | native | partial | runner | From chat the agent runs a locus on its next goal and waits for it: in the page, one at a time, only while the page is open, at the person's autonomy level. Without the page open it needs the server-side runner. (The engine's tool also takes a message; here the run takes the locus' next goal.) |
locus_watchlist | native | planned | runner | What a locus checks on every unprompted wake-up: the heart of a proactive agent. |
heartbeat_respond | native | planned | runner | Report the outcome of a periodic check, and say whether the person should be told. |
proactive wake-ups: heartbeat and conditions | native | planned | runner | A locus that wakes because something is wrong. Cloud-checkable conditions: a page changed, a file changed, a date. Conditions that run a command belong to the engine. |
inbox: what a locus wants to tell you | native | planned | runner, store | Proactive results land in an inbox with an unread count; urgent ones can ask for an approval. |
locus character and expressions (avatar) | native | planned | ui | A static SVG set from the same manifest, swapped by the event-to-expression rules of the spec. |
roles and bot templates | native | planned | ui | Coordinator, researcher, reviewer and writer as ready-made starting points in "New locus". |
companion and personal stores | local-only | local-only | - | Private by design. Stays on the device; the web may show that it exists. An end-to-end encrypted sync is a possible later option, not a default. |
Swarm, shared memory and consensus
| Capability | Route | On the web | Needs | Note |
|---|---|---|---|---|
swarm_post | native | partial | runner | The project board: board_add writes tasks that the person, the agent and its sub-agents share (inside one conversation). Not built: a board shared between a person's persistent loci. |
swarm_list | native | partial | runner | board_list; the Board page shows the same tasks in four columns. |
swarm_claim | native | partial | runner | board_update with claim=true: ONE statement that succeeds only while the task is still todo and unheld, so two workers can never take the same task (tested with five at once). |
swarm_finish | native | partial | runner | board_update with status done (or blocked) and a short result. |
swarm_release | native | partial | runner | board_update with status todo gives a task back to the pile. |
swarm, collective memory, consensus, conflict detection | native | planned | runner, store |
Safety, approvals and policy
| Capability | Route | On the web | Needs | Note |
|---|---|---|---|---|
hash-bound, one-shot approvals | native | live | link | Built for the Link and tested end to end: the engine sends the action as text with its SHA-256, the page hashes the text it shows (WebCrypto) and answers with that hash, and the engine compares it with its own, consumes the approval before acting, and refuses a wrong hash, a replay, a stale one and a question it never asked. Verified across languages with non-ASCII text and an emoji. The browser-run agent needs none: nothing carries its approvals between the page and the loop. Not built: approvals signed by a key the browser holds (a compromised cloud could still forge one in v1). |
autonomy levels with a ceiling | native | live | - | Five levels, a ceiling per organisation and per person, enforced in the proxy. |
the audit trail | native | live | - | Names, paths, sizes, decisions; never contents. |
guardrails as data (argument-aware rules) | native | partial | - | Live for the call about to be made: block, ask the person first, or warn, judged on the tool and its arguments (path, content, address, words searched), in two layers (the organisation's, which nobody can switch off, and the person's own), with the engine's posture (fail closed, patterns screened for backtracking, a closed vocabulary), for the chat agent, every locus run and every sub-agent. Enforced by the page like the approval prompts, not in the proxy. Not built: rules on a result (PostToolUse) or on the prompt (UserPromptSubmit), and the engine's shell "command" field. The cloud-side answer to the engine's shell hooks. |
sandbox ladder and native sandbox | engine | partial | link | The engine's own: read-only, workspace-write, danger-full-access; Docker, bubblewrap, Seatbelt. None native on Windows (Docker there). Through the Link the page shows whether the engine is confined, and "autonomous" is held at "edits run by themselves" unless it is. Missing: choosing the sandbox from the page (it is set on the engine, on purpose). |
action-risk escalation | native | planned | loop | Ask when the cost of being wrong crosses a threshold, not only when a tool is a write. |
extension policy tiers | engine | planned | link | |
boundaries (what a locus will not do) | native | planned | - | Checks as well as prompt text. |
The agent loop: reliability
| Capability | Route | On the web | Needs | Note |
|---|---|---|---|---|
edit_match (tolerant edits) | native | live | - | Ported, with its tests. |
cancellation | native | live | - | The Stop button ends the turn. |
steering (redirect a running turn) | native | live | - | Typing while the agent works queues the message under the box; it joins the conversation at the agent's next step (after the results of the last one) and the next model call sees it. Said too late for the turn, it is sent as the next message; Stop gives queued words back to the box. |
spend cap in dollars | native | live | - | Per day and per message (a message and its sub-agents add up), set by the organisation, by an administrator for one person, and by the person (the lowest wins), enforced in the model proxy before each call. Prices: the engine's dated table, an administrator's override, and an expensive fallback marked as an estimate for a model with no price (as in the engine). Models on the person's own device are free and not counted. A cap is only as good as the prices. |
per-tool deadlines | native | live | - | A minute for each tool call (not for sub-agents, a locus run, a question or an approval, which have their own limits); a change that timed out says it may still have gone through. Stop also ends a wait for the model, for a tool or for a click at once. |
model profiles and adaptation | native | partial | - | Three profiles, small, balanced and large, chosen by a guess from the model's name and window or by hand in Settings: the tool set shrinks (a small model is offered the core only), a small model gets a short prompt, and one file read returns at most 6,000, 20,000 or 30,000 characters. A profile only takes tools away. Not built: the engine's per-tool result caps and delegation tuning, or adaptation learned per model. |
tool-call repair | native | partial | - | Live: broken argument JSON is repaired; a tool called by another name (read, cat, str_replace, TodoWrite) is read as ours; an argument named as another tool names it (file_path, old, new, text, q, link) is renamed; values are coerced to the schema ("12" to 12, "true" to true, a lone string to a list of one, an enum in the wrong case); the model is told what was read as what. The mended call is what the level, the guardrails and the approval see. Not ported: the engine's other rungs of the repair ladder. |
loop detection | native | partial | - | Three identical failing calls end the turn; the engine's other patterns are not ported. |
run budget | native | partial | - | Steps per message, tokens per day and dollars (per day and per message) are enforced on the server when an administrator sets them (by default steps and tokens are NOT limited: 0 = no limit; the dollar limits are off too); a seconds ceiling is not. |
durable runs (resume after a crash) | native | planned | runner | Today closing the tab ends the turn in progress. The runner makes a run survive it. |
secret redaction and handles | native | planned | loop | Scrubbing secret-looking strings from tool results and logs is cloud-possible. "Handles" (the model uses a secret without seeing it) needs a vault: the engine first. |
output-schema enforcement | native | planned | - | A tool that declares a result shape has that shape checked; tool input is already validated. |
two-step patching | native | planned | - | Authorise one exact span, then replace it, so an edit cannot land on text the model did not mean. |
Extensibility
| Capability | Route | On the web | Needs | Note |
|---|---|---|---|---|
skills library | native | live | - | See use_skill. |
project instructions (MYRIAXON.md / AGENTS.md) | native | live | - | The project file and the person-wide instructions (Settings) are both read on every turn and every Loci run. |
mcp:remote | native | partial | - | Live: a server-side MCP client over https (streamable HTTP: JSON or event-stream answers, session id, tool list with pages, tool call) behind the address rules of a custom model endpoint, with the token in an encrypted vault, never returned, never sent to a redirect target. A person adds a connector in Settings; the agent uses mcp_list and mcp_call (a call asks first even at Edit on its own, results are untrusted). Not built: OAuth flows, the older two-endpoint SSE transport, resources, prompts and sampling, a connector that works with no page open. |
MCP client, catalogue and registry search | native | partial | - | Remote servers: live (see mcp:remote). Not built: a catalogue or registry to browse (the person pastes an address), and stdio servers, which run with an engine. |
mcp:stdio | engine | partial | link | A stdio MCP server is a process: it runs next to the engine, so the engine's own servers work for a conversation with that engine. The web cannot add or configure one on an engine (MCP servers are not a scope, on purpose), and a remote server in the cloud is still to build. |
skill trust, workshop and usage | native | partial | - | Live: proposals wait for the owner (the agent cannot make a skill live), and each skill counts its uses. Not built: quarantine and smoke tests for skills that ship executable code (those stay with an engine). |
attachments (images, PDFs) | native | partial | ui | Any file: Attach (or drop, or Upload) puts it under attachments/ in the project and names it, with its kind and size, in the message. Text stays text; Word, Excel, PowerPoint, OpenDocument, CSV and PDF files are stored as binary files (10 MB each, 100 MB in all) and read with read_file as text (a workbook with sheet and range, a PDF with pages); Import and Download ZIP carry binary files too. A picture, or one page of a PDF, can be LOOKED at with view_image: it is shrunk in the browser (at most 1568 pixels, JPEG) and shown to the own model of the person, and what the model says comes back marked untrusted; this is also how a scanned PDF is read. Not built: a text recognition (OCR) engine of its own, and the old .doc/.xls/.ppt formats. |
hooks (shell, before and after a tool) | engine (alt: guardrails) | partial | link | The engine's own hooks run on the engine for its agent, so they apply to a conversation with that engine. The cloud counterpart is guardrails as data, which does not apply to an engine's tools. Hooks are configured on the engine, never from the web. |
structured git for review | engine | planned | link | Built for a UI already. |
sub-agent types from files | native | planned | store | |
worktree isolation | engine | planned | link | |
plugin tools | local-only | local-only | - | In-process Python. The web may list and switch them on or off; the code runs only on the engine. |
plugins | local-only | local-only | - | Arbitrary code: only where the person runs it. What the web CAN take from a bundle in the Claude-plugin layout is its declarative parts (slash commands, agent types, skills): the import review installs those and lists everything else as not installed. |
Providers and models
| Capability | Route | On the web | Needs | Note |
|---|---|---|---|---|
providers: Anthropic, OpenAI-compatible, OpenRouter, DeepSeek, Gemini, Vertex | native | live | - | Plus Google Vertex AI through a Google login. Netra is reachable as a custom endpoint, not as a named provider. |
Ollama and other models on the device | native | live | - | The page scans the computer and talks to the model directly. |
usage ledger and model info | native | partial | - | Tokens and money per day are counted (the console shows both); a per-model breakdown is not. |
Vertex explicit context caching | native | planned | loop | |
Vertex through the operator's gcloud login | local-only | local-only | - | The web has its own Google login for Vertex; the gcloud route stays an engine feature and needs no OAuth consent screen. |
Operating the whole: visibility, history, quality
| Capability | Route | On the web | Needs | Note |
|---|---|---|---|---|
run export | native | live | - | A reviewable report: the transcript, the files touched, the decisions. Built in the browser. |
session branching and search | native | live | store | |
transparency dial | native | partial | - | Three of the engine's eight levels: Quiet, Normal, Full detail (the page's dial). The server-side event stream has no finer levels yet. |
dead letters and regression harvest | hybrid | partial | link | Failed Loci runs are listed in each run history; the harvest into a regression suite is an engine matter. |
mission control, health and self-inspection | hybrid | planned | link | The engine already assembles one honest, read-only snapshot. The web shows it for every linked engine: a fleet console. For cloud runs the web has its own source (runs, usage, schedules). |
self-improvement gate and immutable core | engine | planned | link | A viewer, never a remote button. |
IQB-14 benchmark, snapshots, performance gates | hybrid | planned | link | Run on the engine; the web charts the scorecards per model and endpoint. |
Surfaces and packaging
| Capability | Route | On the web | Needs | Note |
|---|---|---|---|---|
editor protocol (ACP) | engine | live | link | Not a web feature in itself: it is the protocol the Link bridge speaks to the engine, and that is built: initialize, session/new, prompt with streamed text, tool calls, permission questions and cancel run through the real server, the real connector and the real relay (tools/link-e2e-test.mjs, tests/test_link.py), including a real agent loop against a model that asks to write a file. Dark until engines are switched on. |
dashboard: sessions, explorer, settings, rules, endpoints | native | partial | - | Sessions, files, settings, keys and endpoints, model and mode are live; the rule editor and the MCP manager are not. |
terminal REPL, theme, banner, commands | n/a | n/a | - | The web page is the surface. |
installers, launcher identity, container image | n/a | n/a | - | The container image is how an engine is placed on a server. |
Engine reading: commit 792f1ad, 2026-11-17. Route: native = re-expressed for the cloud and the browser; engine = runs in a real machine; hybrid = the engine produces the data and the web shows it; local-only = stays on your machine by design; n/a = no meaning on the web.