faezor MCP connector

The faezor MCP connector lets your AI agent work with your faezor account: list your boards, start a new AI board design from a plain-language request, follow the design run, answer the design agent's questions, send it follow-up messages, and fetch renders, check reports, the BOM and the order files. It is a remote MCP server (Streamable HTTP, OAuth sign-in) at https://faezor.ai/mcp and works with Codex, Claude, OpenCode, Muse Code, GitHub Copilot and other MCP clients.

Connected it before 2026-10-13, when the site was pcb.faezor.ai? Your connection keeps working as it is (https://pcb.faezor.ai/mcp still answers); for a new one use https://faezor.ai/mcp.

codex mcp add faezor --url https://faezor.ai/mcp

[mcp_servers.faezor]
url = "https://faezor.ai/mcp"

claude mcp add --transport http faezor https://faezor.ai/mcp

https://faezor.ai/mcp

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "faezor": { "type": "remote", "url": "https://faezor.ai/mcp" }
  }
}

{
  "schema_version": 1,
  "mcpServers": {
    "faezor": {
      "type": "streamable-http",
      "url": "https://faezor.ai/mcp",
      "mode": "optional"
    }
  }
}

copilot mcp add --transport http faezor https://faezor.ai/mcp

{
  "servers": {
    "faezor": { "type": "http", "url": "https://faezor.ai/mcp" }
  }
}

faezor is a beta service: an AI design agent researches parts, draws the schematic, places and routes the board, runs automated checks (electrical rules, design rules, assembly emulation, JLC stock) and builds files you can order at JLCPCB. Designs are checked by automated tools only; review every design before you manufacture it.

Before you start

• A faezor account. Registration is by invitation during the beta. Ask for an invite on the waitlist or write to info@faezor.ai. Your email must be confirmed.
• An MCP client that can add a remote server and sign in with OAuth: Codex, Claude (Claude Code, claude.ai, Claude Desktop and mobile), OpenCode, Muse Code, GitHub Copilot (Copilot CLI, VS Code) or another one.
• No API key: you sign in with your faezor email and password once, in your browser.

Set it up

Every client asks you to sign in once. A faezor page opens in your browser: sign in if you are not signed in yet. The consent page names the app (for example "identified by chatgpt.com" for Codex; apps that register themselves are marked "name given by the app itself, not verified"), shows where your approval is sent and what the app may do. Leave Design ticked to let the app start runs and message the agent, or untick it for read-only access. Select Allow.

Codex

codex mcp add faezor --url https://faezor.ai/mcp

Codex detects that the server needs a sign-in and opens your browser right away. To sign in again later: codex mcp login faezor. The Codex CLI, the IDE extension and the Codex app share this setting (~/.codex/config.toml, table [mcp_servers.faezor] with url = "https://faezor.ai/mcp").

Claude Code

claude mcp add --transport http faezor https://faezor.ai/mcp

Then run /mcp in Claude Code, pick faezor and sign in. The server is added for the current project; add --scope user to have it in all your projects. If you signed in to Claude Code with your claude.ai account, a connector you added on claude.ai is available in Claude Code too.

claude.ai, Claude Desktop and Claude mobile

1. Open Customize → Connectors and select Add custom connector.
2. Paste https://faezor.ai/mcp as the URL and select Add. If the dialog asks about authentication, keep the defaults (sign in; Claude's published identity): no client ID or secret is needed.
3. Select Connect and sign in on the faezor page that opens.
4. Back in Claude, the connector shows as Connected. Turn it on in a chat from the + menu → Connectors.

The connector then works on claude.ai, in Claude Desktop and in Claude mobile. On the Free plan you can add one custom connector. On Team and Enterprise plans an Owner adds it under Organization settings → Connectors (Add → Custom → Web), and members select Connect under Customize → Connectors.

OpenCode

Add it to opencode.json in your project, or to ~/.config/opencode/opencode.json for all projects:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "faezor": {
      "type": "remote",
      "url": "https://faezor.ai/mcp"
    }
  }
}

Then run opencode mcp auth faezor, or sign in when OpenCode asks on first use. opencode mcp list shows the server as connected.

Muse Code

Add it to ~/.config/muse/settings.json. If the file already exists, add the faezor entry under mcpServers and keep everything else:

{
  "schema_version": 1,
  "mcpServers": {
    "faezor": {
      "type": "streamable-http",
      "url": "https://faezor.ai/mcp",
      "mode": "optional"
    }
  }
}

Then run muse mcp login faezor (--headless on a machine without a browser: it prints the page to open and asks for the address you end up on).

GitHub Copilot CLI

copilot mcp add --transport http faezor https://faezor.ai/mcp

Copilot CLI saves it in ~/.copilot/mcp-config.json and opens your browser to sign in when the next session starts.

VS Code (GitHub Copilot)

Add it to .vscode/mcp.json in your workspace, or run MCP: Open User Configuration for all workspaces:

{
  "servers": {
    "faezor": {
      "type": "http",
      "url": "https://faezor.ai/mcp"
    }
  }
}

Start the server (the Start action above its entry, or the MCP server list) and allow VS Code to sign in when it asks; the faezor page opens in your browser. Remote windows (SSH, WSL, containers, Codespaces) and vscode.dev sign in through vscode.dev's redirect page, which this server accepts too.

Other MCP clients

Any client that adds remote MCP servers over Streamable HTTP and signs in with OAuth 2.1 works: it identifies itself with a client ID metadata document (an https client_id) or registers itself (dynamic client registration), uses PKCE and gets the sign-in back on a loopback address (http://127.0.0.1 or http://localhost, any port). Hosted callback pages are accepted for Claude and VS Code only. The client finds everything else from https://faezor.ai/.well-known/oauth-protected-resource/mcp.

What you can ask

• "Show my faezor boards and which ones are ready to order."
• "Design a USB-C powered board with an ESP32-C3, a BME280 sensor and a status LED, 40 x 25 mm, two layers."
• "How is the run on my radar board going? What did the agent say last?"
• "Show me the top render and the verification results of the CAN FD adapter."
• "Read the JLC BOM of that board and list the parts that are not basic parts."
• "Tell the agent to move the USB connector to the short edge." / "Stop the run on that board."
• "What does the agent want to know about my power board? Answer with its defaults, but 3 A output."

Tools

Read tools run without changing anything. Most agents ask for your confirmation before the tools that start runs or change a design, depending on their settings.

list_boards (read-only)

Your boards - your own and the ones shared with your organisations - most recently active first: id, title, summary, status (idle, queued, running, done, failed, cancelled), the design stage reached (Requirements, Schematic, Placement, Routing, Verification, Order files), the verification result and whether order files exist. Pages of up to 50 (limit, cursor). Also returns how many design runs you have left today, whether the agent waits for your answers to its questions (waiting_for_answers) or for documents from you (waiting_for_documents), each board's "ASIL D parts" setting (asil_d_parts), its owner (owner), the organisations it is shared with (shared_with: id, name and access, view or edit) and what you may do with it (your_access, below), and your organisations with your role in each (organisations).

get_board (read-only)

One board in detail (board_id): status and stage, the queued or running run (with its queue position) or the last run and its error, every verification check with its result, the number of files, the latest message of the design agent and your latest message, the share link if you turned one on (with whether its page shows your request and sketches, your setting in the board's Share dialog), the agent's open questions (open_questions, or null) and its open document request (open_document_request, or null), and its "ASIL D parts" setting (asil_d_parts; create_board, update_board_settings). Across the products: each one's state (products: pcb, cad, firmware, sim and hub, each with a state, a short label and a detail), the case and the firmware in detail (case, firmware), faezor's latest answer in the central chat (latest_faezor_reply) and a plan of faezor's still waiting for Start (open_plan, or null; decide_board_plan).

The agent asks for decisions it cannot make itself as a question set: 1 to 8 questions, each with an id, the question, an optional detail, a type (single choice, multiple choice or free text), the options (label and description), whether an own answer is allowed (allow_other), the option it recommendeds and whether an answer is required; plus its default_summary, what it would choose for the whole set. In the web app the set is a form in the chat; here you answer it with send_board_message.

The agent designs only with parts whose datasheet it has. When it cannot get one itself (or a hardware design guide the layout depends on), it asks for it: needed lists each missing document (id, the part's refs, mpn, the kind: datasheet, hardware design guide, reference manual, app note, safety manual or FMEDA report, why it is needed and what the agent tried), found the documents it did download, each with a download_url for a browser signed in to faezor PCB and what is wrong with it (issue). Files can only be uploaded on the website (the chat's document window); here you can let the agent continue with what it found (send_board_message with documents).

list_board_files (read-only)

The files you can fetch (board_id): renders (top, bottom, isometric), board view and loop/decoupling pictures, the schematic PDF, the 3D model (GLB), Gerbers and drill files for JLCPCB, the JLC BOM and pick-and-place file, check reports, the board's README and design notes, and the KiCad project. Each has a size, a type and a download link that works in a browser signed in to faezor.

get_board_file (read-only)

One file (board_id, path from list_board_files). Pictures come back as an image, scaled down to fit a tool result (about 100 KB). Text files (CSV, Markdown, reports, KiCad files) come back as text in pages: max_chars (default 20,000, at most 100,000) from offset; the answer says where the next page starts. ZIP, PDF and GLB files come back as a download link.

get_board_timeline (read-only)

The board's chat and run history (board_id): your requests, the agent's messages, progress notes and plan, run status and stage changes, errors, restores of an old version on the site (version_restored: restored_version, new_version), changes of the board's "ASIL D parts" setting (setting_changed: setting, value, via), and for messages sent while a run was going (during_run, message_id) their delivery to the agent (steering_delivery). The agent's question sets come as agent_questions events with their current state: open, answered, skipped (a message was sent instead) or replaced (the agent asked again); answers come as your user_message with answers (per question the chosen options, the other text or the typed text) and a readable text. Document requests come as agent_document_request events with their state, replies as your user_message with documents (continue_with_found, or the uploaded files with the needed document each is for). Without paging arguments it returns the newest 20 events (limit up to 100); pass before_seq for older events or after_seq for newer ones. include_steps adds the agent's individual tool steps.

create_board (writes: starts a design run)

Creates a board from your request (request, 15 to 8,000 characters: what the board does, interfaces, power, size or layer limits, preferred parts) and queues a design run. A run usually takes 10 to 60 minutes. The answer has the new board's id; follow it with get_board or get_board_timeline. org_id (an id from list_boards' organisations) shares the new board - yours - with that organisation for editing; without it the board is shared with nobody.

asil_d_parts: true switches on "ASIL D parts" for the board (off by default): the agent only uses parts suited for an ISO 26262 ASIL D design - a safety microcontroller (lockstep cores), a safety power supply with independent monitoring and watchdog, automotive-qualified (AEC-Q) parts - quotes the vendors' statements in the part specs, and the verification checks them. The board is a basis for certification, not certified: hazard analysis, FMEDA, safety software and the ISO 26262 process remain your system-level work.

send_board_message (writes: the agent may change the design)

A message for the board's agent (board_id, message): a change request, an answer to the agent's question, more requirements. product picks who gets it, as the project's pages do on the website:

• "faezor": the project's central chat. faezor reads the message, answers questions about the project's state itself and routes the rest to the products it touches - several at once, a simulation test run, a simulation model for one part, a fleet release. The answer has its reply and its routes (per product the action, a brief and what happened: started, sent to a running agent, waiting for another run, link, refused, unavailable, with the run_id of a run it started). A big job, one that touches several products or a model build comes back as a plan (plan_id) that starts only with decide_board_plan.
• "pcb" (the default): the circuit board's design agent.
• "cad": the case's agent (build123d code in case/, fit checks, STEP / STL / 3MF).
• "firmware": the firmware's agent (firmware/, built and tested in the simulator).
• "sim": the Simulation's world agent - the project's own copy of the simulated World, a Godot project in sim/world/ it may change as it sees fit.

answers and documents (below) go to the PCB's agent only. While a run is queued or going on the board, the message goes to the running agent between two of its steps (steering: no new run, no daily run used); the answer has the message's message_id, and the timeline shows a steering_delivery event when the agent has it (seen), or when it moves to the board's next run because the run ended first (followup). Without an active run the message starts a new design run on the board. Every version of a design stays in the board's version history.

To answer the agent's open questions, pass answers: answers.answers maps question ids to an option's label, a list of labels for a multiple-choice question, or your own words (they become that question's "Other" answer, or the answer to a text question); use_defaults: true accepts the agent's defaults for every question you leave out. message is optional then and goes along as a note. For example:

{ "board_id": "...", "answers": { "use_defaults": true, "answers": { "current": "3 A", "connectors": ["USB-C"] } } }

The agent gets the answers by question id; the chat shows them as your message. A required question without an answer is refused unless use_defaults is set. A message without answers while questions are open closes them unanswered (skipped): the agent reads the message as your reply.

To an open document request, pass documents: { "continue_with_found": true }: the agent continues with the documents it found, and for a part with nothing usable it proposes a replacement it can get a datasheet for (or asks again). A plain message closes the request too.

update_board_settings (writes: no run)

Changes a board's settings (board_id): asil_d_parts true or false (see create_board). It starts no design run: the run already queued starts with the new setting (applies_from: "queued_run"), otherwise the next run does ("next_run"), and that run re-checks the board's parts against it; a run going now keeps the setting it started with. changed is false when the board already had that setting.

decide_board_plan (writes: starts runs)

Starts (start: true) or dismisses (start: false) a plan faezor proposed in the central chat (board_id, plan_id from send_board_message or get_board's open_plan). Starting it starts every product's run in it, each counting against the daily design runs; a run that has to wait for another one starts by itself after it. A plan is answered once; plans expire after a week. The timeline shows the central chat as faezor_user_message, faezor_reply and faezor_plan events (with the plan's state), and the site's own checks after a case, firmware or world run as product_check.

stop_board_run (writes)

Stops the board's queued or running run (board_id). What the agent has saved stays on the board; the step in progress is cut off, and a message the agent has not received yet is not delivered (its steering_delivery event says dropped).

Not available through the connector: deleting boards or your account, share links, passwords, the browser PCB editor.

Organisations and sharing

Every board belongs to a person, its owner. The owner shares it with organisations on the website ("Can view" or "Can edit", like sharing in Microsoft 365); the connector follows the same rules:

| your_access | reads (get_board, files, timeline) | messages, runs, Stop, plans | update_board_settings | | ------------- | ---------------------------------- | --------------------------- | --------------------- | | owner | yes | yes | yes | | edit | yes | yes | - | | view | yes | - | - |

edit: the board is shared with your organisation for editing and you are its member, admin or owner. view: it is shared with your organisation for viewing, or for editing and you are a viewer there. On the website, anyone with access can also clone a board into their own projects. A tool your role does not allow says so. Whatever you start - a run, a new board - counts against your own daily runs and designs, also on someone else's board.

Limits

• Design runs per day per account: 5 during the beta (shown as runs_left_today). One run per account at a time; runs wait in a queue when the servers are busy. Messages to a running agent do not start a new run (up to 5 not yet seen by the agent and 50 per run).
• A run stops after 3 hours; send a message to continue it.
• Tool results stay small: images are scaled to about 100 KB, text comes in pages of at most 100,000 characters, timelines in pages of at most 100 events.
• Requests: up to 1,200 MCP requests per hour per account.

Your data and access

• The connector uses OAuth 2.1 with PKCE. Your agent never sees your password; it gets an access token that is valid for one hour and a refresh token that is replaced on every use. Both are stored on our server as hashes only.
• You choose read-only or read-and-design access on the consent page. Account → Connected apps lists every connected app with its access and last use; Disconnect ends its access at once. Changing your password disconnects all apps.
• The connector only reaches the boards of the account that approved it (its personal boards and, by its role, its organisations' boards). What your agent sends to the connector (a board request, a message to the agent) becomes part of that board, like a message typed on the site. We do not receive or store your conversations with your agent.
• Board texts and files are written by you and by the design agent; the connector returns them as data.
• Details: privacy policy, terms.

Troubleshooting

• "Couldn't connect" or the sign-in page says the request does not work: start connecting again from your agent (Claude: Connect; Codex: codex mcp login faezor; OpenCode: opencode mcp auth faezor; Muse Code: muse mcp login faezor); a sign-in request is valid for 15 minutes and works once.
• A tool says a board was not found: the board belongs to another account (or an organisation you are not in), or it was deleted. list_boards shows the ids of your boards.
• "This account may only view this board": its owner can share it with your organisation for editing.
• "You've used today's design runs": the daily limit resets at midnight UTC.
• "The agent is still working on ...": one run per account at a time. Wait, or stop the run with stop_board_run.
• Design tools ask you to reconnect: you allowed read-only access. Sign in again from your agent and leave Design ticked.
• Remove the connector: remove it in your agent (Claude: Customize → Connectors; codex mcp remove faezor, claude mcp remove faezor, copilot mcp remove faezor; OpenCode, Muse Code, VS Code: delete its entry) and disconnect it under Account → Connected apps.

Support

Write to info@faezor.ai with the board id, the time, your agent and what you asked it. We answer on working days.