You can prepare a 1PC connection in Meta Muse Code using remote MCP and OAuth, then verify it with a small product task. Start through Product Owner, read the current product state and save only the result you asked for. A fresh session should retrieve that result from 1PC.
This guide follows version-specific Muse Code documentation reviewed on 4 October 2026. It is a setup procedure to verify in your installed client, not a report of a completed live connection.
Choose Muse Code rather than assuming every Muse surface works alike
Muse Code is the setup surface covered here. Meta's Muse connector guidelines describe platform submission and review; they do not establish a personal custom-MCP setting in the consumer Muse app. This guide does not claim that 1PC is listed as an approved Muse connector.
For 1PC, the client must handle tool discovery, authentication and the calls required by your task. A model's ability to reason about a product is separate from the application's ability to connect to its workspace. The MCP overview explains that distinction.
Sign in to 1PC, complete your founder profile and choose a product you can access. Your Muse account or model credential does not authenticate you to 1PC. If the product already exists, reuse it rather than creating another record for this client.
Configure remote MCP and authorize 1PC
The Muse Code MCP reference documents 1.3.0. Its canonical settings use mcpServers and type: "streamable-http". Compare your installed version first. In your user settings at ~/.config/muse/settings.json (or the configured XDG equivalent), merge this entry while preserving other settings:
{
"schema_version": 1,
"mcpServers": {
"onepc": {
"type": "streamable-http",
"url": "https://use1pc.com/mcp"
}
}
}
Use user settings for this OAuth path; a project-only server cannot use the documented login command. Do not mix canonical and legacy keys. This example deliberately contains no token.
muse mcp login onepc --scope knowledge:read --scope knowledge:write
Inspect the browser consent before authorizing. 1PC requires knowledge:read for discovery and reads; saving also needs knowledge:write. New OAuth connections grant full User access, including owner decisions. Use read-only tool calls for an initial connection check.
Start a new Muse Code process after changing configuration and inspect /mcp. Its connection and tool inventory are the first checks. The SDK warns that HTTP header values are literal, so an environment placeholder in an Authorization header is not a working secret reference.
1PC supports dynamic client registration, PKCE and remote Streamable HTTP at the endpoint shown above. Registration alone grants no account access. If OAuth cannot finish, use the authentication reference to check registration, the exact MCP resource and callback rules. Do not invent a client ID or treat a website login cookie as an MCP credential.
Enter Product Owner before starting a domain task
A server connection exposes tools; it does not install the plugin's native Product Owner skill. In an MCP-only Muse Code setup, make the entry explicit:
Use the connected 1PC tools. Load get_skill_instructions
with skill_id "product-owner" and phase "entry".
Read get_workspace_context and paginate list_product_skills.
List my products so I can select the existing product.
Load get_product_context with that product_id.
Explain saved state, current access and unfinished work before starting.
Keep this first check read-only; do not save or run another workflow.
Use the tool schemas currently returned by the server, including the selected product ID where required. This bootstrap is public setup guidance. Keep the entry available in the host's supported instructions and reload current backend guidance in a fresh session.
Product Owner matches your request and saved state to the available catalog. For a domain task, the assistant loads the selected skill with get_skill_instructions, phase work, and follows its separate requirements for inputs, evidence, outputs and checks. The returned Markdown guides execution; it is not automatically installed as a native Muse skill.
State and routing entry are available on Free. Saved Product Owner reports, the full catalog and private skill execution require an eligible paid 1PC plan. Check current plans; a Muse subscription does not grant 1PC paid access.
A founder task: review a pricing hypothesis without inventing evidence
Consider the fictional Follow-up Board, a tool for freelance designers tracking unanswered proposals. Its founder has a proposed monthly offer but no verified willingness-to-pay result. The useful task is to identify what supports the offer and what must be tested before changing pricing.
For the selected Follow-up Board product, start through Product Owner.
Review the saved pricing hypothesis using the available pricing workflow.
Separate accepted facts, proposed assumptions and missing evidence.
Suggest one bounded test that would help decide whether to keep the offer.
Preserve the current records. Save this review as scoped Knowledge with
an explicit department, reference role and stable key. Prepare and self-review
the update, commit its exact revision, then read the receipt back. Do not accept a pricing change,
publish a price or contact customers.
The workflow's access and requirements govern the next step. If pricing guidance is unavailable on your plan, explain that boundary. If there is no saved hypothesis, collect the missing offer details before pretending to review them.
| Review item | What belongs in the result |
|---|---|
| Customer and problem | The saved target customer and pain point, with their source and remaining uncertainty. |
| Offer hypothesis | The proposed price, package and reason for the proposal; a hypothesis remains a hypothesis. |
| Evidence gap | Which claims need customer evidence, cost information or an actual purchase test. |
| Next test | One feasible test, the response to observe and the decision it would inform. |
The table is a review framework, not customer research. A saved note does not establish willingness to pay. If you later accept a pricing decision, record the choice, rationale and consequences separately; the product decision-log guide explains that distinction.
Verify that the next session retrieves the saved result
Record the installed Muse Code version and the date of the check. Tool discovery, a convincing answer and a save request are different milestones. Verify the actual outcome:
- Read: the assistant retrieves your real founder context and the selected product's current records.
- Work: it loads available requirements, identifies missing information and produces the authorized review.
- Save: it reports the server's successful save receipt for the required destination.
- Read back: it checks the saved content and revision, resolving any conflict before continuing.
- Start fresh: a new session enters Product Owner, selects the same product and reads that review from its saved file.
When a write response is uncertain, read the destination before retrying. It may already contain the result. If you requested status only, leave that check read-only rather than turning it into a saved plan.
The cross-client continuity guide covers the same check across hosts. 1PC carries submitted product records; it does not automatically archive the full Muse conversation or synchronize every local repository file.
Find the connection gap before trusting the result
- No 1PC tools: inspect configuration and the MCP inventory. Keep one schema for the installed version and the exact
/mcpendpoint. - Authorization fails: inspect the client error and 1PC consent. A successful browser login alone is not a completed MCP grant.
- Reads work but saves fail: check write scope, product membership and 1PC entitlements.
- A private skill is absent: paginate the catalog. Only a published active skill in the caller's workspace is executable; a draft is not.
- A fresh session cannot find the review: confirm the account, selected product, destination and successful save receipt.
Use the MCP error reference for server-side recovery. Check read-only consent and revocation before relying on the integration. Keep tokens and private product content out of public screenshots or support examples.
Once the connection is established, a published private skill can supply your own review method while preserving the same saved-state loop. Start with one bounded outcome and verify it before expanding the task.
Check the connection contract while you set up Muse Code.
Use the 1PC quickstart to verify authentication, discover current tools and confirm a scoped save before relying on continuity.
Open the 1PC MCP quickstart ↗