Plato

An AI coding agent for VS Code

An AI coding agent you can watch, and steer, while it works.

Most agents are a black box. You send a task, you wait, and you find out afterwards what happened. Plato shows the work as it happens, and lets you act on it in the middle.

Made by Applivity.

The Plato chat panel mid-task. A plan card, a tool-call summary and a streaming answer are visible. The composer shows Pause and Cancel, and the status line reads “editing a file”.
The chat, mid-task. A tool call is in progress and the composer shows its run controls.

Watch the work. Then change it.

This is the part most agents leave out. Plato writes each step into the conversation as it runs, and it reads what you type at the next safe point.

  1. 1

    You type a task.

    Describe the change in the composer. Plato starts.

  2. 2

    Plato works, in the open.

    Every tool call appears as it runs — the file it reads, the search it makes, the write it proposes.

  3. 3

    You type a correction, mid-run.

    The composer stays live while the work continues. Your message reaches Plato inside the same task.

  4. 4

    Plato reads it and changes direction.

    It picks up your guidance at the next safe point, and keeps going.

Watch

Every tool call is written into the conversation as it happens.

Guide

Typing during a run reaches Plato inside that run.

Pause

Plato stops at the next safe point. The button has three states, because a pause is a request before it is a fact.

/queue

Hold a message for the next task. During a run, the composer means “change this run”, so this is the one thing it cannot say.

A conversation where the developer typed guidance during the task. The transcript shows a “[guide]” row reading “Keep the public signature — sync.ts calls it directly”, and the composer reads “Guide Plato mid-run… (injected at the next safe point)” with Pause and Cancel buttons.
Guidance typed during a task, and the composer ready for more.

Three modes

The clearest description is the shortest one.

plan looks and does not touch. edit changes the project and asks first. auto asks nothing.

plan

Read-only. Plato can look at files and run commands that only read, but never changes anything on disk.

Nothing is written until you change the mode.

edit

Writes and commands, each behind an approval card.

A file you approve once is not asked about again this session.

auto

No approval clicks, web requests included. Plato runs end-to-end on its own.

Watch it, and stop it if it goes wrong.

The mode is remembered

The run record names the mode it began in, so you can always tell how a task started.

The mode is read live, at every tool call

Change it mid-run and it takes effect on Plato’s next action, in the same turn.

The mode picker open above the composer. Three modes are listed with their descriptions; edit is marked active.
The mode picker. edit is active.
A question card headed “Plato has a few questions”, with three tabs: Contract, Backoff and Tests. The open question asks whether the retry should change the public signature of upload(). Three options are offered, the first marked recommended.
Plato asks when the answer changes the design.

Where the modes differ on the web In plan and edit, a web request raises a card first. In auto, it does not — auto fetches without asking. Three limits still hold whatever the mode, and they are enforced in the request itself rather than by a card: a redirect onto a loopback or private address is refused, a non-text response is refused, and fetched content arrives labelled untrusted.

Nothing changes without a card

In edit, every write and every command raises a card first. The card shows what will change before it changes.

  • Your answer can cover one call, or the whole session.
  • A command is asked every single time, on purpose.
An approval card asking “Let Plato edit src/upload.ts?”. Below the heading is a unified diff showing a fetch call wrapped in a retry helper, with removed lines in red and added lines in green. Three buttons read “Allow once”, “Allow every edit this session” and “Deny”.
An approval card, showing a real diff before anything changes.

Put other models beside it

Plato is always the one doing the work. You can add other models to watch it, and to speak up.

Solo

Plato alone.

Duo

One more model watches, and can steer.

Academy

Up to five more models.

A watcher can intervene during a run, and can stop it. The team is edited in the settings panel.

The Orchestration settings, top to bottom: three mode cards (Solo, Duo, Academy; Academy selected); the project files block for PLATO.md and AGENTS.md; the Academy configuration with its Lyceum preset and Plato's model; then two philosopher cards, Aristotle the empiricist and Pythagoras the geometer, each with a role, a model, and powers to pause, cancel and intervene up to five times.
The team editor. Aristotle and Pythagoras are watching this run.

Undo, and what it will not do

Plato keeps its own copy of every file it replaces. /undo puts them back.

It refuses rather than overwrites.

If you changed the file after Plato did, the undo stops and says so. It will not destroy your edit to restore its own.

A file Plato created is removed, not restored.

The card says which one it is.

An undo card headed “Undo your last request?”. Under “Plato will undo” it lists src/upload.ts and src/upload.test.ts. Under “Plato will not undo” it lists src/upload-retry.ts, with the reason that the developer edited it after Plato did. The buttons read “Put back 2 files”, “Put back only src/upload.test.ts” and “Cancel”.
The undo card names both lists before it touches anything.

The limit Undo covers files. It cannot cover a terminal command. Nothing outside Plato’s own writes can be undone.

Protected files stay protected

A protected text file — a .env, a properties file, a keystore — reads with every value replaced by a marker, such as «masked:API_KEY».

  • Plato sees the keys, the comments, and the line structure. It does not see the values.
  • The model never holds a value it could move.
  • If a value must be shown, Plato asks first, on a card that states the cost.

The rest of the work

  • Live answers. Replies stream as the model writes them.
  • It reads the editor’s own errors. After a write, Plato collects the language server’s errors for the affected files and gives them back to the model in the same turn, so it learns immediately that it broke something.
  • A task is bounded by repetition, not by a step count. There is no turn limit. If Plato repeats a failing action, it is nudged, then asked. Nothing is stopped silently.
  • Bring your own model. Anthropic, or any OpenAI-compatible address — a local server, a proxy, or a hosted provider. Keys are kept in the VS Code secret store.
  • MCP servers. Plato can use tools from MCP servers you configure.
  • A record of every task. One transcript per task in ~/.plato/runs/. Old ones are compressed, and you can delete one or all of them.
  • Images. You can attach an image to a message.
  • Project instructions. A PLATO.md in the project overrides the global one. Plato also reads AGENTS.md and CLAUDE.md.

Everything Plato owns lives in one folder

~/.plato/, outside the project. The project itself is only read, except for the edits you approve.

  • ~/.plato/PLATO.md the global default instructions
  • ~/.plato/DUO.yaml the Duo teammate
  • ~/.plato/ACADEMY.yaml the council of philosophers
  • ~/.plato/mcp.yaml MCP servers
  • ~/.plato/runs/<key>/ one transcript per task

Five commands

CommandWhat it does
/compactSummarise the conversation to make room. Your transcript is kept.
/historySee and reopen earlier conversations.
/system-promptWrite the project’s PLATO.md.
/undoPut back the files Plato replaced.
/queueHold a message for the next run.

The queue is held in memory. A window reload loses it, as it loses the task.

The context panel pinned open. It lists total, system, user, assistant and tool token counts, the maximum, the last request, and a compaction threshold slider set to 80 percent. A note reads that the figures are an estimate.
The context panel, with the compaction threshold. The figures are an estimate, and the panel says so.

Fourteen tools

read_filewrite_fileapply_diffapply_patchlist_dirgrepglobgitshellbash_outputkill_shellweb_fetchask_usertodo_write

How to get it

Plato is on the VS Code Marketplace. Install it from there, or from a .vsix file if you already have one.

  1. From the Marketplace

    Search Plato by Applivity in the Extensions view, or open the listing. 

    code --install-extension applivity.plato

  2. From a .vsix file

    If you have the file, open the Extensions view and choose Install from VSIX…, or run: 

    code --install-extension plato-<version>.vsix

Plato is an early release, and it changes quickly. It is on the VS Code Marketplace, and its source is not public. Licensed under the Apache License 2.0.

The VS Code activity bar with the Plato owl mark at the bottom of the icon column, active. To its right, the Plato sidebar shows its two rows: Open Chat and New Chat.
Plato sits in the activity bar.

After it installs

The owl appears in the activity bar. Open it to start a task, or open the Orchestration settings to change the mode and the team before you send anything.