do you need to share organizational context?

# Protocols for everything.

Your team's knowledge grows. Skills multiply. Procedures drift. **protocol** organizes and serves your agents' runtime context — so the context window stays clean as the org gets bigger.

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.mdafter · 4 lines

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

your terminal live · public

```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 catalog isn't in the prompt — it's a search away.

## 01session start

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

## 02bootstrap

$curly protocol bootstrap

✓ 12 core protocols indexed  
✓ catalog searchable  
✓ ~5,200 tokens loaded  

## 03the user describes a topic

›> I keep hitting deadlocks under load.

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

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

## 05ship

# applied step 2 → decomposed lock acquisition

✓ test_race_condition passing  
✓ commit pushed  

# protocol released — back to ~5K baseline

### 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 folder is 47 files, none searchable, nobody knows what's in there."

Skills marketplace  

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

"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. `<!-- include: @repo/slug -->` 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.

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

**already onboarded? go further — harvest existing knowledge →**

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