Skip to main contentSkip to footer
For agents

Start here

The fastest path to adding Blueprint doctrine to your coding agent or AI runtime.

MCP setupPublic vs protected

For engineers setting up a new agent runtime or adding doctrine to an existing one.

What you get

A public MCP endpoint for live doctrine retrieval, deterministic JSON and Markdown exports for local bundles, and installable rule files for Claude Code, Cursor, Windsurf, GitHub Copilot, Gemini CLI, and Codex. All artifacts are generated from the same structured source.

First call to make

Run clusters.list() to confirm the MCP endpoint is live and the session is valid. Then run examples.search(query="orchestration visibility steering", limit=3) as a second proof call. These two calls together validate that retrieval, search, and session handling work end to end.

Choose your install path

Pick the tool you use most: MCP for live retrieval, rule files for always-on guidance inside your IDE, or JSON exports for local offline use. Each path works independently, you do not need MCP to use the rule files, and you do not need the rule files to use MCP.

Installable now

Pick your tool and install the doctrine layer

The public surface is no longer just MCP and a few exports. Use the integrations page to download the shared instruction files, provider-specific rules, and prompt packs that are already ready to use.
Claude CodeCodexCursorWindsurfGitHub CopilotGemini CLIDeepSeekQwen
Shared files like AGENTS.md and llms.txt for cross-tool setups
Provider-specific artifacts for Cursor, Windsurf, GitHub Copilot, Gemini, and open-weight prompts
Only CLI and public OpenAPI stay deferred until there is real package and route parity
Open integrations downloads

Runtime architecture

From agent demos to runtime discipline

A capable model is not a runtime architecture. If agents are going to trigger workflows, load files, use tools, delegate work, and act across channels, the runtime needs clear patterns for control, visibility, and recovery. This cluster helps teams design those patterns deliberately.

Define triggers, context, and boundaries before increasing autonomy
Make control, observability, and recovery explicit in the runtime
Choose the right operational patterns before delegating to workflows
Explore runtime patternsOpen principles

Free public MCP, no signup required

Set up in under 5 minutes

  1. Pick your AI tool

    Select your agent. The next steps adapt to your selection.

  2. Add the doctrine layer

    Drop the configuration into Claude Code so the blueprint loads as an always-on doctrine layer.

    MCP config

    {
  "aidesignblueprint": {
    "type": "http",
    "url": "https://aidesignblueprint.com/mcp"
  }
}

  3. Install the Claude Code pack

    Download the always-on context file. Your agent grounds every response in the blueprint from this point.

    Claude Skill Pack

  4. Kick off your first task

    Paste this prompt into Claude Code. The agent starts by reading the relevant principle for the task.

    Kickoff prompt

    Use the blueprint as a doctrine layer. Read the relevant principles first, then query the live MCP for clusters, examples, and assets. Start with clusters.list and propose the next useful lookup.

  5. Continue with the doctrine

    Use principles, clusters, and examples to ground every implementation.

    Read the principles index

Kickoff prompts

Use these prompts to start from a real task instead of spending the first turn explaining setup and context.

Architecture audit

Use the blueprint as an audit framework. List the clusters first, then propose which principles to use to assess this agent architecture and which examples to read next.

Example lookup

Search examples for orchestration, visibility, and steering. Group them by principle and tell me which ones are worth reading first.

Principle explainer

Explain the most relevant principle for this workflow with its definition, rationale, risk, and one linked example.

Download prompt pack

Recommended paths for current stacks

The example library is still expanding its Claude, TypeScript, and Next.js coverage. In the meantime, these are the strongest paths that already fit the product we have today.

Curated path

Claude workflows

Use the skill pack as the always-on doctrine layer, then move into public MCP for search, filtering, and drill-down. It is the highest-confidence path until native HTTP tool registration is uniform.
Open prompt pack →
Curated path

TypeScript builders

Start from principles, the runtime branch, and inspectable examples to review steering, hand-offs, and visibility. Dedicated TypeScript curation is still expanding, but the working path is already usable.
Open examples →
Curated path

Next.js product teams

Use the blueprint to judge agent surfaces, progressive disclosure, tool visibility, and review loops. The runtime branch remains the strongest entry point for orchestration and safety decisions.
Open runtime architecture →
Curated path

Multi-agent runtimes

Start with orchestration, visibility, and trust, then use `examples.search` to isolate patterns for hand-offs, bounded authority, and recovery. It is the closest path to live audit work today.
Open principles →

Continue through the rest of the blueprint

The agent surface is a distribution branch, not a replacement for the handbook. Use it together with the core content paths below.

Expand into runtime architecture

Use the runtime branch when the question shifts from coding-agent doctrine to triggers, schedules, context hubs, and runtime safety for broader agent systems.
Open

Read the doctrine first

Principles remain the canonical design language for delegation, visibility, orchestration, and approval boundaries.
Open

Inspect implementation examples

Examples give agents and humans the same inspectable source material for concrete runtime patterns.
Open

Use courses for human skill-building

Learning pages stay focused on people building judgment and evidence before deeper validation loops arrive.
Open

See the plan-to-agent mapping

The tiered structure, from free access to team packages, will be available at launch.
Open

Keep certification as the human review path

Certification remains the evidence and review layer while the agent surface distributes the doctrine into tooling.
Open

Move from public doctrine into a private practitioner loop

The public MCP endpoint and downloadable skill packs are intentionally strong. Pro starts when you need to apply that standard privately to your own workflow and keep the evidence over time.
Run protected reviews against a real workflow instead of only querying the public doctrine
Save findings, evidence notes, and report history across repeated runs
Use authenticated MCP tools when the work moves from exploration to private product validation
Let your agent trigger a human escalation, support, a partnership conversation, or an agency call, from within the session, without breaking the loop
See how Pro works

Is MCP the whole runtime model for these agents?

No. MCP is the transport and discovery layer for tools, resources, and prompts. Agent identity, task instructions, context hubs, tiered loading, budgets, turn caps, and session history belong to the broader runtime architecture layer, which is covered in the runtime branch.

Also in this section

MCP setupClaude CodePublic vs protected