MCP Skills Resources

What are Bridge Town skills?

Bridge Town ships a set of bundled skill templates: curated, Jinja2-templated Markdown prompts that guide an AI agent through common FP&A workflows. Each skill is returned as a raw template — Jinja2 placeholders such as {{ tenant_name }} remain literal in the response — so the caller can render the template with the appropriate context before attaching it to an agent conversation.

Skills are MCP resources, not tools. An agent reads a skill template by fetching a resource URI — such as template://{name} for a scaffold template — rather than calling a tool.

MCP resource URIs

Resource URI	Returns
`skills://`	JSON catalog of all bundled skills (name, description, category, required context fields)
`skill://{name}`	Full metadata and raw template body for one skill, by name

Read the catalog

Read resource: skills://

Response shape:

{
  "count": 16,
  "skills": [
    {
      "name": "create_revenue_model",
      "description": "Build a bottom-up or top-down revenue forecasting model in Python.",
      "required_context": ["tenant_name", "script_name", "model_name"]
    }
  ]
}

Read a single skill

Read resource: skill://create_revenue_model

Response shape:

{
  "name": "create_revenue_model",
  "description": "Build a bottom-up or top-down revenue forecasting model in Python.",
  "category": "model-authoring",
  "required_context": ["tenant_name", "script_name", "model_name"],
  "template": "You are building a **revenue forecasting model** for {{ tenant_name }}.\n\n- Script identifier: `{{ script_name }}`\n- Model: `{{ model_name }}`\n\n..."
}

Note: skill://{name} also supports MCP completion/complete — clients that speak the MCP completion protocol receive autocomplete suggestions for the {name} parameter as you type.

How to reach skills via search_tools

When you search for a skill-related task, search_tools returns both regular tool matches and a skill_matches array. Each skill match includes the canonical resource_uri, a related_tools list, and a next_action hint:

{
  "items": [],
  "skill_matches": [
    {
      "name": "bridge-town-gsheet-formatting",
      "title": "Bridge Town Gsheet Formatting",
      "description": "Use whenever a Bridge Town agent is about to write model output to Google Sheets.",
      "resource_uri": "skill://bridge-town-gsheet-formatting",
      "related_tools": ["write_gsheet", "format_gsheet", "modify_gsheet_structure", "ingest_data_source"],
      "next_action": "get_skill(name='bridge-town-gsheet-formatting', include_template=true)"
    }
  ]
}

Passing domain="skills" returns skill_matches from the registry directly, with items: [] (no regular tool results). If no skills match, the response includes reason="no_skill_matches" with a recovery hint:

{
  "items": [],
  "total_count": 0,
  "truncated": false,
  "reason": "no_skill_matches",
  "recovery": {
    "message": "No skills matched this query.",
    "next_step": "Read skills:// to browse all available skills."
  }
}

See the search_tools reference for details.

`get_skill` — compatibility bridge for hosts that can’t read resources

skills:// and skill://{name} are the canonical way to access skills, and Bridge Town skills are plain MCP resources — not a host-native skill system. A host that doesn’t natively integrate with them (OpenCode, custom agent frameworks, etc.) is not missing anything special; it just needs to call an MCP tool instead of reading a resource.

The deciding question is capability, not brand: can this MCP host autonomously read resources mid-conversation?

Yes (Claude Code, Claude Desktop, most full MCP SDK clients, and other hosts with working resources/read support): read skill://{name} directly. Prefer this path — it is one round trip and needs no extra tool call.
No (Claude.ai’s OAuth connector, the Claude API’s Messages API connector, or any other host — including OpenCode-style clients — that exposes tools but not resource reads): use get_skill as the compatibility bridge. It reads from the same canonical registry as skill://{name} — there is no separate skill store, and no OpenCode-specific integration — it is one more MCP tool call available to any host.

When to use get_skill:

Host type	Recommended path
Claude.ai (OAuth connector)	`search_tools` → `get_skill(include_template=true)`
Claude Code / Claude Desktop	Read `skill://{name}` directly
Claude API (Messages API connector)	`get_skill` (resources not available via API connector)
Custom full MCP client	Read `skill://{name}` directly
Other MCP hosts without resource-read support (e.g. OpenCode-style tool-only clients)	`search_tools` → `get_skill(include_template=true)`

If you are unsure whether your host supports resource reads, try skill://{name} once — if it comes back empty or unsupported, fall back to get_skill for the rest of the session rather than retrying the resource read.

Compact-metadata-first behavior:

get_skill returns compact metadata by default (include_template=false): name, description, category, resource_uri, required_context, and related_tools. Request include_template=true only when you are about to use the template — this avoids loading large Jinja2 bodies unnecessarily.

// Compact lookup (default)
{"name": "get_skill", "arguments": {"name": "bridge-town-gsheet-formatting"}}

// Full template retrieval — use when you are ready to render and apply the skill
{"name": "get_skill", "arguments": {"name": "bridge-town-gsheet-formatting", "include_template": true}}

See the get_skill reference for the full parameter schema and response shape.

Canonical bundled skill catalog

These 19 skills ship with every Bridge Town deployment. They are the stable, registry-ready surface of the skills:// resource. The authoritative list at runtime is always skills:// itself — the table below documents the bundled set as of this release.

Name	Category	Description
`bridge-town-gsheet-formatting`	gsheet-formatting	Use whenever a Bridge Town agent is about to write model output to Google Sheets. Teaches how to shape Python output so it arrives in the sheet correctly formatted.
`bridge-town-native-sheets`	native-sheets	When to create a native sheet vs. a Google Sheet, how to read the `.btsheet.json` schema/example resources, how to edit safely with `update_native_sheet_cells`, the v1 formula/formatting scope, and how to explain an output cell’s derivation with `render_native_sheet_cell_explanation`.
`bridge-town-scenario-sheets`	native-sheets	Branch-based what-if workflow for native sheet input assumptions — branch, edit cells, run, compare against base, then merge/keep/discard.
`collaborate_on_project`	collaboration	Set up and manage multi-analyst collaboration on a Bridge Town model — sharing, pull-request review workflow, and internal template cloning.
`commit_files`	file-management	Atomically commit multiple file creates, updates, and deletes in one git commit, keeping the model in a consistent state.
`connect_google_sheets`	data-integration	Connect a Google Sheet to a Bridge Town model and import data for modelling.
`convert_excel_workbook`	data-integration	Convert an existing Excel financial model into a reviewable Bridge Town Python model — profile, generate, review findings, apply, run, and dashboard.
`create_cash_flow_model`	model-authoring	Build a cash flow model covering operating, investing, and financing activities.
`create_dashboard`	dashboards	Create a visual dashboard from a Bridge Town model run output — chart type discovery, output structure, and the full create → share flow.
`create_expense_model`	model-authoring	Build an operating expense (OPEX) model with departmental budgets in Python.
`create_headcount_model`	model-authoring	Build a headcount plan with loaded costs, hiring schedules, and attrition.
`create_marketplace_gmv_model`	model-authoring	Forecast GMV, take-rate revenue, and supply/demand dynamics for a marketplace.
`create_revenue_model`	model-authoring	Build a bottom-up or top-down revenue forecasting model in Python.
`create_unit_economics_model`	model-authoring	Model CAC, LTV, payback period, and expansion revenue for a SaaS business.
`create_usage_based_pricing_model`	model-authoring	Forecast revenue for usage-based or consumption pricing models (API calls, seats, compute).
`discover_and_query_data`	data-integration	Discover data sources attached to a model and query them with SQL.
`gsheet-finance-styles`	gsheet-formatting	Apply finance-grade visual formatting via `format_gsheet` after writing values to a Google Sheet. Pair with `bridge-town-gsheet-formatting`.
`run_scenario_analysis`	scenario-analysis	Run what-if / sensitivity / compare-assumptions analysis on an existing model via a branch-based workflow.
`scenario_analysis`	model-authoring	Author a new scenario/sensitivity model from scratch in Python — defines BASE_ASSUMPTIONS, SCENARIOS, and SENSITIVITY_DRIVERS.

Domain-specific resources: native sheets

Not every resource is a skill template. bridge-town-native-sheets and bridge-town-scenario-sheets (above) are paired with three plain-data MCP resources under a separate bridge-town:// URI scheme that agents should read before hand-authoring or patching a .btsheet.json file:

Resource URI	Returns
`bridge-town://native-sheets/schema/v1`	The `.btsheet.json` JSON Schema, generated from the runtime `NativeSheetDocument` model.
`bridge-town://native-sheets/examples/input-assumptions`	A worked editable input sheet: two tabs, sparse cell encoding, a same-sheet cross-tab formula.
`bridge-town://native-sheets/examples/output-view`	A worked immutable output sheet view: one tab in the row-array encoding, with run/commit provenance populated.

See the native sheets tool reference for the tool-call surface these resources support.

Canonical MCP skills vs. public user-authored skills

Bridge Town has two distinct surfaces that both use the word “skills”:

Surface	URI / endpoint	What it contains
Canonical MCP skill templates	`skills://` · `skill://{name}`	The 17 bundled templates above. Stable. Ships with every Bridge Town server. Authoritative source of truth for agent guidance.
Public user-authored skills	`GET /api/skills`	User-created and community-published skill templates stored in the Bridge Town database. Dynamic — varies by deployment, user, and community activity. Not part of the MCP resource surface.

Key distinction for agents and registry reviewers:

skills:// is a stable MCP resource backed by files bundled into the server image. It does not change at runtime and is safe to rely on across deployments.
/api/skills is a dynamic REST collection of user-created content. Its contents vary per tenant and community state. It is not the source of truth for skills:// and is not surfaced as an MCP resource.

When an agent or integration references skills://, it is talking to the canonical bundled set, not the community catalog. When a user visits the Bridge Town web app’s Skills directory, they are browsing the public REST surface.

MCP Apps — interactive UI over existing tool results via ui:// resources
get_skill reference — compatibility bridge for hosts that cannot read resources
search_tools reference — includes the domain="skills" special case
Connecting Claude.ai — Claude.ai-style search_tools → get_skill workflow
Connecting any MCP Client — full MCP resource surface overview
Agent Workflow Cookbook — examples of attaching skills to agent workflows