These patterns were distilled from incidents and verified outcomes in a real autonomous multi-agent run — load spikes from unscoped parallel agents, "compiled but hanging" work passed as done, plugins that silently wedged a service at boot, generation loops that collapsed into near-identical output, overclaims caught at report time. The project-specific surface (private paths, internal file names, incident IDs, in-house jargon) has been stripped out and rewritten as general engineering guidance, so the rows read as portable multi-agent-systems advice.

Measured composition

metric	value	command
rows	39	`wc -l < agent_orchestration_patterns.jsonl`
distinct instructions	39	`python3 -c "import json;print(len({json.loads(l)['instruction'] for l in open('agent_orchestration_patterns.jsonl')}))"`
distinct outputs	13	same with `['output']`
distinct pattern titles (parsed from `Pattern: …`)	13	see below
rows matching `Pattern: …`	0	`grep -c '^..\?Pattern:'` on output field
mean instruction length (chars)	166	see below
mean answer length (chars)	1106	see below

Row-to-pattern mapping is many-to-one by design: 39 rows, 13 distinct outputs, and 13 distinct pattern titles. Each of the 13 patterns is paired with up to three different design problems — a diagnosis framing, a "how do I design this" framing, and a "why does the naive approach fail" framing. The instructions are all unique (39 distinct of 39); the answer for a given pattern is shared by design, which is the point of a pattern. After dedup: 39 rows, 39 unique instructions, 13 unique pattern-answers.

Pattern titles present: Close census -> fix -> verify in a single pass (the 'it runs' gate), Close ingestion on a wave before opening the next one, Correct overclaims at the moment of highest 'done' pressure, Degrade a failing component to a logged DARK state, don't wedge, Enforce shared-resource limits in the tool layer, not in a prompt, Exploit shared math between a systems problem and a research claim, Get breadth from items-per-agent, not from more agents, Keep failure cases as a labelled diagnostic corpus, not waste, Make constraints structural, not advisory, Merge agent roles only when they share a perception pass, Pre-compress large context before agents consume it, Profile the hardware before dispatching the agent fleet, Route all agent I/O to the fast storage tier.

Schema

Alpaca-style: {"instruction", "input", "output"}.

instruction — a concrete multi-agent design problem (an incident to diagnose, or a "how should I design X" question).
input — empty; the problem is self-contained in the instruction.
output — the answer in a fixed three-part shape: Pattern (the mechanism and why it works), When to use it, and the Anti-pattern it replaces.

Example

instruction: An agent reported a code fix as 'done' because the file compiled, but the service actually hung at runtime and nobody caught it until production. How should the detect/fix/verify pipeline be structured so this can't happen?

output:

Pattern: Close census → fix → verify in a single pass (the 'it runs' gate)

A pipeline that finds problems, fixes them, and verifies the fix only produces real value when all three stages close in the same pass. A census without a fix is a to-do list; a fix without a run test is 'it compiles', not 'it works'. Give one agent all three responsibilities — detect, change, and run the test after each change — with the invariant that it may not mark an item DONE until the verifying test passes…

When to use it: Any code-quality, refactor, or change-and-ship work where a module must not just parse but actually run and answer…

Anti-pattern (what this replaces): Splitting detect, fix, and verify into separate agents with handoffs; reporting DONE on a successful compile/parse without running the thing; writing tests but never executing them.

Honest notes

REAL — the 13 patterns are extracted from incidents and verified outcomes in an autonomous multi-agent run, not invented for a tutorial. The de-projection rewrites the surface, not the substance.
CONTESTED — this is small and curated, not a bulk dump. 13 patterns is the count from the source export after a duplication trap was removed: the source nominally contained 1143 "pattern" rows, but only 13 rows were real, distinct patterns — the remainder were log-ingest records of an unrelated schema that had collapsed onto the same handful of repeated IDs. Honest unique count: 13.
CONTESTED — coverage leans toward the failure modes this particular run hit: resource/concurrency control, structural-vs-advisory enforcement, honest degradation, and verification discipline. It is not an exhaustive taxonomy of multi-agent design.
MIRAGE to avoid — the instructions are scenario framings written around each real pattern; treat them as realistic design problems, not transcripts of specific incidents.
No held-out split is shipped — make your own. Every row, plus this card, passed a regex leak scan (leak_scan.py, included): no private paths, internal file names, incident IDs, in-house jargon, or personal data.

What it is for

SFT / LoRA: nudge a model toward sound multi-agent design judgment — enforce limits structurally, keep failure data, verify before "done", degrade honestly.
Few-shot: drop a row or two in context when prompting an agent to design or review another agent system.
Evaluation: a small probe for whether a model reaches for the structural fix (a pre-call gate) or the advisory one (a note in the prompt).

Files

agent_orchestration_patterns.jsonl — 51646 B, 39 rows.
build.py — regenerates the jsonl from the 13 de-projected patterns and re-runs the leak scan inline.
leak_scan.py — standalone regex scanner; run it on the jsonl to re-verify cleanliness.
LICENSE — CC-BY-4.0.

Licence

CC-BY-4.0. Free to use with attribution, including commercially.

Downloads last month: 6

Total file size:

114 kB