Claude Code plugin

Two commands give Claude Code full access to your Everythings workspaces, plus /things, a pane beside the conversation that, while follow is on, opens each thing the agent writes in that session, and /everythings:panel, a live claude.ai panel that follows along while an agent builds things for you. A band above the prompt counts the questions waiting on you and the @Agent jobs waiting on the agent, and a session that asked you something carries on once you answer.

Install

Anthropic is still reviewing the plugin for Claude's plugin directory, so it isn't under Customize β€Ί Plugins β€Ί Discover yet. Until it is, add it from its GitHub marketplace with the steps below. It is the same plugin, and a copy added this way keeps updating from GitHub after the listing goes live.

Claude Code

In a terminal (or with /plugin inside Claude Code):

claude plugin marketplace add bbabkin/everythings-claude
claude plugin install everythings@everythings-claude

You'll need an Everythings account (the free plan works). On first use, Claude Code opens the Everythings sign-in: approve the access it asks for; no token to copy. The plugin's source lives at github.com/bbabkin/everythings-claude.

claude.ai, Claude Desktop, and Cowork

  1. 1. Open Customize β€Ί Plugins.
  2. 2. Choose Add β€Ί Add marketplace and enter:
bbabkin/everythings-claude
  1. 3. Find Everythings in the plugin list and select Add.
  2. 4. Connect the Everythings connector as described in Set up the panel. Adding a plugin doesn't sign you in to anything, so the tools stay unavailable until the connector shows Connected.

The plugin is saved to your Claude account. Cowork loads it the next time you start a task, and Claude Code downloads it the next time you start a session signed in to the same account (run /reload-plugins in a session that is already open). On Team and Enterprise plans, an Owner decides whether members can add marketplaces.

Without the plugin system (Claude Code)

Two of the plugin's pieces can be placed by hand: the server and the /panel skill. The /things pane comes with the plugin only. First add the Everythings server to every project, then run /mcp inside Claude Code and pick everythings to sign in:

claude mcp add --transport http --scope user everythings https://www.everythings.app/api/mcp

Then copy the /panel skill into your personal skills folder, so its file ends up at ~/.claude/skills/panel/SKILL.md (macOS, Linux, or Git Bash on Windows):

git clone https://github.com/bbabkin/everythings-claude
mkdir -p ~/.claude/skills
cp -r everythings-claude/plugins/everythings/skills/panel ~/.claude/skills/

Start a new session and run /panel. Pick one: this path or the plugin. A copied skill doesn't update itself: pull the repository and copy the folder again to get a newer panel.

What you get

Your things, in every project

Claude can search, read, and (with write access) create, edit, and organize your workspaces and things from any session: capture ideas mid-task, pull up your lists, save results where they outlive the conversation. Deletes only ever go to Trash; an agent can never permanently destroy your data.

/things: a pane in Claude Code

A pane beside the conversation: your workspace as a grid of things, and each thing with its content, marks, comments, and any question an agent asked. While follow is on it follows the session's own writes, so each thing the agent creates or changes opens there as soon as the write finishes. /findthing searches every workspace and lists the hits there. It writes only your own mark when you press one, and your own comment when you send one.

What is waiting, above the prompt

A band above Claude Code's prompt shows ❓ the open questions agents asked you and πŸ€– the open @Agent jobs people left in comments, across all your workspaces. Press a count to list them in the pane. The band hides when both are zero.

The session carries on when you answer

When the agent asks you a question and ends its turn, answer in the app or on your phone. Within about five minutes the plugin wakes the Claude Code session, and the agent reads your answer and goes on. You don't need to come back to the terminal to tell it.

Readable writes in the conversation

Each Everythings write the agent makes reads as one line, such as β€œupdated πŸ‹ Lemon cake”, with the thing's name linking to it in the app, in place of the tool's name over its raw JSON.

/everythings:panel, your live panel

One command publishes your private panel: a claude.ai page showing your workspaces as the app does: floating emoji tiles, Markdown content, marks, and comments, refreshing on its own. It shows which things an agent wrote, the questions it is waiting on you for, and what is in your inbox. Read-only by design.

Follow mode

On from the moment the panel opens: every thing an agent creates or updates opens on screen as it happens, breadcrumbs and workspace switches included. Ask for a trip plan and watch it assemble itself; the radar toggle turns following off.

An interactive view in the chat

Where the client supports it (claude.ai, Claude Desktop, ChatGPT on the web), asking to see your things draws a card in the chat: a workspace as a grid of emoji tiles, or a single thing with its Markdown content, sub-things, marks, and comments. Click a tile and it opens in place. Clients that don't render it still get the same answers.

Open the pane

In Claude Code, run:

/things

The pane opens beside the conversation. The first time in a session it shows your default workspace (else the last workspace you opened there, else the first); after that it reopens where it last was. It draws what this session's Everythings calls carried, then reads through the same Everythings server the agent's calls use to complete the screen. When that read cannot go through and the pane has nothing to show yet, it asks Claude in the chat to show the page, once, and fills in when Claude has read it.

To find a thing in any workspace, run /findthing with the words to look for:

/findthing groceries

The pane lists the hits, one row each with the workspace it is in; press one to open it. Searching pauses follow.

  • A workspace shows as a grid of cards, and a thing's sub-things as a list, one per row; a sub-thing's row starts with the emojis of its marks, then a bar, then its emoji and name. Press a card or a row to open it. On a thing, the top of the pane leads back: the grid button returns to the workspace, and the button after it opens the thing this one sits under. Refresh reads again; a page read in the last 30 seconds opens without a new read.
  • A thing's marks are one row of buttons: the workspace's default marks in their order, then any other mark the thing carries. Each button shows the emoji and how many carry it; yours stand out as the main button. Press one to put your mark on or take it off; the button changes where it sits, and a line under the row says what happened (for example, Added your βœ… done mark.). On a thing with no marks, the workspace's default marks show dimmed. Once the pane has read a thing's comments, a field under them takes a comment of your own: type it and press Enter. The phone has no field. A mark or comment from the pane is yours and carries the agent's label, since the pane writes through the agent's connection: the apps show the comment via the agent, and the pane shows it as You until it next reads the thing.
  • /things turns Follow on: each thing the agent writes in this session opens as soon as the write finishes. Pressing a thing, a workspace or the back button pauses it until you press Follow again; Refresh and Retry leave it as it is.
  • The band above the prompt shows ❓ open questions and πŸ€– @Agent jobs, each hidden at zero. Press one to list them in the pane, each row with its thing, its workspace and the question or the comment; press a row to open the thing. The counts update when the session starts, after each Everythings call in the session, and when you press Refresh.
  • Each Everythings write the agent makes shows in the conversation as one line: the verb and the thing, such as β€œcreated πŸŒ‘ thing icon shadow color”, with the name linking to the thing in the app. A call that failed, is still running or was interrupted keeps Claude Code's usual row.
  • Under auto permission mode Claude Code refuses the pane's own reads until you allow its six read-only tools, get_thing_view, get_workspace_view, get_workspace, search_things (the search behind /findthing), list_requests and list_mentions (the band and the check for your answers), in Claude Code's permission settings (see Make sure the pane works). The pane's note shows the rules as your setup spells them, with a Copy the rules button; add them and press Refresh. Until then the pane shows what the agent's own calls carried, so a thing the agent just wrote appears in full, and it reads nothing of its own until you press Refresh. Dismiss hides the note until a Refresh you press is refused again.
  • A thing Claude has not read yet shows its name and an Ask Claude to open it button, which asks Claude in the chat for you; the page fills in once Claude reads it. A workspace with nothing listed yet offers Ask Claude to list it.
  • Ask Claude to show you a thing or a workspace and it calls show_thing, which opens it in the pane.

Make sure the pane works

  1. 1. Use a Claude Code that runs mods: the desktop app's Code tab, or the terminal CLI kept up to date with claude update.
  2. 2. Get the newest plugin. The pane needs 0.3.0 or later, /findthing 0.4.0, and the band and the wake on answer 0.4.3; claude plugin list shows the version you have. To update:
claude plugin marketplace update everythings-claude
claude plugin update everythings@everythings-claude
  1. 3. Allow the pane's own calls. Under auto permission mode Claude Code refuses them until they are in permissions.allow of ~/.claude/settings.json. Merge these into that file:
{
  "permissions": {
    "allow": [
      "mcp__plugin_everythings_everythings__get_thing_view",
      "mcp__plugin_everythings_everythings__get_workspace_view",
      "mcp__plugin_everythings_everythings__get_workspace",
      "mcp__plugin_everythings_everythings__search_things",
      "mcp__plugin_everythings_everythings__list_requests",
      "mcp__plugin_everythings_everythings__list_mentions",
      "mcp__plugin_everythings_everythings__add_mark",
      "mcp__plugin_everythings_everythings__remove_mark",
      "mcp__plugin_everythings_everythings__add_comment"
    ]
  }
}

The first six only read; list_requests and list_mentions are the band's counts and the check for your answers. The last three let through the marks and comments you make from the pane; they also let Claude's own calls of those three tools through without asking. The rules name the plugin's server, plugin_everythings_everythings. If Claude reaches Everythings through another connector in your setup, such as the claude.ai connector, which the desktop app lists under a long id, the pane uses that one: press Copy the rules in the pane's note and add those as well.

  1. 4. Run /reload-plugins in a session that is already open, or start a new one. Until then a session keeps the plugin version it started with.
  2. 5. Run /things. If it is not in the command list, go back to steps 1 and 2. If the pane shows a note instead of your workspace, the rules it names are not allowed yet: add them and press Refresh. If it says the Everythings connector is not connected, run /mcp and sign in to everythings.

Set up the panel

The panel reads your data through a claude.ai connector (one-time setup):

  1. 1. Open the Everythings listing at claude.ai/directory/everythings and click Connect (it's also under Customize β€Ί Connectors). On builds without the directory, choose Add custom connector and paste:
https://www.everythings.app/api/mcp
  1. 2. Sign in to Everythings when prompted (keep the connector named Everythings).
  2. 3. In Claude Code, run /everythings:panel. Your panel opens in the side panel and keeps its address from then on.

The same connector also gives claude.ai the Everythings view: ask Claude there to show a workspace or a thing and it draws it inline in the conversation, one screen per answer. The panel is the standing version of that: it stays open beside your work and follows an agent from thing to thing. See The view in the chat for what the inline view does.

Things to try

β€œPlan a trip to Spain in my Everythings”

The agent creates a Spain thing with nested Tickets, Hotels, and Itinerary things and fills each with research. In Claude Code the /things pane, with follow on, opens each thing as soon as the agent's write finishes; in claude.ai the panel's follow mode opens it within about 30 seconds.

β€œAdd milk and eggs to my groceries thing”

The agent finds your Groceries thing by name and appends the items to its list, from any project, mid-task.

β€œWhat's on my reading list?”

The agent searches your things, reads the right one, and answers inline, with no app switch.

β€œSave a summary of this session's decisions into my project workspace”

The agent writes a new thing capturing the outcome, so the knowledge outlives the conversation.

β€œ/things”

In Claude Code, the Everythings pane opens beside the conversation: on your default workspace the first time in a session, and where it last was after that. Press a thing to read its content, marks, comments, and any question an agent asked. /things turns follow on, so each thing the agent writes in this session opens there as soon as the write finishes.

β€œ/findthing groceries”

The pane opens on a search of every workspace for groceries: each hit is a row naming its workspace, and pressing one opens it. Follow pauses while you look.

β€œAsk me in Everythings which design I prefer, then carry on”

The agent asks with request_input and ends its turn. Answer in the app or on your phone. Within about five minutes the plugin wakes this Claude Code session with a message naming the thing, and the agent reads your answer and goes on.

β€œ/everythings:panel”

Your live panel opens in the claude.ai side panel: workspaces, things, content, marks, and comments, refreshing as data changes.

Using Claude on the web, ChatGPT, or Gemini instead? The same server connects everywhere. See Connect an agent.

Questions

What exactly gets installed?
Three pieces. First, the Everythings MCP server is wired into every Claude Code project, so the agent has workspace and thing tools wherever you work. Second, a Claude Code mod (a plugin of function hooks) that adds the /things and /findthing commands, a pane beside the conversation, a band above the prompt with the questions and @Agent jobs waiting, the wake that carries a session on when you answer its question, one-line rows in the conversation for the agent's Everythings writes, and a show_thing tool the agent can call. Third, the /everythings:panel skill: it publishes your personal panel page as a private claude.ai artifact and reopens it on demand.
How is the /things pane different from the panel that /everythings:panel opens?
The pane lives inside Claude Code, beside the conversation. While follow is on it follows the writes of this session, with no polling: when one of these Everythings calls finishes, the pane shows the thing it wrote, from what the call carried, and then reads it to complete the page: create_thing, update_thing, move_thing, delete_thing, restore_thing, copy_thing, add_mark, remove_mark, add_comment, request_input, answer_request, resolve_request and resolve_mention. Deleting the thing on screen returns the pane to its workspace grid; deleting any other thing reads the screen again. add_mark, remove_mark, add_comment and resolve_mention are names other servers use too, so the pane follows them once it knows which server is Everythings, which it learns from any call of a tool only Everythings has, such as create_thing or get_thing. The panel is a private claude.ai artifact. It polls about every 30 seconds and follows writes from any session, including Cowork and other machines. Use the pane while you work in Claude Code, and the panel in claude.ai.
What should an agent call when the person asks to see a thing?
In Claude Code with this plugin, call the show_thing tool (listed as mcp__everythings__show_thing) whenever it is in your tool list. Pass thingId to open that thing in the pane, workspaceId to open a workspace's grid, or neither to open the person's default workspace. Calling it only displays; it changes no data. When its answer says the pane could not load the thing, call get_thing_view with that thingId yourself; the pane shows its result. When show_thing is not in your tool list, call get_thing_view for a thing or get_workspace_view for a workspace. To read a thing for yourself, call get_thing.
How does a Claude Code session pick up my answer?
When the agent in a session asks you a question with request_input, the plugin remembers it. While the session stays open it checks for an answer every 5 minutes, for up to 2 hours after the question. When you answer, in the app or on your phone, the next check sends one message into the session naming the thing, and the agent reads your answer and carries on. Each question wakes the session once. Only questions that session asked wake it, and a closed session wakes for nothing: an agent run later picks the answer up with list_requests. The check uses list_requests only, never what_changed, so it does not move the agent's place in what changed.
What does the pane show when Claude Code refuses its reads?
Under auto permission mode Claude Code refuses the pane's own reads until you allow its six read tools, get_thing_view, get_workspace_view, get_workspace, search_things (the search behind /findthing), list_requests and list_mentions (the band's counts and the check for your answers), for your Everythings connector in Claude Code's permission settings. All six are read-only. A refused count hides only the band until you press Refresh, and a refused check for answers stops that session's checks; neither blocks the pane. The rules name the connector as your setup spells it (a long id in the desktop app), so copy them with the Copy the rules button in the pane's note, add them, and press Refresh. Until then the pane shows what this session's own Everythings calls carried, so a thing the agent just created or updated appears in full, and it makes no read of its own until you press Refresh. Sections no call has carried yet, such as sub-things, marks or comments, are missing. A thing Claude has not read yet shows its name and an Ask Claude to open it button, which asks Claude in the chat for you, naming the thing by its id; the page fills in once Claude reads it. Dismiss hides the note, in later sessions too, until a Refresh you press is refused again: that shows it again, in later sessions as well, until you dismiss it once more. When Claude Code refuses a mark or a comment, a line under the marks or under the comment field says so, and a second note gives the rules for add_mark and remove_mark, or for add_comment, with its own copy button; it shows beside the note for reads when both are up, and goes once a mark or comment of the same kind goes through.
Which Claude Code versions run the pane?
The pane is a mod, so it needs a Claude Code version that runs mods (function hooks): the desktop app's Code tab, or the terminal CLI kept up to date with claude update. It also needs plugin 0.3.0 or later. /findthing needs 0.4.0, and the band, the wake on answer and the one-line write rows need 0.4.3. Where mods are unavailable or the plugin is older, the features it lacks are absent, and the MCP tools and /everythings:panel still work as before. If the pane says the Everythings connector is not connected, run /mcp in Claude Code and sign in to everythings. Make sure the pane works, above, lists every step.
Is the panel shared? Where does it live?
The panel is a private artifact on your own claude.ai account, reading your data through your own Everythings connector. Every user publishes their own copy; nothing is shared unless you explicitly share it.
How is the in-chat view different from the panel?
The view is drawn by the client itself, inline, when the agent shows you a workspace or a thing (when you ask to see one, or right after a write you asked for): click a tile to open it, click a breadcrumb to go back, all without leaving the conversation. The panel is a page of your own that stays open beside the chat, refreshes on its own, and follows an agent's writes even from another session. The panel only reads; the view writes one thing, a checklist box you tick. Neither answers a question an agent asked you: both show it, and you answer in the app or by telling the agent. Both read the same connector. Clients without MCP Apps support (ChatGPT's phone apps, Gemini and the CLIs) receive the ordinary text answers, unchanged.
How live is the panel?
The panel refreshes on a poll of about 30 seconds, the connector platform's floor. Its follow mode opens things within half a minute of an agent writing them, from any session. For instant follow inside Claude Code, use the /things pane: it opens each thing this session writes as soon as the write finishes.
Can the pane or the panel change my data?
The panel is read-only: it requests only read tools. The pane reads with get_workspace_view, get_thing_view and get_workspace, searches with search_things, counts the band with list_requests and list_mentions, checks for your answers with list_requests, and writes two things, each only when you act: your mark when you press a mark (add_mark, or remove_mark when the mark is yours), and your comment when you send one from the field under the comments (add_comment, a top-level comment, sent as typed). Each is one call, never retried. The call rides the agent's connection, so a mark or comment from the pane is yours and carries the agent's label: the apps show such a comment via the agent (the pane shows it as You until it next reads the thing), and other members of a shared workspace are notified of it as of any comment. The pane writes nothing else; the wake on answer sends a message into the session and changes no data. Both show a question an agent asked you, on the thing it is about, with its options and, once you have answered, your answer; you answer it in the app or by telling the agent, because an answer sent from the pane would ride the agent's connection and read as the agent answering itself. Creating and editing things happens through the agent's MCP tools, which you grant separately at sign-in, or in the app itself.
Does this work in Claude Cowork?
The tools do: a Cowork agent can research and file everything into your workspaces. Publishing the panel itself needs Claude Code (CLI or web) or claude.ai, so run /everythings:panel once there. Then keep the panel open in a browser beside Cowork: with follow mode armed it opens each thing as the Cowork agent writes it, because the panel follows your data, whichever session writes it.
How do updates arrive?
Plugin updates come from the GitHub marketplace. In Claude Code, run claude plugin marketplace update everythings-claude, then claude plugin update everythings@everythings-claude, and run /reload-plugins in any session that is already open (or start a new one): until then a session keeps the version it started with. In claude.ai, select Check for updates under Customize β€Ί Plugins, or turn on Sync automatically for the marketplace. After an update, the next /everythings:panel republishes the newer panel to your same private URL. A skill you copied by hand stays at the version you copied.
How do I revoke access?
Revoke the agent's rows under Settings β€Ί MCP Access Tokens in Everythings. A token you created stops for good, and revoking the claude.ai connector's OAuth: row ends every token it holds for you, refresh tokens included, so it is disconnected within a minute. Then uninstall the plugin in Claude Code, or remove it from its menu under Customize β€Ί Plugins in claude.ai, and remove the claude.ai connector under Customize β€Ί Connectors if you added one, so nothing on that side still points at Everythings.

Still need help?

Email us and we'll help you out. Include your account email and a short description of the problem.

support@everythings.app