Wireface Desktop

MCP servers and skills

The panel's Tools tab shows the MCP servers and skills of the agent behind the face, with a switch for each that changes the agent's own configuration, and recommends some to install. It works with Claude Code, Codex and OpenCode.

On this page

The Tools tab
MCP servers
Skills
Turning one off
When a change applies
Recommended
What Install does
Keys and tokens
Backups
What it can't change

The Tools tab

Right-click the face and choose Tools, then MCP servers... or Skills..., or open the panel and pick Tools, the tab after Activity.

Everything comes from the agent's own configuration for the working folder: the same files the agent reads, so choosing another agent or folder changes what's shown. A switch changes the agent's configuration the way the agent's own commands do, and nothing else.

At the top are the agent and the folder it works in, and when its servers were last checked, with a green dot while its session runs, and a refresh button. Below them are two sub-tabs, MCP servers and Skills, each with how many there are, and a red count of servers with a problem. The panel remembers which one you used last.

Finding things

Each sub-tab has its own search and filters, and remembers them:

Search looks through names, descriptions, where things come from, commands, addresses and tool names, and marks what it finds. Press / to search, and Esc to clear it.
Installed, Recommended or All. Installed, the default, is what the agent has. Recommended is what Wireface suggests installing, and All is both.
Any, On, Off and, for servers, Problems narrow what's installed.

While a search or filter hides something, the tab says how many it's showing, with Clear filters.

What's installed

Installed servers and skills are grouped by where they come from, with any that have a problem first. Each one has its name and a label for where it's from, its status, and a line about it. On the right is its switch, or a lock for one that can't be switched here: click the lock to see why.

Click an item for its details: the command it runs or its address (with keys, tokens and passwords taken out), the names of the environment variables and headers it's given, its tools, any error, the file it's defined in, and exactly what its switch changes and in which file.

MCP servers

Each server says how it runs (its transport, and its command or address) and the names of the environment variables and headers it's given. Their values are never shown: see Keys and tokens. The groups, in the order they're shown:

Group	Where they come from
Built into Wireface	The face itself (below)
This folder	Yours, only for this working folder (Claude Code's local scope)
Project	The project's own configuration, shared with it
Yours	Your own configuration, for every folder
Plugins	A plugin
claude.ai	Your claude.ai account (Claude Code)
Built into the agent	The agent itself
Managed	Your organisation
Other	Known only to the agent

Status	What it means
Connected	It's working, with its number of tools when the agent says.
Failed	It didn't start or connect. The reason is in its details.
Can't start	The program it runs, such as `npx` or `uvx`, isn't on this PC, or isn't on the `PATH`.
Needs sign-in	Sign in to it: from `/mcp` in Claude Code, with `codex mcp login NAME`, or with `opencode mcp auth NAME`.
Connecting	It's still starting.
Off	It's switched off.
Not checked	It hasn't been checked yet, or the agent doesn't say.
Built in	One of the face's own servers.

A server that's on but failed, needs sign-in or can't start has a problem: it's marked in red, listed first in its group, and counted on the MCP servers sub-tab. Problems shows just those.

How they're checked

The agent checks its own servers, in the background, so the tab never waits for it:

Claude Code: the face's running session, which also knows the servers that come from plugins and claude.ai. While no session is running, claude mcp list.
Codex: codex mcp list --json, which says only whether a server is on and whether it needs signing in to. Codex connects to the others when it works on a request.
OpenCode: opencode mcp list.

A check connects to every server, so it can take a while. The result is kept for ten minutes for each agent and folder: opening the tab after that checks again, and refreshing checks now. If a check fails, the tab says why and asks whether the agent is installed and signed in.

The face's own servers

The servers Wireface gives the agent are grouped first, under Built into Wireface:

face (Claude Code): expressions, and going away and coming back. It's part of the face, so it has a lock instead of a switch.
computer, browser and claude-in-chrome (Claude Code): the Computer, Browser and Your Chrome switches of Using this PC. Switching one here changes that setting (backend.tools in the face's profile.json), which restarts the agent; the conversation continues.
phone: while the phone line is on, for any agent. It goes with the line (Agent tab, Phone), so it has a lock too.

Skills

Skills are grouped the same way as servers, each with what it's for, from its SKILL.md, and its folder in the details. A skill that's off says Off. A Claude Code skill set to show the agent only its name says Name only, and one used only when you ask for it by name says Only when asked.

Turning one off

Each switch writes what the agent's own command would. Turning it back on undoes that change.

Agent	An MCP server off	A skill off	Applies
Claude Code	Its name in the project's `disabledMcpServers` in `~\.claude.json`, as `/mcp` does	`"skillOverrides": {"NAME": "off"}` in the project's `.claude\settings.local.json`, as `/skills` does	Servers at once while the session runs; skills from the next session
Codex	`enabled = false` in the server's `[mcp_servers.NAME]` table	A `[[skills.config]]` entry with `enabled = false` in `~\.codex\config.toml`, as its `/skills` does	From your next message
OpenCode	`"enabled": false` (v1) or `"disabled": true` (v2) in the server's entry	A rule denying the skill in the global `opencode.json`	When OpenCode restarts

~ is your home folder, C:\Users\you. Each agent's details:

Claude Code

Where they are. MCP servers: in ~\.claude.json (yours in its mcpServers, this folder's in the project's entry under projects), in the project's .mcp.json, in plugins that are on, and from claude.ai. Skills: in ~\.claude\skills, in .claude\skills in the working folder and each folder above it up to your home folder, in plugins, and synced from claude.ai.
The project is the working folder's git repository, or the folder itself if it isn't in one. The switches are kept for that project, as Claude Code's own are. CLAUDE_CONFIG_DIR moves ~\.claude and .claude.json.
A server: its name goes into the project's disabledMcpServers, or comes out of it. While the face's session runs, the switch goes through the session itself, so it applies at once and is remembered. Servers from plugins and claude.ai switch the same way.
A skill: "NAME": "off" goes into skillOverrides in the project's .claude\settings.local.json. Turning it on takes that out; if your own or the project's settings.json turns the skill off, it writes "on" instead, which overrules it.
Not here: skills that come with a plugin go with the plugin (/plugin in Claude Code), and skills synced from claude.ai are turned off in claude.ai's settings. A server in the project's .mcp.json that your settings reject (disabledMcpjsonServers) shows as off and can't be switched here.

Codex

Where they are. MCP servers: [mcp_servers.NAME] tables in ~\.codex\config.toml, and in .codex\config.toml in the project root and each folder down to the working folder (Codex reads those only in folders it trusts). Skills: in ~\.agents\skills, ~\.codex\skills (its own are marked Built in), the project's .codex\skills, and .agents\skills from the project root down to the working folder. CODEX_HOME moves ~\.codex.
A server: enabled = false goes under its table's header, in the file that defines it, and turning it on sets that back to true. Every other line stays as it was.
A skill: turning it off adds an entry to ~\.codex\config.toml, and turning it on takes the entry out again:

[[skills.config]]
path = 'C:\Users\you\.agents\skills\review-aloud\SKILL.md'
enabled = false

Before writing, Wireface checks that the file is still valid TOML and that only that one setting has changed. If not, nothing is written. Codex runs once for each message, so a change applies from your next one, with no restart.

OpenCode

Where they are. Its global config is opencode.json in ~\.config\opencode, or opencode.jsonc if there is one (OPENCODE_CONFIG_DIR, or opencode in XDG_CONFIG_HOME, moves that folder). Then come opencode.json and .jsonc in the working folder and the folders above it, and the same in their .opencode folders. A server's entry in a later file replaces the whole of an earlier one.
Skills are in skill and skills in OpenCode's config folder, in ~\.claude\skills and ~\.agents\skills, and in .opencode\skill, .opencode\skills, .claude\skills and .agents\skills in the working folder and each folder above it. A skill is named after its folder.
A server: "enabled": false (OpenCode 1) or "disabled": true (OpenCode 2) in its entry, in the file that defines it.
A skill: a rule denying it, in the global config. Wireface asks opencode --version which kind to write. Turning the skill on takes the rule out again.

// OpenCode 2 and later
"permissions": [
  { "action": "skill", "resource": "review-aloud", "effect": "deny" }
]

// OpenCode 1
"permission": { "skill": { "review-aloud": "deny" } }

A skill turned off by a rule in another file, or by a pattern such as *, has to be turned on where that rule is: the tab names the rule and the file.

When a change applies

The tab says when a switch applies, and every change is noted in Activity ("Turned the MCP server github off"). When a change waits for a running agent to restart, the tab says so, with Restart now: that starts the agent's session again, and the conversation continues where it was. Claude Code's skills need it, and so does every change for OpenCode; Codex never does. A change made while the agent isn't running applies when it starts.

MCP servers that are well known and maintained, and skills: five of Wireface's own, made for a voice and a face, and three from Anthropic. Each is a card in its sub-tab's Recommended view, with who makes it and its licence, what it does, and an About link. All shows the ones not installed yet under what's installed.

Needs: what it needs, each checked on this PC: Node.js, uv, Chrome, Git, or a GitHub token. For the token Wireface checks only whether the environment variable is set, never its value. Anything missing is flagged, with a link to get it.
What Install will do, with the exact command or config entry, which you can copy: see What Install does.
Installed once the agent has it, recognised by its name or by the package or address it runs, with Show it to jump to it among what's installed. Playwright shows Built in for Claude Code.

MCP servers

Their versions are pinned, so npx and uvx don't ask the registry every time they start.

Server	What it does	What it needs
Context7 (Upstash, MIT)	Up-to-date documentation and code examples for thousands of libraries, looked up while the agent works	Nothing. A free key from context7.com raises its rate limit.
DeepWiki (Cognition)	Answers questions about any public GitHub repository, and reads its generated documentation	Nothing. Public repositories only.
Microsoft Learn (Microsoft)	Searches and reads Microsoft's documentation and code samples: Windows, .NET, Azure, PowerShell, Office	Nothing
Playwright browser (Microsoft, Apache-2.0)	Drives a browser: opens pages, reads them, clicks, fills in forms and takes screenshots	Node.js and Chrome. Claude Code behind the face has it already (its Browser), so it shows Built in.
Chrome DevTools (Google, Apache-2.0)	Inspects a live Chrome: console messages, network requests, performance traces and screenshots	Node.js 20.19 or later, and Chrome
Memory (MCP reference server)	A small knowledge graph the agent writes to and reads back, to remember people, projects and facts between conversations	Node.js. It's kept in `.mcp-memory\memory.jsonl` in your home folder.
Fetch (MCP reference server, MIT)	Fetches a web page as readable text, for agents without their own (Claude Code has WebFetch)	uv. It can reach addresses on your own network, so use it with care.
GitHub (GitHub, MIT)	Issues, pull requests, code search, releases and Actions	A GitHub personal access token in the `GITHUB_PERSONAL_ACCESS_TOKEN` environment variable. It's read from there, never written into the agent's config.

Skills

Wireface's own come with it. Replies are spoken, so these keep what's hard to hear on screen, in files in the working folder:

Skill	When it's used	What it does
Answer on screen	A reply with commands, code, paths, links, tables or long steps; "show me", "write it down"	Puts the exact part in `answers\TOPIC.md` and opens it, and says the gist out loud
Dictation notes	"Take a note", "add ... to my to-do list", "draft an email saying..."	Tidies what you dictated into `notes\YYYY-MM-DD.md`, `notes\todo.md` or a draft in `notes\drafts\`, and confirms in a sentence
Review aloud	"Review my changes", "is this ready to commit?"	Reviews the code changes, writes the full review to `review-notes.md`, and says the verdict and what matters most. It changes nothing until you say so.
Standup briefing	"My stand-up", "what did I do yesterday?", "where was I?"	About a minute of speech from the git history, work in progress and to-dos: done, next, and blockers
Walk me through	"Walk me through...", "how do I ... in this app?"	Guides you through a task one spoken step at a time, waiting for you between steps, and warns before anything that can't be undone

Anthropic's three, from github.com/anthropics/skills (Apache-2.0), are fetched from there when you install them, not shipped with Wireface:

Web app testing: tests a local web app with Playwright: starts its server, drives the pages, takes screenshots and reads the browser's logs.
MCP builder: guides building an MCP server in Python or TypeScript, from designing its tools to testing and evaluating them.
Skill creator: helps write a new skill ("make a skill for how we do releases"), then test and improve it.

What Install does

Some installs are handed to the agent, and some Wireface does itself:

Agent	MCP servers	Wireface's skills	Anthropic's skills
Claude Code	The agent runs `claude mcp add` (or, for GitHub, `claude plugin install`), for all your projects	Wireface copies them into `~\.claude\skills`	The agent fetches them
Codex	Wireface runs `codex mcp add`	Wireface copies them into `~\.agents\skills`	You do: Copy steps copies them. The agent does if permissions are skipped
OpenCode	The agent adds an entry under `"mcp"` in its global config	Wireface copies them into `~\.config\opencode\skills`	The agent fetches them

When the agent does it, Wireface sends it the request as if you'd typed it, with the exact command or entry and "Don't change anything else". It goes to this face's own agent, even in a room. You can follow it in Activity, and the agent asks you before it runs the command or changes the file, unless you've skipped permissions. Until it's installed (for up to 15 minutes), the card says Asked the agent; click that to open Activity.
When Wireface does it, there's nothing to approve. It copies a skill's folder whole, and won't write over a folder of the same name. For Codex it runs Codex's own codex mcp add, because Codex's sandbox keeps Codex out of its own config.
Anthropic's skills: the agent clones the repository with git (--depth 1) into a temporary folder, copies the skill's folder and its licence file into its skills folder, and deletes the clone, so it needs git. Codex's sandbox keeps it from writing outside the working folder, so for Codex the card has Copy steps instead, for you to follow, unless permissions are skipped.

Claude Code loads a new server or skill when its session restarts, OpenCode when it restarts, and Codex uses it from your next message. When Wireface copies a skill in for Claude Code or OpenCode while it's running, the tab offers Restart now, as it does for a switch.

These are the commands and entries as of this version; the tab always shows the exact one. C:/Users/you stands for your home folder.

Claude Code

claude mcp add --scope user --transport http context7 https://mcp.context7.com/mcp
claude mcp add --scope user --transport http deepwiki https://mcp.deepwiki.com/mcp
claude mcp add --scope user --transport http microsoft-learn https://learn.microsoft.com/api/mcp
claude mcp add --scope user chrome-devtools -- npx -y chrome-devtools-mcp@1.10.1 --no-usage-statistics
claude mcp add --scope user memory -e MEMORY_FILE_PATH=C:/Users/you/.mcp-memory/memory.jsonl -- npx -y @modelcontextprotocol/server-memory@2026.8.31
claude mcp add --scope user fetch -- uvx mcp-server-fetch@2026.8.18
claude plugin install github@claude-plugins-official --scope user

Playwright isn't among them: for Claude Code it shows Built in, because the face's own browser is Playwright's server already.

Codex

codex mcp add context7 --url https://mcp.context7.com/mcp
codex mcp add deepwiki --url https://mcp.deepwiki.com/mcp
codex mcp add microsoft-learn --url https://learn.microsoft.com/api/mcp
codex mcp add playwright -- cmd /c npx -y @playwright/mcp@0.0.83
codex mcp add chrome-devtools -- cmd /c npx -y chrome-devtools-mcp@1.10.1 --no-usage-statistics
codex mcp add memory --env MEMORY_FILE_PATH=C:/Users/you/.mcp-memory/memory.jsonl -- cmd /c npx -y @modelcontextprotocol/server-memory@2026.8.31
codex mcp add fetch -- uvx mcp-server-fetch@2026.8.18
codex mcp add github --url https://api.githubcopilot.com/mcp/ --bearer-token-env-var GITHUB_PERSONAL_ACCESS_TOKEN

OpenCode

The agent adds the entry under "mcp" in the global opencode.json (inside "mcp": {"servers": ...} if the file already uses that), keeping everything else in the file, comments included. Each entry is in a form both OpenCode 1 and 2 read.

"context7": {"type": "remote", "url": "https://mcp.context7.com/mcp", "enabled": true}
"deepwiki": {"type": "remote", "url": "https://mcp.deepwiki.com/mcp", "enabled": true}
"microsoft-learn": {"type": "remote", "url": "https://learn.microsoft.com/api/mcp", "enabled": true}
"playwright": {"type": "local", "command": ["cmd", "/c", "npx", "-y", "@playwright/mcp@0.0.83"], "enabled": true}
"chrome-devtools": {"type": "local", "command": ["cmd", "/c", "npx", "-y", "chrome-devtools-mcp@1.10.1", "--no-usage-statistics"], "enabled": true}
"memory": {"type": "local", "command": ["cmd", "/c", "npx", "-y", "@modelcontextprotocol/server-memory@2026.8.31"], "enabled": true, "environment": {"MEMORY_FILE_PATH": "C:/Users/you/.mcp-memory/memory.jsonl"}}
"fetch": {"type": "local", "command": ["uvx", "mcp-server-fetch@2026.8.18"], "enabled": true}
"github": {"type": "remote", "url": "https://api.githubcopilot.com/mcp/", "enabled": true, "oauth": false, "headers": {"Authorization": "Bearer {env:GITHUB_PERSONAL_ACCESS_TOKEN}"}}

Keys and tokens

Agents' configurations often hold keys. None of them reaches the panel or the activity log:

Environment variables and headers are shown by name only, never their values.
Commands, addresses and error messages have anything that looks like a key, token or password taken out and replaced with **** or [hidden]: --token=..., --api-key ..., KEY=..., Authorization: Bearer ..., passwords in addresses, the values in an address's query, and tokens by their shape (sk-, ghp_, github_pat_, xoxb-, AIza, hf_ and the like).
The values of a server's environment variables and headers, and Wireface's own keys, are taken out wherever they appear.

Of the recommended servers, only GitHub needs a key, and it's read from an environment variable, never written into the agent's config.

Backups

The first time Wireface changes one of the agent's files, it keeps a copy of the file as it was in data\backups, named after the file with a short code for where it was, such as .claude.json-1a2b3c4d.orig. That copy is never replaced, so it's always the file from before Wireface first touched it. data\ is the app's data folder, shared by every face: %LOCALAPPDATA%\Programs\Wireface\data when installed.

Files are written atomically: to a temporary file in the same folder, which then replaces the original, so the agent never reads half a file. Everything Wireface doesn't know about is kept, and so is the file's own layout: a JSON file keeps its indentation and line endings, and in a TOML file only the lines for that one setting change. A file is only written when something in it changes.

What it can't change

Rather than risk a file, Wireface leaves it as it is and says what to change by hand:

An OpenCode config with comments, usually opencode.jsonc: rewriting it would lose them. Change it by hand, or ask the agent to.
A Codex server written as an inline table (mcp_servers.NAME = { ... }) rather than a table of its own: add enabled = false to it by hand.
A Codex change that wouldn't be valid TOML, or would change more than the one setting: nothing is written.
A file that isn't valid JSON or TOML: the tab shows the error. Fix the file, then refresh.

And some things are switched where they come from: Claude Code's plugin skills (with the plugin), skills synced from claude.ai (in claude.ai's settings), servers that come from a Codex or OpenCode plugin, and OpenCode skills turned off by a rule elsewhere. Most of these have a lock instead of a switch: click it to see why. An OpenCode skill turned off elsewhere keeps its switch, and turning it on says where to change it.

The tab knows Claude Code, Codex and OpenCode, the three agents Wireface drives.

The Tools tab#

Finding things#

What's installed#

MCP servers#

How they're checked#

The face's own servers#

Skills#

Turning one off#

Claude Code#

Codex#

OpenCode#

When a change applies#

Recommended#

MCP servers#

Skills#

What Install does#

Claude Code#

Codex#

OpenCode#

Keys and tokens#

Backups#

What it can't change#

The Tools tab

Finding things

What's installed

MCP servers

How they're checked

The face's own servers

Skills

Turning one off

Claude Code

Codex

OpenCode

When a change applies

Recommended

MCP servers

Skills

What Install does

Claude Code

Codex

OpenCode

Keys and tokens

Backups

What it can't change