Connect to CuriousCirkits

Connect your agent, verify access, then add the workflow skills you need.

Connect MCP · Verify connection · Add skills · Set up notifications

Helping someone get started? Follow the agent instructions.

https://mcp.curiouscirkits.com/api/v2/mcp

Connect your agent

ChatGPT

1. Open ChatGPT on the web.

2. In Settings → Security and login, enable Developer mode.

3. Open Plugins and select the plus button to create a developer-mode app.

4. Enter the following connection details:

   Copy

   Name: CuriousCirkits
   MCP server URL: https://mcp.curiouscirkits.com/api/v2/mcp
   Authentication: OAuth

5. Use dynamic client registration when selecting the OAuth registration method. CuriousCirkits supports public clients without a client secret.

6. Complete CuriousCirkits sign-in and review the requested permissions.

7. Finish creating the app.

8. Open a conversation, choose Developer mode, and select CuriousCirkits.

9. Run the connection check.

Availability and settings depend on your account and workspace permissions.

Grok

1. Open Grok's custom MCP connector settings.

2. Add a connection named CuriousCirkits.

3. Enter:

   Copy

   https://mcp.curiouscirkits.com/api/v2/mcp

4. Save the connection.

5. Open the saved connection and select Connect.

6. On the CuriousCirkits OAuth page, sign in and review the requested permissions.

7. Approve access and return to Grok.

8. Run the connection check.

Saving the URL alone does not authorize the connection.

Perplexity

1. Open Account settings → Connectors.

2. Add a custom connector and choose Remote.

3. Enter the following connection details:

   Copy

   Name: CuriousCirkits
   MCP server URL: https://mcp.curiouscirkits.com/api/v2/mcp
   Authentication: OAuth
   Transport: Streamable HTTP

4. Save the connector.

5. Open the saved connector to start authorization.

6. On the CuriousCirkits OAuth page, sign in and review the requested permissions.

7. Approve access and return to Perplexity.

8. Enable the connector for your request and run the connection check.

Custom connectors must be available for your account and permitted by your organization.

Muse

Ask Muse: “Please connect curiouscirkits.com.” If your version offers automatic setup, try it first. Otherwise, follow these steps.

Manual app setup was reported working September 9, 2026. Current app navigation and automatic setup remain unverified.

1. Register the client

Open Register a client, choose Muse, and match the callback to your connector. Register, copy the client ID, then return to Step 2. The Muse preset uses:

https://agent.meta.ai/api/hatch/oauth/callback

curl --fail-with-body --request POST \
  'https://developers.curiouscirkits.com/oauth/register' \
  --header 'Content-Type: application/json' \
  --data '{
    "client_name": "Muse — CuriousCirkits",
    "redirect_uris": [
      "https://agent.meta.ai/api/hatch/oauth/callback"
    ],
    "grant_types": [
      "authorization_code",
      "refresh_token"
    ],
    "response_types": ["code"],
    "token_endpoint_auth_method": "none"
  }'

2. Configure Muse

Use the current endpoint values from authorization-server metadata if they change.

{
  "mcp_server_url": "https://mcp.curiouscirkits.com/api/v2/mcp",
  "authorization_url": "https://developers.curiouscirkits.com/oauth/authorize",
  "token_url": "https://developers.curiouscirkits.com/oauth/token",
  "client_id": "<from step 1>",
  "client_auth": "none",
  "pkce": "S256",
  "oauth_resource": "https://mcp.curiouscirkits.com/api/v2/mcp",
  "initial_scope": "goals:read"
}

3. Connect and authorize

1. Save the connector configuration.
2. Start the connection using the client ID saved in the manual configuration.
3. Complete CuriousCirkits sign-in.
4. Review and approve the requested permissions.
5. Return to Muse and run the connection check.

Muse must handle the PKCE challenge, verifier, and token storage. Manual registration does not replace PKCE.

To enable writes later, request the required write scopes and authorize again. A new client registration is not inherently required; a new consent grant is.

Register a client

Choose Muse or enter another client's name and exact callback URL. Copy the returned ID into your connector. Registration creates no account access; sign-in and consent come next.

Reading Markdown? Open the registration form.

Verify the connection

After connecting any agent, ask:

Use CuriousCirkits to list my goals. Read only—do not create or update anything.

A successful response, including an empty list, confirms access to your records.

Only report “Connected” after this read succeeds. A saved connector or tool list alone does not confirm access.

Add workflow skills

MCP connects your assistant to your records. Skills provide workflow guidance for using those capabilities. Skills are optional, but recommended for the work you want to do.

1. Open Skills, also available as Markdown.
2. Choose the relevant published user skills. The current index links to their instructions and the official download.
3. If your assistant supports skill installation, use its supported upload or installation flow. Review the skills before enabling them. Follow the skill setup instructions.
4. Confirm that the skill appears in your assistant's installed or enabled skills. If it only read the Markdown, report that as guidance loaded for this conversation, not installed.

MCP authorization does not prove skills are installed, and installing skills does not authorize MCP. Report both results separately. If your assistant cannot install skills, it may still read the published instructions and use the connected MCP.

Set up proactive notifications

Get new CuriousCirkits updates without asking each time. After the connection check succeeds, your assistant should bring up notification setup and help you choose a schedule.

The schedule runs in your assistant and checks CuriousCirkits through the connected MCP. get_notification_setup provides setup guidance; get_pending_notifications reads updates. Acknowledge delivered notifications only after they have been shown to you.

Help me set up scheduled CuriousCirkits notifications. Check whether your scheduler can use my CuriousCirkits connection, ask how often I want updates, and create the schedule once I choose. Tell me about new notifications. Confirm only after the schedule is created successfully.

Your assistant should:

1. Bring up notification setup as part of connecting, even if you skip the capabilities walkthrough. Read the setup guidance and verify scheduled MCP access is supported.
2. Reuse known timing preferences or ask for your preferred frequency and time zone. Check for an existing schedule before creating another.
3. Create or update the schedule once you agree to its timing. Report its frequency and how to change or stop it after creation succeeds. Respect a decision to skip and do not repeatedly prompt.

If scheduled MCP access is unavailable, explain that limitation and offer to check notifications when you return. A reminder to check is different from a task that actually reads CuriousCirkits notifications.

Connecting MCP or installing skills does not enable a schedule automatically. Your assistant should guide this setup without waiting for a separate request. You control whether to enable alerts and when they run. The assistant owns the schedule; CuriousCirkits keeps your updates in Review & alerts.

Notifications do not approve or apply suggestions. Review any proposed changes separately.

Connection problems

Muse: Invalid authorization request

For the app's manual setup, leave automatic registration unset and use the client ID returned by CuriousCirkits. The sandbox credential helper has different settings; see Muse sandbox credentials.

Keep PKCE S256 enabled. Also check that the callback URL matches the registered value exactly. The error alone does not establish which field failed.

Check the connection you are using: app authorization does not authorize a sandbox or CLI. Reconnecting does not inherently require a new client registration.

Contact support with the agent name, approximate time, and error message. Do not include access tokens, refresh tokens, authorization codes, or PKCE verifiers.

CuriousCirkits authorization

Every agent connects to the same MCP endpoint and uses the same CuriousCirkits authorization service.

There are three parts to authorization:

1. Client registration identifies the application connecting to CuriousCirkits.
2. Sign-in identifies your CuriousCirkits account.
3. Consent grants the application the permissions shown on the authorization page.

The client then receives tokens that allow it to make authorized MCP requests.

Saving the MCP URL configures a connection. Completing sign-in and consent authorizes access.

Permissions

Permissions determine what the connected agent can read or change.

For a first connection check, request goals:read where the client allows scope selection. Add write permissions when you need them.

Review the permissions shown during consent. Asking an agent to “read only” does not reduce the permissions already granted to its connection.

To add permissions later, update the connection and complete authorization again.

{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}

{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"review_goals","arguments":{"limit":10}}}