Portal

One app per vendor — or one workspace#

The Claude app is built around Claude, the ChatGPT app around OpenAI’s models, Warp around the terminal and its own agent, Muse around boards for thinking. Portal is built around the combination: any model, any coding agent, and the terminals and canvas they work in — with one set of rules, skills, tools and memory for all of them.

Side by side#

Every one of these tools is good at what it is built for. The difference is scope — how many models, agents and surfaces live in one place, and whether they share what they know.

From each product’s public pages, September 2026. Muse is now called Allume.

Coming from another tool#

They outlive the window#

A small per-user terminal daemon owns every PTY; the tile on the canvas is only a reconnecting client. Close the tile, quit the app or crash it — the shell keeps running, and the next launch attaches to the same session and replays what it missed.

• socket 0600 · state 0700
• peer credentials checked
• fsynced JSONL journal
• frames ≤ 16 MiB

Every command becomes a record#

For zsh, bash and fish, Portal adds temporary shell hooks that chain to your own configuration and mark where each command starts and ends. The daemon sees those marks even while the app is closed, so every finished command becomes a durable value — one you can wire, filter and search. Warp made blocks familiar; here a block is also a record that outlives the app and can be wired straight to an agent.

CommandResult {
  event_id, session_id,
  command, cwd, environment, shell,
  exit_code, duration_s,
  transcript,
  objects[], risk,
  started_at_ms, finished_at_ms
}

Objects are recognised in the output — files and Git states, containers, processes, pods, pytest cases, deployments, URLs. environment is a safe host, folder and shell identity, never a dump of your variables.

Risk is classified low, medium, high or critical from the command and its environment. It routes approvals; it is not a sandbox. Shells without reliable hooks keep durable PTYs and transcripts, but never get invented exit codes.

Know before you press Enter#

The prompt suggests the likely next command in grey. For commands that change the world — rm, git push, kubectl, terraform — a preflight line says what would happen, on which host, before you commit to it. Commands that failed here before say so as you type.

When something breaks#

⌥E opens the latest failure as a side sheet — the top source, diagnostics, failing tests — with three ways forward: ask an AI with the evidence attached, create an agent mission, or open the raw block. If something fixed this error here before, the block says so and offers to replay it.

Commands flow to agents#

Draw a wire from a terminal to an agent or chat and each finished command travels as a typed record, in order. Filter by exit status, objects, host or risk; high-risk records wait as approval cards; text routed into a terminal is pasted, never run.

Each wire keeps its own cursor, advanced only when the destination accepts. If a crash lands between a remote side effect and its acknowledgement, the wire returns as uncertain — you choose Retry or Treat as delivered — rather than risking a duplicate.

Remote hosts, same terminal#

SSH hosts open as ordinary terminal tiles. First contact shows the server’s fingerprint to compare; forwarded ports become chips you can open; transfers show inline; a dropped link reconnects and restores the session. The same harness and memory follow you onto the host.

Machines on demand#

Connect a Vagabond host and every coding agent Portal launches can create machines — containers, Firecracker microVMs, QEMU/KVM VMs or full Linux desktops. Each one appears on the canvas beside the agent that made it. The key stays in your OS keychain, and every side effect is written to a compute journal, attributed to its owner.

• 33 s200 containers, workspace uploaded once
• 1.7 sone command answered across all 200
• 8 sone microVM forked into 16, processes running
• 5 s4 desktops with live thumbnails

Measured end to end through the agent tools on a single-node lab host.

Claude Code, Codex, OpenCode — or yours#

The New agent dialog picks a runtime, a folder and a model. Creating the tile has no side effects — the process starts with your first prompt, under its own login and its own model — and Portal reads each runtime’s structured output instead of scraping its screen. The Claude app runs Claude Code and the ChatGPT app runs Codex; here both run side by side — with OpenCode and your own CLI — and every one of them gets the same harness.

Tool calls you can read#

Every step arrives as a row — read a file, searched, edited, ran a command, fetched a page — and the run folds into a one-line summary with failures counted. Expand a command to see its exact input and output. When the runtime asks permission, the question is a card: Allow or Deny, naming the path or command.

What needs you, first#

Zoom out and every tile reduces to its state — WORKING, NEEDS APPROVAL, FAILED, WAITING FOR YOU. ⌘J walks what needs you in order: host failures, then waiting input, then failed commands. Each card names the host, folder, actor, the exact request, its risk and a short tail of output.

Missions with limits and evidence#

A mission gives an agent a goal and a contract — time, cost and command budgets; how many edits, files and attempts it may use; which commands are allowed — pinned above the conversation with a Stop button. Finished commands join a Mission Evidence ledger: actor, session, environment, risk, exit code, duration class and a command digest, never the prompts, replies, commands or transcripts themselves.

Agents that work together#

Wires connect agents to each other, to chats and to documents. A report can fan out to a researcher and a skeptic; one agent’s answer can become another’s prompt. Whatever crosses a wire is typed, ordered and, when it matters, reviewed.

Scopes: who gets what#

Every agent resolves the same chain: Everyone, then the repo it works in, then its Board, Channel and Station, and finally the agent itself. Each narrower scope can grant or forbid. The Harness screen shows what reached an agent, the scope each item came through, and about how many tokens ride every turn.

Plain files, where you keep them#

Your library is a folder of rules, skills, custom tools and profiles — and Portal also reads the folders your other tools already use, editing them in place. Change a file in any editor and it reloads within about 1.5 s. Nothing is deleted; removed files move to .trash/.

agent/
  rules/<id>.md         # always on
  skills/<id>/SKILL.md  # + scripts/
  tools/<id>.md         # custom tools
  profiles/<id>.md      # roles
  .trash/               # never deleted

<repo>/
  CLAUDE.md, AGENTS.md  # their own CLIs
  rules/*.md            # this repo's agents
  tools/                # id@my-repo
  policy.yaml           # restricts

Facts that carry directives#

A fact is one line of text. Trailing brackets give it structure — where it applies, what it forbids and how to check it — so every place that edits facts can write them: the kit editor, settings.yaml, a repo’s policy.yaml. Agents read each fact together with its latest result.

We use pnpm, never npm         [guard: `npm install*` `npm ci*`]stopped 3 · ran anyway 1Deploys freeze on Fridays      [when: branch=release/*, repo=github.com/acme/app]sent only on release/* in acme/appThe suite runs under a minute  [probe: `make test`] [expect: under 60s]checked 2h agoThe API listens on 8443        [probe: `grep -q 8443 config/app.yml`] [rests: config/app.yml]its check failed — verify before relying on it

A repo’s own probes wait until you allow them once or trust the repo. Probes run with your rights — keep them to read-only checks.

Where a guard holds#

One rule, enforced the strongest way each runtime allows. Claude Code’s PreToolUse hook denies the call and cites the rule; OpenCode’s plugin refuses it; an API chat’s terminal proposal fails. Codex and other CLIs have no hook before a command runs, so Portal notices it in the terminal and counts it as run anyway — the harness report lists each rule’s stops and misses.

How it reaches each runtime#

Nothing to install per agent. Each runtime receives the harness through the switches it already understands, and every shell carries a live link to its tile’s bundle — change a scope, and the next claude or codex typed in that same shell gets it, with no restart.

Remote hosts get the same bundle over SSH, synced once per content hash. Vagabond machines install it with the command that starts their shell, so later edits reach the next launch.

Autonomy is earned#

Every agent action carries the effects its plan declares — editing the canvas, creating tiles, typing into terminals. In Review, an action runs on its own only when you’ve allowed that agent every effect it has. After 20 accepted in a row, Portal offers to let the agent do that kind of thing without asking; one discard takes it back, and Keep asking waits for 40 before offering again.

One memory for every agent#

Every Portal terminal — local, over SSH or on a machine — gives its agents four memory tools. Memory follows the repo, named by its origin remote, so a laptop and a remote box share it. remember never writes: a proposal waits under Proposed until a person accepts it, and unreviewed ones expire after 14 days.

• signed per terminal
• notes printed by scripts show as unverified
• stale answers warn when a file changed

A harness that learns#

Every finished command joins a log. Once a week — or when you ask — the evidence becomes edits you review: a guard for a “never” rule that ran anyway, a fact for an error that keeps coming back, stop sending a skill nobody opened in 30 days, remove a fact whose check fails. Profiles can be tried against each other by bad-turn rate and cost, and nothing is called before 20 turns an arm.

Policy that can’t be quietly loosened#

A skill is a folder#

Standard frontmatter — name and description — so the same folder works in Claude Code, Codex and any tool that reads Agent Skills. Portal-only keys live under metadata:, and keys it doesn’t model — allowed-tools, license, your own — are never rewritten.

---
name: release-check
description: Before tagging a release, run the
  suite, confirm the changelog and build.
---
1. `pnpm test` — stop on the first failure.
2. Check that CHANGELOG.md names this version.
3. `pnpm build`, then attach the bundle report.

skills/release-check/
  SKILL.md
  scripts/      # helpers it may run
  references/   # docs it may read
  assets/       # files it may copy

# a default-off flag under metadata:
# → available only where a scope turns it on

The skills you already have#

Portal reads skills from the folders your tools already use and merges them into one library. For the same id the narrower source wins — the repo over Portal, Portal over the other tools — and a repo’s skills get qualified ids like deploy@my-repo, so two repos never collide.

One library, managed from any chat#

Open the Skills panel beside any chat and the whole library is there: filter by name and see whose each skill is. The skills chip in the composer keeps the count in view. Each skill can be granted or forbidden per scope — everyone, a repo, a board, one agent — and the Harness screen shows which scope an agent got it through.

Learned from what you ran#

A sequence you run three times or more that mostly ends well is proposed as a skill, with its steps as a trace and the repo files it goes with. A command you run with varying words is proposed as a tool with parameters. The eye opens the exact file it would write; Add to library writes it, and dismissing silences it.

Later, when an agent runs a step of a learned skill without the steps before it, its hook’s note says which ones were skipped.

Fixes become skills#

When a failure turns into a pass, Portal captures what changed as a fix — When, Diagnose, Fix, Verify. Accept skill grants it to every agent on the board, Memory only keeps it as a known fix, Discard drops it. Accepting is the only way a fix becomes a skill.

Measured by outcome#

For each skill an agent had, Portal compares failures with the skill opened and without it — API chats’ turns, CLI agents’ command results reported by their hooks. With eight or more on each side, a two-proportion test says whether it goes with fewer failures or more. In an API chat’s always-on context, up to two short skills that fit the repo ride whole; one that goes with more failures is sent only by name, last.

Delivered the way each agent reads them#

Command skills for ⌘K#

Declarative *.skill.json files compose registered commands into one ⌘K entry. They can’t call a binary, a URL or a provider directly, and on load Portal derives their effects from the commands they use — so a manifest can’t hide risk by under-declaring. Limits are deliberately small: 16 arguments, 16 steps, no recursion.

{
  "id": "skill.project_room",
  "title": "Create project room",
  "effects": ["canvas_write", "tile_create", "terminal_spawn"],
  "arguments": [
    {"id": "name", "label": "Project name"},
    {"id": "brief", "label": "Brief"}
  ],
  "steps": [
    {"command": "canvas.new_board", "arguments": {"name": "${name}"}},
    {"command": "canvas.new_note", "arguments": {"title": "${name} brief", "content": "${brief}"}},
    {"command": "canvas.new_terminal"}
  ]
}

The canvas is a tool server#

Coding agents reach the canvas through an MCP server of about 55 verbs, each declared read-only, staged or mutating. Agent tiles running Claude Code get the canvas tools pre-allowed; anything that would change your canvas arrives as an Accept / Discard card.

Proposals, not side effects#

In a chat, a fenced tool block becomes a typed proposal. Parsing alone never executes model output: auto-approved actions run through the same planner and executor as ⌘K, everything else waits as a card, and unknown tools or malformed calls stay plain text.

{
  "tool": "create_diagram",
  "title": "Request flow",
  "nodes": [
    {"id": "client", "label": "Client", "x": 0.15, "y": 0.5},
    {"id": "api", "label": "API", "x": 0.5, "y": 0.5},
    {"id": "db", "label": "Database", "x": 0.85, "y": 0.5}
  ],
  "edges": [
    {"from": "client", "to": "api", "label": "HTTPS"},
    {"from": "api", "to": "db", "label": "query"}
  ]
}

Library tools, run by their effect#

A kind: shell tool binds its arguments into environment variables — never parsed as shell — and runs by its declared effect. API chats call library tools with run_tool; CLI agents see them as tools of the memory server.

tools/check.mdCopy

---
name: check
description: Run the test suite
kind: shell
effect: read_only
run: make check
---
Runs the whole suite.

Canvas Operator, visibly armed#

An AI chat can operate the whole workspace through bounded Lua — only when you arm it, per tile. Pause and Stop are always on its bar. One turn is bounded to 12 continuations and a response to four calls, and a restart never silently restores automatic authority: saved modes come back as Review.

Transactions with receipts#

Each step is an explicit Lua block that opens with an intent comment — its title on the card. Changes go through transactions checked against the world revision, so a stale plan is rejected instead of hitting the wrong tile, and every applied plan returns a receipt you can undo. The Lua runs in a fresh, bounded VM with no filesystem, process or network access.

-- intent: Add a release checklist beside the build
-- read the world, then apply one transaction:
--   artifact.create  "Release checklist"  at 120, 160
--   tile.resize      that checklist to 520 × 360
-- → a receipt you can undo; a stale revision is refused

One pipeline for every command#

⌘K holds built-in actions, native tools, installed skills and recent commands, and every entry follows one pipeline. Provider requests created by a command stay staged in the chat’s exact-payload review — approving a plan doesn’t send them.

Machines as tools#

The vagabond MCP server, served from Portal’s own binary, gives agents machines: exec with real exit codes, logs that wait instead of polling, git-aware upload and download, clone, desktops driven by element name, and fleets. Full per-machine results never enter the agent’s context — they’re written to the workspace, and the answer names the path.

• create_machine
• exec
• logs
• upload · download
• clone
• create_desktop
• screenshot
• desktop_input
• fleet_create
• fleet_run
• fleet_map
• race

Tiles and wires, like Blueprints#

Every tile has typed ports. Drag from one to another and you have a wire: a document fans out to a researcher and a skeptic, one agent’s answer becomes the next one’s prompt, a terminal hands each finished command to an agent. Values arrive in order, filters and review gates sit on the wire, and text routed into a terminal is pasted, never run.

Ask the canvas#

Press ⌘/ and say what you want to see — “black hole lensing”, “how vaccines build herd immunity”, “E = mc²”. The answer arrives inline as a native studio: the governing equation, figures and live controls, never a flat image. Bookmark it and it joins your gallery, searchable from ⌘K.

Plots you can work with#

Plots are native surfaces, not pictures — in 2D and 3D. Pan, zoom, read a crosshair, toggle a series from the legend, orbit a 3D chart or switch it to a table — and the exact data stays with the plot. Lines, scatter, bars and shaded bands; neon, scientific or minimal styles; linear, log, symlog and time axes, with calendar labels and SI units (1.2k · 3.4M).

{
  "tool": "create_plot",
  "title": "Service latency",
  "x_label": "Minute", "y_label": "Latency (ms)",
  "style": "neon",
  "series": [{
    "label": "p95", "type": "line",
    "x": [0, 1, 2, 3], "y": [22, 28, 24, 35],
    "color": "#36D7FF", "fill_alpha": 0.12
  }],
  "annotations": [{"x": 3, "y": 35, "label": "deploy"}]
}

• ≤ 16 series
• 4,096 points per series
• 32 annotations
• agents use the same schema

LaTeX, typeset natively#

Math is typeset by the app itself — in chats, figures and studios — so it stays vector-crisp at every zoom. Inline and display math, colour, cancellations, arrows, stacked limits and your own macros; chemistry with \ce{}, units with siunitx and the physics package. Wide equations break like typeset ones, and a half-streamed formula shows a placeholder instead of an error.

LaTeXCopy

% Schrödinger, with the physics package
i\hbar\,\pdv{\psi}{t} = -\frac{\hbar^2}{2m}\nabla^2\psi + V\psi

% chemistry and units
\ce{2H2 + O2 -> 2H2O} \qquad g = \qty{9.81}{m/s^2}

% bra-ket, colour, cancellation, arrows
\bra{\phi}\hat{H}\ket{\psi} \qquad
\color{teal}{E} = mc^{2} \xrightarrow{\,1\,\mathrm{g}\,} \qty{21.5}{kt}

Branch any answer#

Every answer has a ⋯ menu. Branch opens a sibling conversation beside the original — wired to it, with the context frozen at that turn — so you can take a different direction without losing the first. Race runs a second answer to the same turn side by side. Nothing forks unless you ask: an ordinary Send never doubles provider traffic.

Remember what matters#

The same menu keeps things. Remember records a decision; Save as fact turns a passage into a fact; Add as skill (K) bottles a procedure; Keep as a note drops it on the canvas. Each opens a capture card that asks the scope — this chat or the whole board — and grants nothing until you save. Saved facts join the harness, so every agent in that scope reads them.

Evidence, then a challenge#

Evidence opens beside any passage: its sources, the checks that back it, the assumptions written down and the open questions — with plain flags like No source and Not checked. Challenge passage sends it back as a new turn that must weigh that evidence and say whether the conclusion should change.

Answers that run#

Boards of tiles, conversations with any model, and answers you can use: tables that recompute as you drag a value, derivations checked step by step, figures you can steer.

Drop anything#

Drag files anywhere on the canvas and a ring of verbs opens at the drop point: Preview makes linked file tiles, Compact keeps small file objects, AI chat starts a conversation with the files in its draft, and over an existing chat Attach takes the top petal. Files are linked originals, not copies, and one drop takes up to 128 paths.

What the model actually receives#

Portal prepares every file locally and says what a provider will get — before anything is sent.

• 8 files per message
• 48 KiB shared text budget
• ≤ 1 MiB per image
• no automatic OCR

Pictures become vision tasks#

An image or a visual diff becomes a vision task. Text-only models are marked in the model registry: a PDF sends its text with an explicit note that the image was left out, and an image asks you to pick a vision-capable model while keeping your draft.

Agents that can see the screen#

In Canvas Operator, capture_viewport reads the real rendered frame, encodes a bounded PNG in memory and attaches it to that one call — captures are never saved. On a machine’s desktop, Point lets you circle a region and send it to the agent with a sentence.

Sound, motion and live figures#

Hold ⌥H and hum — the pitch becomes the seed of a song. Answers can be live figures and simulations you steer rather than pictures, and video, drawing studios and music share the same canvas. Full-screen GPU scenes are on the way.

Any model, the same harness#

DeepSeek, Xiaomi MiMo and Zhipu GLM are built in. Any OpenAI-compatible endpoint works with your key — OpenAI itself, or a local server such as Ollama or LM Studio on loopback. Claude joins through Claude Code; Codex and OpenCode bring their own models. Where a single-vendor app picks the model family for you, here each chat picks its own — and can change its mind mid-thread.

Several models, one question#

Pick a model per chat and switch mid-thread without losing the history, let a second model cross-examine the first, or put several on the same question.

Every knob, in one place#

⌘, opens Settings as a side sheet with a lens for each part of the app — Appearance, Canvas, Terminal, Media, Music, AI, Models, Sources, Chat, Hosts, Vagabond and Memory. Changes apply live and save themselves; Reset returns to the defaults.

• Graphite · Claude · Codex · Neon
• Worlds · Geometry · Classics
• HDR glow
• frosted tiles
• depth: flat → dimensional
• reduce motion

All of it is plain text#

Everything the Settings screen shows lives in one plain-text file, settings.yaml — one section per area, one key per line. Edit it in any editor and Portal reloads it; save from the app and your comments, order and unrelated keys stay exactly as you wrote them. Any key can also be set from the environment — for one machine, a CI run or a demo.

window:
  width: 1440
  vsync: true
ui:
  accent: "#4C9EEB"
  reduce_motion: false
canvas:
  grid: true
  grid_size: 64          # comments survive every save
terminal:
  shell: "/bin/zsh"
  opacity: 0.98
ai:
  base_url: "https://api.xiaomimimo.com/v1"
  default_model: "mimo-v2.5"

• Live or next launch. Most changes apply at once; a few — window size, fonts, worker pools — on the next launch. The reference says which.
• Safe by construction. Values outside safe bounds are clamped; malformed ones are ignored, never guessed.
• No lost edits. Two changes to the same field pause the save and show both — Use file or Keep edits.
• No secrets in the file. Provider keys stay in the environment or the OS keychain.

411 settings, 26 sections#

The settings reference documents every key — its range, its default and whether it applies live. Canvas and AI carry the most; the long tail covers windows, motion, capture, notifications and more.

Per-chat and per-tile controls#

Each chat carries its own controls: a model picker grouped by provider with context size and price, quick settings such as temperature and history, a Session panel with progress, outputs, context and export (PDF, JSON, compact), and a Skills drawer to grant any skill in the library. Terminal tiles have theirs: look, font, typography, colours, cursor, rendering, harness and command template.

The Inspector — Wireshark for AI#

⌘I opens Portal’s diagnostic page. Its Traffic view is a capture of everything the app says to the outside world and everything that comes back: every model request with its streamed reply, every shell command with its transcript, every tool call — in full, in order, with timing, size and cost. The tap sits at the transport, not the UI, so nothing is missed; API keys are never part of a frame.

Open any frame#

A row opens its dissector. For a model request: session, purpose, endpoint, status, time to first token, total time, tokens in, out and reasoning, tokens per second, cost and size — then the request as its messages and the reply as it streamed. For a command: folder, who ran it, exit code, time and the whole transcript. For a tool call: the arguments and the receipt, or the refusal.

• first token
• tok/s
• tokens in · out · reasoning
• cost
• p50 · p95
• follow session
• copy as curl

Breakpoints on prompts#

Hold the next request from a chat’s ⋯ menu, or with a rule. It stops before it leaves, and the Held tab shows it as layers — identity, each skill or harness block, the live wired context, every message — each with a switch and its token weight, beside the model, temperature and a live cost estimate. If nobody answers, the original goes after a timeout, so an unattended agent never freezes.

A filter language#

Type to filter, or use tokens: the wire, the session, the model, the tool, the purpose, the outcome, an exit code, a token or cost threshold, a latency. Tags narrow further. Follow session shows one conversation’s requests in order, the way you follow a TCP stream; Copy as curl reproduces a request with the key read from your environment.

kind:ai model:deepseek-chat tokens:>4000
session:"Compare my options" failed
kind:term exit:!0 slow:>2s
purpose:review cost:>0.01
#status:429 #edited

Every run, recorded#

Every interactive run writes a capture file beside its log — one frame per line, complete bodies included — so you can open it with jq, attach it to a bug report or diff two runs. The next launch restores the previous run’s last 400 frames, so the Inspector opens onto history.

{"v":1,"id":12,"kind":"ai","ttfb":0.412,"took":6.91,
 "session":"Compare my options","purpose":"turn",
 "label":"deepseek-chat","endpoint":"https://api.deepseek.com/chat/completions",
 "request":"{\"model\":\"deepseek-chat\",\"messages\":[…]}","response":"…",
 "status":"HTTP 200","failed":false,"out":8123,"in":2210,"chunks":143,
 "tin":1890,"tout":412,"treason":-1,"cost":0.00081,"exit":-1}

Keys worth learning first#

Honest limits#

• Guards after the fact. Codex and other CLIs have no hook before a command runs: a guard is noticed afterwards and counted as “ran anyway”.
• Risk is not a sandbox. Risk levels route approvals; isolation comes from where the command runs.
• No automatic OCR. Image-only PDF pages beyond the first aren’t read, and encrypted PDFs must be unlocked first.
• Machines can stop. A kernel PTY can’t outlive its machine — you get an honest archived transcript, not a resurrected process.
• Reattached remotes keep their bundle. A remote session reopened from Recents keeps the harness it was born with; open it fresh to follow the tile.
• Numbers are from the lab. Machine timings were measured on a single-node lab host, and the hundred-tile board is a recorded fixture.