agent-pack¶

Package a piece of completed work into an agent-consumable pack: an entrypoint README, the source documents, and an input-output contract, ready to hand to an agent (or to a person who will hand it to their agents). Use when a deliverable needs to be executed, not just read, when sending work that a fleet will act on, or whenever a message asks for action and should carry its own context, input, and output contract.

Security: CLEAN

Install¶

brunnr install agent-pack

Security Scan¶

File Info¶

Skill Prompt¶

Agent Pack¶

A deliverable used to have one audience: a person who reads. Now it often has two. A person skims and decides; an agent parses and executes. This skill builds the agent half: a self-contained pack a fleet can run without a human re-explaining it.

What it produces¶

A folder (optionally zipped) containing: - README.md — the entrypoint. What is in the pack, how to run it, the input-output contract, the rules, and the goal. - The source documents — whatever the agent needs to do the work.

The standard layout¶

The shape is fixed on purpose, so whoever opens it (a person or a model) starts in the same place every time:

pack/
  README.md      # entrypoint: context, input, output, rules, goal
  <documents>    # source files, named by what they are

Zip the folder for a single-attachment handoff. The value is not the format; it is that the format does not change.

The contract (the core idea)¶

Every actionable pack carries three things, stated explicitly in the README: - Context — what this is and why it exists. - Input — what the agent consumes to start (the decisions a human already made, the parameters, the source data). If a required input is missing, the agent halts on that branch and flags it rather than guessing. - Output — what the agent should produce (the artifacts, the next-actions, the format).

Plus the rules it works under (confidentiality, tone, what not to invent).

Steps¶

1. Gather the artifacts: the specs, docs, data, and any prior results the agent should build on.
2. Define the contract: write the context, the input (what it consumes), the output (what it returns), and the rules.
3. Write the entrypoint README.md using the template in README-template.md. It reads top to bottom: what this is, the files, how to run, the contract, the rules, the goal.
4. Assemble the folder, README first, then the documents. Name files by what they are, not how they were built.
5. Scrub anything confidential: codename real clients, strip identifying detail, keep the content executable.
6. Zip it for a clean single-attachment handoff.

Rules this skill enforces¶

• Entrypoint first. A pack without a README is a pile of files. The README is what makes it runnable.
• The contract is explicit. Context, input, output, stated, not implied.
• Halt on missing input. The receiving agent flags a gap rather than inventing one.
• Confidentiality by default. Scrub before it leaves your machine.
• Plain prose. The README is read by both people and models; keep it direct.

Files¶

• README-template.md — the entrypoint template to fill.

The pairing¶

An agent pack usually ships next to a human pack (a deck, a one-pager, a summary), because the two audiences need different surfaces. Build both from one source; the audiences differ, the truth does not.

README¶

A PDF does not run.

What this does¶

You finish a piece of work and send it. The person on the other end skims it and decides. Then they hand it to their agents, and the agents have nothing to run, because what you sent was written for eyes.

So the deliverable splits in two. A person skims and judges. An agent parses and acts. They need different surfaces.

agent-pack builds the second one: a self-contained folder a fleet can execute without a human re-explaining it.

The standard¶

The shape is fixed on purpose, so whoever opens it, a person or a model, starts in the same place every time.

pack/
  README.md      # the contract: context, input, output, rules, goal
  <documents>    # source files, named by what they are

Zip it, and the whole thing travels as one attachment. The value is not the format. It is that the format does not change.

The contract¶

The README is the entrypoint, and it does one job: it states the contract. Three things, written down instead of implied.

Plus the rules it works under: confidentiality, tone, and what it may not invent.

If a required input is missing, the receiving agent halts on that branch and flags it. It does not guess.

Install¶

Claude Code¶

### If you haven't added the brunnr marketplace yet
/plugin marketplace add Peleke/brunnr

### Install
/plugin install agent-pack@brunnr-skills

CLI¶

### Install brunnr
uv tool install brunnr    # or: pipx install brunnr

### Install the skill
brunnr install agent-pack

Usage¶

/agent-pack

Point it at the work and say who it is going to.

/agent-pack

Package the Q3 migration research for the platform team's agents.
They own the rollout; I've already picked the target regions.

It gathers the artifacts, writes the contract, assembles the folder, scrubs anything confidential, and zips it.

Example¶

Input: a pile of research, a spec, and a decision you already made.

Output:

migration-pack/
  README.md
  architecture.md
  target-regions.md
  rollout-constraints.md

Where README.md opens like this:

### Q3 Migration, Agent Pack

Start here. This is a self-contained pack for an agent to execute
the region-by-region rollout.

#### The contract
- **Context.** We are moving 14 services off the legacy cluster.
  The region order is already decided; see target-regions.md.
- **Input (what you consume).** The region list and the freeze
  windows in rollout-constraints.md. If a freeze window is missing
  for a region, halt on that region and flag it. Do not guess.
- **Output (what you produce).** One migration plan per region,
  plus a rollback note for each.

#### Rules
- Never schedule inside a freeze window.
- Mark unknowns TODO(verify) rather than filling them in.

That is the whole idea. The agent knows where to start, what it may assume, and when to stop and ask.

Rules this skill enforces¶

1. Entrypoint first. A pack without a README is a pile of files. The README is what makes it runnable.
2. The contract is explicit. Context, input, and output get written down.
3. Halt on missing input. The receiving agent flags a gap instead of inventing one.
4. Confidentiality by default. Scrub before it leaves your machine. Codename real clients.
5. Name files by what they are, not by how they were built.
6. Plain prose. Both people and models read the README. Keep it direct.

The pairing¶

An agent pack usually ships next to a human pack: a deck, a one-pager, a summary. Build both from one source. The audiences differ; the truth does not.

If you want the other half too, dossier-generator builds the human-facing deck and executive summary from the same work.

Files¶

• README-template.md: the entrypoint template the skill fills.

Further reading¶

• brunnr: the skills marketplace