Artifact Server sends review comments to the agent that did the work. You comment on an exact version and send all open comments as one bundle. The agent can reply to each thread, resolve completed work, and publish the next version. You do not have to copy feedback into a chat window.
How the loop works
The agent connects
An extension in the agent’s harness registers it with your Artifact Server and polls for work. The agent appears in the review as a presence avatar. Its status ring shows whether it is idle, thinking, or replying.
You review and send
Leave comments on the version. The main control reads Send all open (N) to ‹agent›. One click sends the batch. An Undo toast appears for the next few seconds. To send one comment, use the send control on its card.
The agent replies and resolves
The agent receives the bundle as follow-up work after its current task. The agent reads each thread, replies, and resolves the completed work. The review shows each reply with the agent’s identity.
Artifact Server delivers each bundle at most once per work boundary. It holds the bundle while the session compacts. The UI reports delivery only after the host accepts the message. A bundle that is not delivered stays queued.
What each agent supports
Each agent exposes different runtime functions. Artifact Server shows the available delivery tier in the review.
| Agent | Tier | What happens on send | Presence |
|---|---|---|---|
| Pi | Native | The bridge injects the bundle into the running session. The agent replies and resolves through the native artifact_comments tool. |
Live |
| OpenCode | Native | OpenCode uses the same bridge core as Pi. Its prompt queue delivers the bundle to the active top-level session. | Live |
| Claude Code, channel | Channel | The bridge sends the bundle to the selected session as a channel event. The artifact_comments tool closes threads. |
Live |
| Claude Code, plain MCP | Mailbox | The bundle waits in the agent’s inbox. Each MCP tool result includes a one-line reminder until the agent claims it. | Inferred from recent tool calls |
| Codex, Cursor, Copilot | Mailbox | These clients use the same MCP inbox path. | None |
Native and channel tiers deliver into the running session. The mailbox tier waits until the agent next reads its inbox. The review shows “Queued for ‹agent›” while the bundle waits.
Connect your agent
Pick the agent you use. The choice is remembered across pages.
Install the extension
pi install npm:@plannotator/artifact-server-piOr add it to Pi’s settings.json:
{
"packages": ["npm:@plannotator/artifact-server-pi"]
}Point it at your server
A local Artifact Server needs nothing: the extension reads the managed local service’s discovery record. For a team server, set two variables before starting Pi:
export ARTIFACT_SERVER_ORIGIN=https://artifacts.example.com
export ARTIFACT_SERVER_AGENT_TOKEN=<token with agent:connect and comment scopes>ARTIFACT_SERVER_AGENT_NAME overrides the display name. The default is the name of the working directory.
Send a bundle
Open a review and add comments. Then click Send all open to ‹name›. Restarts, /new, and /resume keep the same agent identity. Pending bundles remain available.
Add the plugin
In opencode.json:
{
"$schema": "https://opencode.ai/config.json",
"plugin": ["@plannotator/artifact-server-opencode"]
}Point it at your server
The settings are identical to the Pi settings. The plugin discovers a local Artifact Server automatically. A team server requires ARTIFACT_SERVER_ORIGIN and ARTIFACT_SERVER_AGENT_TOKEN.
Send a bundle
The plugin targets the most recently active top-level session and never a subagent session. It is built against OpenCode 1.18.18 and the V1 plugin API.
Claude Code channels are a research preview, so this runs behind a development flag today.
Register the channel
Add it to the project’s .mcp.json:
{
"mcpServers": {
"artifact-server": {
"command": "npx",
"args": ["-y", "@plannotator/artifact-server-claude-channel@<release-version>"]
}
}
}The bridge uses the local discovery record to find a local server. A team server requires ARTIFACT_SERVER_ORIGIN and ARTIFACT_SERVER_AGENT_TOKEN.
Start Claude Code with the channel allowed
claude --dangerously-load-development-channels server:artifact-serverClaude Code prints one line at startup if a channel failed to register and names the cause. If you use a Team or Enterprise plan, turn on the organization’s channelsEnabled policy. Remove MCP_PROTOCOL_NEGOTIATION=auto from the session.
Send a bundle
The session appears in the review as a claude agent with live presence. Bundles arrive as <channel source="artifact-server"> events. Claude replies and resolves through artifact_comments.
Without a channel, Claude Code still works at the mailbox tier through plain MCP. See the Any MCP client tab.
Claude Code without a channel, Codex, Cursor, and GitHub Copilot connect through the built-in MCP server:
artifactserver connectComments sent to these agents wait in the agent’s inbox. Each MCP tool result includes a short reminder (2 review bundles are queued for your inbox. Call dispatch_inbox …) until the agent claims the work.
Several agents at once
With more than one connected agent, the send control becomes a split button. The main button uses the last agent selected for this project. The menu lists the other agents and their presence states. If that agent disconnects, the control asks you to select another agent.
Build an extension for another agent
Each extension is an adapter over @plannotator/agent-bridge (MIT). The bridge handles registration, claims, bundle format, and comment operations. An adapter supplies a HostPort for user notifications, session messages, and compaction state. The package documents the wire protocol in PROTOCOL.md. The Pi, OpenCode, and Claude channel adapters are available under integrations/.
When MCP supports Tasks and server-initiated events, standard MCP can replace these adapters. This change affects only the transport layer.