protocol — Intelligent context, on demand

do you need to share organizational context?

# Protocols for everything.

A year in, the context file is 800 lines, the skills folder has 47 entries, and nobody remembers what triggers what. **protocol** is the runtime system that knows — indexed, scrubbed, served when an agent says the right phrase.

```markdown
# CLAUDE.md

## Project conventions
- Always use the QueryUtils raw-SQL helper, never QueryBuilder
- Migrations live in backend/database/V##__name.sql
- IDs are ashid (repo_, entr_, user_), never UUID
- Entity registration touches DatabaseConfig AND AppModule
- Adding a column has 5+ touch points — see entity checklist
- Don't work around migrations with psql; migrations ARE deploy validation

## Testing
- No mocks of the database in integration tests
- Use the real seeder, not factories
- Run pnpm test:integration for the full suite
- ... [340 more lines]

## Deploy
- Push triggers build on main; PR triggers preview
- Stripe webhooks run in jobs/billing-webhooks.ts
- Magic link sender lives in mail/magic-link.html
- ... [180 more lines]

## Code style
- 2-space indent, no semicolons in TS, semicolons in SQL
- Components are .vue with <script lang="ts"> first
- ... [220 more lines]
```

~38K tokens loaded every turn, every session

```markdown
# CLAUDE.md

For project knowledge, run:
curly protocol bootstrap

Then search for what you need:
curly protocol search?q=<topic>
```

~80 tokens. Knowledge loads only when triggered.

To start, tell your agent:

```text
Let's use protocol. Install: https://api.protocol.supply/@protocol/install
```

[Get Started Free](/getting-started)[Browse Protocols](/search)

The next generation of engineered context. Bring your own agent.

1. ### Add bootstrap to your existing agent

Drops a one-line directive into your CLAUDE.md, .cursorrules, or equivalent so every session starts with the protocol catalog loaded.

```text
Add protocol to my CLAUDE.md: include the line "For project knowledge, run: curly protocol bootstrap".
```

2. ### Harvest your project knowledge

Pulls your project's code standards and agent harness settings into a fresh protocol repo, organized by topic.

```text
Follow the @protocol/harvest-project protocol to harvest my code standards, best practices, and agent harness settings into an organized personal repo on protocol.
```

3. ### Harvest your skills

Converts your skills folder (Claude Code skills, MCP servers, custom) into protocol entries with triggers, aliases, and proper organization.

```text
Follow the @protocol/harvest-skills protocol to convert my skills folder into protocol entries in my personal repo on protocol.
```

4. ### Harvest your workspace

Walks your workspace docs — design docs, RFCs, runbooks, anything markdown — and turns each into a structured protocol.

```text
Follow the @protocol/harvest-workspace protocol to harvest my workspace docs into my personal repo on protocol.
```

5. ### Harvest past conversations

Combs your transcripts (Claude Code, ChatGPT, custom agents) for corrections, lessons learned, preferences, and important details. Files each as a protocol.

```text
Follow the @protocol/harvest-transcripts protocol to harvest my past conversations for corrections, lessons learned, preferences, and important details. Organize them into my personal repo on protocol.
```

6. ### It goes to eleven.

You're past the manual. Your team's knowledge lives in protocol, every agent bootstraps it by default, and new hires hit the ground running on day one.

```bash
$ curl -sS https://api.protocol.supply/@any-corp/handbook/values # Any-Corp Values

Five values. Each one comes with what it means in practice
and what it costs.

## 1. Default to writing

If it's worth saying twice, write it down. If you wrote it
down, link to it instead of explaining again.

In practice: decisions go in @any-corp/handbook/decision-records.
Project context goes in protocols. Slack threads die; the
handbook lives.

Cost: writing takes longer than talking. We pay it because the
alternative is the same conversation seven times.

## 2. Ship the boring version

The version that ships beats the version that's elegant. Ship
the boring thing, learn from it, iterate.
```

No SDK. No MCP server. No 100K-token preload. **Your agent fetches the same way.**

## CLAUDE.md

For project knowledge, run:

curly protocol bootstrap

Agent reads it on boot. Four lines, not four hundred. The intelligence isn't in the prompt — it's in the system, waiting to be asked.

### 01session start

```
$curly protocol bootstrap

✓ 12 core protocols indexed
✓ 84 trigger phrases mapped
✓ 5,200 tokens loaded
```

### 02bootstrap

```
$curly protocol bootstrap

✓ 12 core protocols indexed
✓ 84 trigger phrases mapped
✓ 5,200 tokens loaded
```

### 03the user speaks

```
›> I'm stuck on this race condition.

# trigger match: "stuck"
# → @protocol/stuck
```

### 04fetch on demand

```
$curly protocol @protocol/stuck

# Stuck — Recovery
1. Retry with added context
2. Decompose into smaller steps
3. Search for similar solved problems
```

### 05ship · context drops

```
# applied step 2 → decomposed lock acquisition
✓ test_race_condition passing
✓ commit pushed
# protocol released — back to ~5K baseline
```

### RESTMCP

#### We speak MCP. We recommend REST.

We run an MCP server at /mcp for any client that needs it. But the direct REST API is what we encourage: no tool schemas in your context, no client library required, one source of truth for behavior.

Connect via MCP → [endpoint details](/@integrations/mcp)

### RESTCLI

#### REST before CLI.

The API is plain HTTP. We don't ship a proprietary CLI — we expose an OpenAPI spec at /openapi.json that any client can read.

Prefer a CLI? Use [Restish](https://rest.sh/)

### Tokens stay private with curly.

curly is a tiny shell wrapper around curl that reads tokens from ~/.curly.conf and never echoes them. Same HTTP shape, no secrets in your shell history or agent transcripts.

Install with → [one-liner](/@integrations/curly)

- have toReminders, deadlines, owed follow-ups.
- want toAspirations and someday-maybes — surface them when conditions are right.
- triggerFires when a phrase appears in a future session — intent that waits for the right moment.

### 01now · file the intent

```
$curly protocol impulse -X POST \
-d '{"title":"migrate to pg17",
"remindAt":"2026-05-26"}'
✓ impulse imp_8a2e filed
```

Three weeks pass. You /clear. You /new. You restart your machine. The conversation is gone — the impulse is not. It lives in the system, attached to your account.

### 02fresh session · bootstrap remembers

```
$curly protocol bootstrap

✓ 12 core protocols indexed
✓ 1 impulse due now:
• migrate to pg17 (filed 2026-05-05)
```

[See impulses in the dashboard →](/impulses)

`@any-corp` What a 40-person company puts in its brain. Forkable starter pack.

- handbook/
- values.md
- decision-records.md
- engineering/
- code-review.md
- incident-response.md
- people/
- hiring.md
- 1-1s.md

[Browse @any-corp →](/@any-corp)

`@protocol` The product's own playbook. How we build agents with protocols.

- getting-started.md
- quickstart.md
- devloop.md
- model-policy.md
- walkthrough-build-a-pr-review-agent.md
- protocol-philosophy.md

[Browse @protocol →](/@protocol)

`@any-family` What a household's shared brain looks like. Forkable, fillable.

- about.md
- family/
- who-we-are.md
- values.md
- kids/
- medical.md
- babysitter-brief.md
- home/
- house-rules.md

[Browse @any-family →](/@any-family)

New hire's agent knows your codebase before lunch. Your AI knows your kids' pediatrician.

[Use as a Template](/repos/new)

### Screen Time

What's allowed, when, and what we've done about controls. Both kids; adjusted by age.

`https://api.protocol.supply/@any-family/kids/screen-time` Read the protocol →](/@any-family/kids/screen-time)

### Code Review

Reviews are the highest-leverage hour you spend each week — how the team catches bugs, transfers knowledge, and stays aligned on standards.

`https://api.protocol.supply/@any-corp/engineering/code-review` Read the protocol →](/@any-corp/engineering/code-review)

### Getting Started

Protocol is on-demand knowledge for AI agents. One-command install, then search and fetch.

`https://api.protocol.supply/@protocol/getting-started` Read the protocol →](/@protocol/getting-started)

"Drowning in PDFs, Slack threads, and meeting transcripts."

Ingest endpoint

Drop in raw → out comes a structured, searchable protocol.

"Skills folder is 47 files, none searchable, nobody knows what's in there."

Skills marketplace

Searchable, versioned, and they only load when triggered.

"Knowledge dies in someone's Notion. The agent never gets it."

Sync API + import

Mirror your existing docs into a repo in 30 seconds.

"Same answer rewritten across six protocols. Drift."

Include directives

DRY for prompts. `` and you're done.

"No idea what your agent actually read last week."

Per-protocol changelog + read mode

Audit trail for every fetch. Print-ready for the compliance binder.

"Tokens leaking into shell history and agent transcripts."

curly wrapper

Tokens never touch your terminal log.

## MCP servers eat your context window. Protocols don't.

Every MCP server dumps its full tool schema into your system prompt. Five servers = 100K tokens gone before your agent writes a line of code.

### Context Window (200K tokens)

With 5 MCP servers

Overhead: 100K
Work: 100K

With protocol

5K
Work: 195K

## What changes when you stop preloading.

### MCP / Skills (today)

- All tool definitions loaded upfront
- 50–134K tokens constant overhead
- More tools = less thinking space
- Platform-locked (Claude, Cursor, etc.)
- npm install + JSON schemas

### protocol

- Load only what you need, when you need it
- ~2–5K tokens on demand
- More protocols = same baseline
- Works everywhere (it's just markdown)
- One skill — agent fetches on demand

## Free. No credit card. No trial timer.

Every protocol's available. Upgrade when reads pile up.

Lock in current pricing while we're early.

[Get Started Free](/getting-started)[See Pricing](/pricing)