protocol — Intelligent context, on demand

is your agent memory getting out of hand?

# Protocols for everything.

Claude Code, Cursor, ChatGPT, custom — every agent that can `curl` can use **protocol**. We host your team's runtime context. Your agents fetch what they need, when they need it, and drop it when they're done.

CLAUDE.mdbefore · 847 lines

```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

## CLAUDE.md after

```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 on demand.

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.

```
$ 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.**

### 01 session start

For project knowledge, run:

```
curly protocol bootstrap
```

Agent reads it on boot. Four lines, not four hundred. The catalog isn't in the prompt — it's a search away.

### 02 bootstrap

```
$curly protocol bootstrap
✓ 12 core protocols indexed
✓ catalog searchable
✓ ~5,200 tokens loaded
```

One call. ~5K tokens. The agent learns the protocol catalog — names, summaries, where to look — but holds none of the actual content yet.

### 03 the user describes a topic

```
$curly "protocol search?q=deadlocks+under+load"
→ @protocol/stuck (0.91)
→ @protocol/debug (0.74)
```

User describes the problem in their own words. The agent doesn't pattern-match a magic phrase — it searches the catalog.

### 04 fetch the best hit

```
$curly protocol @protocol/stuck
# Stuck — Recovery
1. Retry with added context
2. Decompose into smaller steps
3. Search for similar solved problems
```

Only the protocol this moment needs. ~600 tokens. The agent reads, follows the steps, and ships the fix.

### 05 ship – context drops

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

### Sample protocols

#### 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)

`@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)

## 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

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

#### Ingest endpoint

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

#### Skills marketplace

Searchable, versioned, and they only load when an agent fetches them.

#### Sync API + import

Mirror your existing docs into a repo in 30 seconds.

#### Include directives

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

#### Per-protocol changelog + read mode

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

#### Curly wrapper

Tokens never touch your terminal log.

### 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".
```

### 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.
```

### Harvest your skills

Converts your skills folder (Claude Code skills, MCP servers, custom) into protocol entries with summaries, 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.
```

### 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.
```

### 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.
```

### 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.

[See impulses in action →](/impulses)

## 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)