Plato

Plato puts the agent you already run inside the browser page: a view beside whatever is open, where you talk to Claude Code, Codex, or any command that speaks the Agent Client Protocol, and the page hands over what is on screen as context. The agent runs in the root, reads the same instructions and me.md every agent does, and works under the same role contract. On by default (eidos plugin disable plato switches it off); the plugin’s page names the agent this machine talks to.

Nothing of eidosmd’s own is in the loop: no model, no key, no endpoint. Nothing leaves the machine but through the agent you configured, under its own permissions.

In the browser

• A Plato view in the Auxiliary Sidebar: a conversation with the agent, started in the root on the first message with EIDOS_ROOT set.
• Context without asking. What the page has open rides each message: a blueprint by title, id, and file; a canvas page; a collection’s table and its filter; a settings tab; a top-level doc. It shows on the composer as a chip you can drop for one message or add a blueprint to, and the plugin words it to the agent. The first message of a session carries a standing note: where the agent is, what to read first, that its job is the root folder and nothing outside it, that the docs are eidos standard and eidos instructions, and the persona.
• The reply streams as the agent answers. Its tool calls and the files it changed are listed under the answer, and the reader and the tables refresh as for any change on disk. A message can be stopped.
• Permissions are the agent’s. A permission request the agent raises is shown as the agent worded it and answered in the view; nothing is approved on your behalf, and you are in the view for every message. The agent’s file reads and writes are answered inside the root only.
• Grilling. /grill in the message box (offered as you type the slash, with anything after it as your opening) starts a conversation in which Plato questions what is open: it reads the blueprint, or the framework, and asks one question at a time about what the text leaves unsaid, never answering for you. It asks only what your role can answer, in its words and depth: the role of the user picked as you under Users, else the one in .eidos/me.md, with its contract, and your calibration from me.md when its role is the same. Picking a user of another role is standing in for them: Plato grills you as that user, by their role alone. What did we find? closes it with each gap, what you said, and where in the blueprint it belongs, the gaps for another role listed apart with the role that decides each, and offers to write them in through the agent’s usual permission.
• A commit message for Git. With the Git plugin on, Summarize in Source control and each auto save ask Plato for a one-line commit message. It answers in a session of its own, kept in no conversation, with no edit and no tool allowed; while the agent is answering a conversation, the auto save uses a plain message instead. Commit messages on the plugin’s page words what it is asked, the changes following; empty, one subject line in the imperative under 100 characters.
• Plato: Focus Plato, in the palette, shows the view and puts the caret in its message box.
• Conversations are shared with the root, so anyone on it can open and continue one, or private. A conversation continued after the agent restarts goes on in the agent’s own session, reloaded through ACP’s session/load where the agent offers it; otherwise a new session is told the turns so far, and nothing extra shows in the conversation.

Connecting the agent

Plato does not bring an agent; it starts the one on your computer through that agent’s ACP adapter, fetched with npx the first time. So a machine needs three things: Node.js (which gives npx), the agent’s own sign-in, and a model the account can use.

• Codex signs in with npx -y @openai/codex login (a ChatGPT account) or an OpenAI key in OPENAI_API_KEY, which Plato hands to the adapter when nothing else is signed in. It reads its model from ~/.codex/config.toml; a model = line naming a model the account cannot use makes every answer an error.
• Claude Code signs in with /login in claude (or npx -y @anthropic-ai/claude-code).

The bar under the agent on the plugin’s page tests the agent picked, and picking one tests it: Node.js found, the agent started, signed in, and answering one short message, each step marked, with what to do for the step that failed and Copy details to send to whoever helps. The test runs an agent of its own, so a conversation in progress is not touched.

The persona

Plato answers as Plato: curious, plain, a little dry, fond of a good question and of a short answer. That is a voice and nothing more; the role contract in me.md and the instructions decide what it surfaces and who holds a decision. The plugin’s page offers Plato’s voice, your own text, or none.

On disk

• .eidos/plugins/plato/local.yaml, private: the agent (claude-code, codex, or custom), command (the ACP command to run; unset, the named agent’s adapter through npx, fetched on first use), persona_mode (plato, own, off), and persona (your own text). Never committed: the agent you talk to does not travel with the root.
• .eidos/plugins/plato/settings.yaml: commit_prompt, what Git’s commit message is asked with, shared with everyone in the root; and Plato as a user (as_user, on by default) with Plato takes actions as (acts_as): the user Plato’s comments are signed as, by default a user Plato (@plato, an agent with no role) the plugin adds to the root’s users the first time it is needed. Pick another user (say, Sammy) and Plato signs as them; switch it off and Plato comments as nobody, its comments refused. From a shell, eidos plugin set plato as_user off or eidos plugin set plato acts_as sammy.
• .eidos/plugins/plato/conversations/<id>.yaml: a shared conversation, committed. .eidos/plugins/plato/local/conversations/<id>.yaml: a private one, never leaving the machine. Each holds the messages, the context each carried as it was worded, the files an answer changed, and the agent’s session id.

From the shell

There is no eidos plato: asking the CLI to ask your agent, from your agent, is a loop with nothing in it. The page is the only surface for talking to it. Its settings are written from the shell as any plugin’s are:

eidos plugin set plato agent codex                # the agent, private, in local.yaml
eidos plugin set plato command "my-agent --acp"   # a command of your own that speaks ACP
eidos plugin set plato agent --unset              # back to Claude Code, the default

What the check reports

Nothing. Off or unconfigured, there is no process, nothing is sent anywhere, and the plugin’s page says which.