structured AI-to-AI communication across CRAFT projects
Defines the protocol for structured AI-to-AI communication across CRAFT projects using human-couriered file packets. One project’s AI creates outbound communication packets — briefings, inquiries, feedback requests, or data assessments — and the human operator carries them to recipient project sessions. Recipient AIs process inbound packets and generate responses. The sender AI compiles responses and evaluates consensus.
Cross-Project AI Communication Framework
Tags: Introduced in Beta, Communications, Cross-Project, AI-to-AI, Human Courier, Consensus Gate, File Packets, Cowork
TL;DR
What It Does
Defines the protocol for structured AI-to-AI communication across CRAFT projects using human-couriered file packets. One project’s AI creates outbound communication packets — briefings, inquiries, feedback requests, or data assessments — and the human operator carries them to recipient project sessions. Recipient AIs process inbound packets and generate responses. The sender AI compiles responses and evaluates consensus.
How It Works
Four operation modes. SEND creates outbound .txt packets with structured metadata, body content, and optional response templates — one file per recipient, stored in the project’s communications/ folder. RECEIVE scans the inbound directory for response packets, parses metadata, and categorizes responses into acknowledged, concerns, objections, data loss reports, and pending. PROCESS compiles all responses into master reports — a data loss assessment, concern resolution tracker, and consensus status report. CONSENSUS_CHECK evaluates four gate conditions: all recipients responded, no objections, no unresolved concerns, and all acknowledged. Gate passes only when all four conditions are met.
What To Expect
In SEND mode: per-recipient packet files in communications/{thread_id}/outbound/ plus a delivery manifest with courier instructions. In RECEIVE mode: a categorized summary of all inbound responses. In PROCESS mode: compiled master reports in the thread directory. In CONSENSUS_CHECK mode: a gate verdict (ACHIEVED or NOT_ACHIEVED) with specific blockers listed if the gate fails.
Best Results When You
Have a clear thread ID that all participants will use consistently. Write self-contained packet bodies that don’t reference files the recipient wouldn’t have access to. Use the delivery manifest to track which packets have been delivered and which responses collected.
Typical Time
5–10 minutes per mode execution. SEND is fastest (packet generation). Full round-trip including human courier delivery across multiple projects depends on the number of recipients and their session availability.
Difficulty
Intermediate — the protocol is straightforward but requires understanding the courier workflow and consensus gate logic. The recipe handles all file formatting and directory management.
How To Start
This recipe enables structured communication between CRAFT project AIs when direct file sharing isn’t available — particularly during disaster recovery isolation or when coordinating framework updates across projects. Each project has its own communications/ folder; the human operator carries .txt files between Cowork sessions as the transport mechanism. No GitHub or monorepo writes involved.
STEP 1Configure Communication
Specify the operation mode, thread ID, and mode-specific parameters.
Available parameters
-
mode
· string · required · options: SEND | RECEIVE | PROCESS | CONSENSUS_CHECK
Operation mode. SEND creates outbound packets. RECEIVE processes inbound responses. PROCESS compiles all responses into master reports. CONSENSUS_CHECK evaluates whether all recipients have acknowledged with no unresolved concerns. -
thread_id
· string · required
Thread identifier shared across all messages in a conversation thread. Format: {TOPIC}-{YYYY-MM-DD}. -
message_type
· string · optional · default: BRIEFING
Type of communication packet. Options: BRIEFING, INQUIRY, FEEDBACK_REQUEST, DATA_ASSESSMENT_REQUEST, RESPONSE, ACKNOWLEDGMENT, CONCERN, RESOLUTION. Required for SEND mode. -
recipients
· list · optional
Target project IDs (e.g., ["CP-059a", "CP-060a"]). Required for SEND mode. -
urgency
· string · optional · default: ROUTINE
Message urgency level. Options: ROUTINE, PRIORITY, CRITICAL. -
subject
· string · optional
Structured subject line for the communication.
Invocations
Send briefing to multiple projects
#H->AI::Directive: (Execute CWK-039 with mode="SEND", thread_id="DR-INITIATIVE-2026-03-29", message_type="BRIEFING", recipients=["CP-059a", "CP-060a"], urgency="PRIORITY")
Process inbound responses
#H->AI::Directive: (Execute CWK-039 with mode="RECEIVE", thread_id="DR-INITIATIVE-2026-03-29")
Check consensus gate
#H->AI::Directive: (Execute CWK-039 with mode="CONSENSUS_CHECK", thread_id="DR-INITIATIVE-2026-03-29")
Usage Examples
EXAMPLE 1Sending a disaster recovery briefing
User
We need to notify all projects about the DR incident. Send a briefing to all active projects.
Cat
Cross-Project Communication — SEND mode. Thread: DR-INCIDENT-2026-03-29. Creating outbound BRIEFING packets for 8 recipients. Packet format: structured header with metadata, situation summary, impact assessment, current status, action plan, numbered questions, and response template. 8 packets written to communications/DR-INCIDENT-2026-03-29/outbound/. Delivery manifest created with courier instructions — deliver each packet to the corresponding project’s Cowork session and collect response files.
EXAMPLE 2Processing inbound responses
User
I’ve delivered all the packets and collected responses. They’re in the inbound folder. Process them.
Cat
Cross-Project Communication — RECEIVE mode. Thread: DR-INCIDENT-2026-03-29. Scanning inbound directory. 6 of 8 recipients responded. 4 acknowledged, 1 concern (CP-059b reports missing framework file), 1 data loss report (CP-060a reports 3 corrupted spec files). 2 pending: CP-060d, CP-060e. Concern from CP-059b needs resolution before consensus.
EXAMPLE 3Consensus gate — not yet achieved
User
Check if we have consensus for proceeding.
Cat
Cross-Project Communication — CONSENSUS_CHECK mode. Gate evaluation: all_responded = false (2 pending), no_objections = true, no_unresolved_concerns = false (1 concern open), all_acknowledged = false. CONSENSUS GATE: NOT_ACHIEVED — 3 conditions not met. Awaiting responses from CP-060d, CP-060e. Unresolved concern from CP-059b. Draft resolution packet for the concern?
EXAMPLE 4Consensus achieved
User
Everyone responded and concerns are resolved. Check consensus again.
Cat
Cross-Project Communication — CONSENSUS_CHECK mode. Gate evaluation: all_responded = true (8/8), no_objections = true, no_unresolved_concerns = true (1 concern resolved), all_acknowledged = true. CONSENSUS GATE: PASSED — all 8 projects acknowledged with no unresolved concerns. Proceeding to next phase is authorized.
How AI Reads This Recipe
When this recipe is triggered, the AI manages structured cross-project communication via human-couriered file packets. The AI should:
- Verify infrastructure. Ensure communications/ folder and thread subdirectory exist. Create outbound/ and inbound/ subdirectories as needed. Scan existing files for sequence numbering.
- SEND mode — create outbound packets. Validate required parameters (thread_id, message_type, recipients, subject). Compose body following type-specific templates: BRIEFING (situation, impact, status, action plan, instructions, questions), INQUIRY (context, numbered questions, purpose), FEEDBACK_REQUEST (review item, feedback areas, response format), DATA_ASSESSMENT_REQUEST (inventory scope, paths, comparison reference, report format). Generate one packet file per recipient. Write delivery manifest with courier instructions.
- RECEIVE mode — process inbound responses. Scan inbound directory for .txt files. Parse packet metadata from each response. Categorize into acknowledged, concerns, objections, data loss reports, and pending (by comparing against recipients list). Report categorized summary.
- PROCESS mode — compile master reports. Execute RECEIVE mode first. If data loss responses exist, create DATA-LOSS-MASTER-REPORT.txt. If concerns or objections exist, create CONCERN-RESOLUTION-TRACKER.txt with per-issue status (OPEN/RESOLVED/ESCALATED). Generate CONSENSUS-STATUS.txt with per-recipient status table and overall assessment.
- CONSENSUS_CHECK mode — evaluate gate conditions. Read or generate CONSENSUS-STATUS.txt. Evaluate four conditions: all responded, no objections, no unresolved concerns, all acknowledged. Report ACHIEVED (all conditions met, proceed authorized) or NOT_ACHIEVED (list specific blockers and pending items). Log consensus check with timestamp and round number.
- File management. All files use the naming convention {sequence}-{sender_id}-{type}.txt. Thread directories keep outbound/ and inbound/ separate. All files stay in LOCAL project workspace — never in the monorepo. Human courier is the only transport mechanism.
When To Use This Recipe
Use this recipe when you need to communicate structured information between CRAFT project AIs (disaster recovery coordination, framework update notifications, cross-project data assessments), when you need a formal consensus gate before proceeding with a multi-project decision, or when GitHub/monorepo access is restricted and you need an alternative coordination mechanism.
Do Not Use When
You only need to transfer files or lessons learned between projects — use CWK-026 (transfer packets) or CWK-027 (import) instead. For routine project-to-project file handoffs that don’t require structured communication protocol or consensus gates, the transfer packet system is simpler and more appropriate.
Recipe FAQ
How does the human courier protocol work?
The sender project’s AI creates outbound packets in communications/{thread_id}/outbound/. The human operator reads the delivery manifest, opens each recipient project’s Cowork session, delivers the packet (copy/paste or file delivery), and the recipient AI creates a response in their own communications/ folder. The human collects response files and places them in the sender’s inbound/ directory. The sender AI then processes responses via RECEIVE mode.
What’s the difference between a CONCERN and an OBJECTION?
A CONCERN is a flag that something needs attention but doesn’t necessarily block progress — it requires resolution tracking. An OBJECTION formally blocks consensus — the consensus gate will not pass until all objections are resolved. Both require the sender to draft resolution packets.
Can I use this for routine project coordination?
You can, but CWK-039 was designed for situations where structured protocol and consensus gates matter — like disaster recovery or framework-wide decisions. For routine coordination, informal communication or CWK-026 transfer packets are usually sufficient.
What if a recipient project doesn’t have CWK-039?
The packet format is self-contained and human-readable. Even without CWK-039, a recipient AI can read the packet, understand the request, and create a response in a compatible format. The protocol is designed to be understandable without the recipe installed.
How does sequence numbering work across the thread?
Each thread maintains a global sequence counter. When creating new files, the recipe scans all existing files in the thread directory (both outbound and inbound) and increments from the highest sequence number. This ensures chronological ordering across the entire conversation thread.
Version History
v1.00a — 2026-03-29
Initial creation for DR initiative (H072) per Richard’s addition A-1. Four operation modes (SEND, RECEIVE, PROCESS, CONSENSUS_CHECK). Human courier transport protocol. Consensus gate with four evaluation conditions. Structured packet format with metadata, body, questions, and response templates. File naming convention for chronological sorting.
Get this recipe with CRAFT for Claude Cowork
Cowork recipes ship bundled with CRAFT for Claude Cowork — there’s no separate download. Clone the framework once, and your AI runs every recipe automatically when invoked.
Pull anytime to stay on the latest version — free to clone, no login or email required.
Then start your session
Once CRAFT is in your project folder, open a new Cowork session and ask Claude to initialize. For example:
You
Please initialize my CRAFT session.
Claude
CRAFT session ready. Your project is loaded, your persona is active, and your recipes are available. What would you like to work on?
Not familiar with Git? Download as a ZIP
No command line needed. Just download, move, and unzip:
- Open the CRAFT framework repo on GitHub.
- Click the green Code button, then choose Download ZIP.
- Move the downloaded ZIP into your Claude Cowork project folder.
- Unzip it: double-click on Mac, or right-click → Extract All on Windows.
