Model Context Protocol

Your company brain,
wired into every agent

A hosted remote MCP server that gives Claude Code, Cursor, Codex, and any MCP client read and write access to your Falconer knowledge base.

Get started Read the docs

Connect in seconds

Point your client at Falconer

OAuth runs in your browser on first connect, so there are no API keys to manage.

Add the remote server
```
claude mcp add --transport http --scope user \
  --client-id falconer-claude-code --callback-port 49152 \
  "falconer" "https://falconer.com/api/mcp"
```
bash
Open Claude Code and authorize
```
/mcp
```
text

Add to Claude.ai

Add it manually as a custom connector
```
https://falconer.com/api/mcp
```
text

Name it Falconer and leave the OAuth Client ID and Secret empty, then connect and sign in when Claude asks.

Add to Cursor Open Cursor Agent

Or add it manually to ~/.cursor/mcp.json

{
  "mcpServers": {
    "falconer": {
      "type": "http",
      "url": "https://falconer.com/api/mcp"
    }
  }
}

json

For Cursor Agent, use this as the server URL
```
https://falconer.com/api/mcp
```
text

Name it Falconer, then click Login to start the Falconer OAuth flow.

Add the remote server

codex mcp add falconer --url "https://falconer.com/api/mcp" \
  --oauth-client-id falconer-codex-cli \
  --oauth-resource "https://falconer.com/api/mcp"

bash

Verify it’s listed
```
codex mcp list
```
bash

Point your client at the remote endpoint
```
https://falconer.com/api/mcp
```
text

Any tool that supports remote HTTP MCP works. OAuth runs in your browser on first connect, so there are no API keys to manage.

What you can do

Workflows your plain coding agent can’t do

Iterate on plans via comments

Leave comments on a plan or spec in Falconer, then tell your agent to read the threads, make each change, and resolve the comments. You review, the agent does the work.

Implement from a spec

Paste a Falconer doc link into your agent. It pulls the full spec and starts building, with no copy-pasting and no context gaps.

Organize your agents’ docs

Have your coding agents write their implementation notes, plans, and design specs straight into Falconer. With the folder and nav tools, they file each one in the right place and keep it organized as the work evolves.

Keep docs in sync with code

When a config or service name changes in the codebase, ask your agent to update the matching Falconer doc so the two never drift.

Onboard onto new code

Point a fresh agent at a subsystem and let it read the architecture and design docs before it writes a single line.

Ask your knowledge base

From Cursor or Claude Code, ask “what’s our auth pattern?” and get an answer grounded in your real docs, not the model’s training data.

Read and write

A knowledge base that compounds

Most MCP integrations are read-only, so the output disappears into a chat window and your docs stay stale. Falconer reads and writes: every spec, runbook, and postmortem an agent touches lands back in your knowledge base, versioned and searchable for whoever needs it next.

Get started Request demo

Read-only MCP

Agent reads context

Output lives in a chat window

Knowledge base goes stale

Falconer MCP

Agent reads and writes back

Docs stay in sync with the code

Every session improves the base

Your company brain, wired into every agent