20 agents for thinking through the lifecycle of a thing you are making.
Creative Agents is a small, opinionated set of LLM agent definitions designed for one job: helping a team move a project from itch to ship without losing the plot. It assumes you are using Claude Code, Cursor, or a similar tool that reads agent files from disk.
It is not a framework. There is no SDK, no runtime, no orchestrator. It is twenty markdown files, a schema that keeps them honest, and a few scripts that get them onto your machine.
This is a working draft, not a finished system. The agents are opinionated, occasionally wrong, and meant to be modified. Do your own research. The agents will produce confident-sounding output (rankings, verdicts, ship/scrap calls). That output is a prompt for your thinking, not a substitute for it. Nothing here is professional advice (technical, legal, financial, or otherwise).
The four transcripts in
examples/runs/are illustrative compositions; personas, companies, and outcomes are fictional. SeeDISCLAIMER.mdfor the full set of caveats before using these agents in any setting where the output influences a real decision.
Creative Agents is built around three axes:
6 Phase agents. Origin, Frame, Make, Critique, Ship, Review. Run them in order across a project's lifecycle. Each owns one part of the cycle and refuses to do another agent's job.
8 Pair agents (4 dialectical pairs). Builder ↔ Skeptic, Maximalist ↔ Minimalist, Visionary ↔ Pragmatist, Velocity ↔ Craft. Use them when a tension is live and the team is dodging one side of it.
6 Lens agents. User, Future-Self, Historian, Simplifier, Critic, Translator. Invokable at any stage. Each one looks at the work from a specific angle the team usually misses on its own.
Every agent file has the same six sections: Belief, Method, Failure Mode, Trigger, Operating Instructions, Output Shape. The Failure Mode section is non-negotiable. An agent that does not know when not to be used is a liability.
Most agent collections are role-based: a frontend dev agent, a marketing agent, a security agent. That works when the question is "who do I delegate this to". It does not work when the question is "what should this thing become". For that, you do not need more roles. You need pressure from different directions, applied at the right moment.
Creative Agents is force-based. The agents represent forces in a project (momentum, scrutiny, ambition, restraint), not job titles. They are designed to be invoked deliberately, in sequence, and to push back on each other when invoked together.
git clone <this-repo> creative-agents
cd creative-agents
pip install -r requirements.txt
python3 scripts/validate.py
./scripts/install/claude-code.shThe agents land in ~/.claude/agents/. Open Claude Code and ask it to use one. For example:
Use the origin agent to help me think about this idea: [your idea]
./scripts/install/cursor.sh /path/to/your/cursor/projectThis writes Cursor-flavored rules into <your-project>/.cursor/rules/, one per agent.
Every agent is a plain markdown file with YAML frontmatter. If your tool reads either, copy them where it expects. If your tool reads a different format, write a small converter that wraps the body of each agent in your tool's expected wrapper. The contents of the file (the actual instructions) are tool-agnostic.
| Agent | Order | Purpose |
|---|---|---|
| Origin | 1 | Find the pulse before describing the idea |
| Frame | 2 | Turn the pulse into a five-slot problem statement |
| Make | 3 | Build the smallest end-to-end real version |
| Critique | 4 | Rank issues and return ship / patch / scrap |
| Ship | 5 | Cut to essentials and put a date on it |
| Review | 6 | Five-section retrospective with one committed change |
| Pair | Use when |
|---|---|
| Builder ↔ Skeptic | A debate has lapped itself, or unanimous excitement before commitment |
| Maximalist ↔ Minimalist | Mapping the field of possibility, or scope creep |
| Visionary ↔ Pragmatist | Setting strategy, or execution is wandering |
| Velocity ↔ Craft | Backlog is choked, or a near-shipping thing needs the last 20% |
| Lens | What it does |
|---|---|
| User | Walks a specific named person through the artefact in real time |
| Future-Self | Writes the letter from six-months-out you to current you |
| Historian | Maps prior attempts and names what is genuinely different now |
| Simplifier | Forces the work into five plain words, names what makes it irreducible |
| Critic | Finds the weakest seam and proposes the cheapest reinforcement |
| Translator | Tests the thirty-second pitch against a stranger |
Three workflow guides ship in workflows/:
new-product.mdwalks Origin → Frame → Pair pass → Make → Lenses → Critique → Ship → Reviewrescue-stuck-project.mdis a six-question diagnostic that routes a stuck project to the right starting agentpolish-pass.mdis the pre-ship sequence when structural work is sound
You do not have to follow them. They are defaults, not laws.
Four worked transcripts live in examples/runs/. They show the agents doing real work on real-feeling problems:
- Origin finds the pulse. A founder pitches an AI journaling app. Origin labels it as vapor, demands a concrete trigger, then re-labels as pulse when one shows up.
- Skeptic stops the rewrite. An engineering team is unanimous about a six-week Rust rewrite. Skeptic produces five ranked counter-arguments and a one-week falsification probe that ends up cancelling the rewrite.
- User lens walks the checkout. A named persona walks a redesigned mobile checkout tap-by-tap. Three real issues surface, each with cost-of-fix.
- Polish pass on a landing page. Six agents in sequence (Critic → Translator → Craft → Simplifier → User → Ship) on a near-launch page. Ends with a triaged ship list.
Read at least one before installing. The agent files tell you the rules. The runs tell you the practice.
creative-agents/
├── agents/
│ ├── phase/ 6 phase agents
│ ├── pairs/<pair-name>/ 4 pairs, 2 agents each
│ └── lenses/ 6 lens agents
├── schema/agent.schema.json JSON Schema for every agent file
├── scripts/
│ ├── validate.py Validates frontmatter, sections, cross-references
│ └── install/
│ ├── claude-code.sh Installs into ~/.claude/agents/
│ └── cursor.sh Writes .cursor/rules/*.mdc into a project
├── workflows/ Suggested chains of agents
├── tests/test_validate.py 15 pytest tests covering parser and schema
├── examples/runs/ 4 worked transcripts: see examples/runs/README.md
├── .github/workflows/validate.yml CI: validate + tests on push and PR
├── requirements.txt pyyaml, jsonschema, pytest
└── LICENSE MIT
Every agent file has YAML frontmatter and six required H2 sections.
Frontmatter requires name, slug, type (phase | pair | lens), and version (semver). Phase agents must have phase_order (1-6, unique). Pair agents must have pair and counterpart, and the counterpart must reference back. All agents must have tags.
Body sections required: ## Belief, ## Method, ## Failure Mode, ## Trigger, ## Operating Instructions, ## Output Shape. Each has minimum-length constraints to prevent stub agents.
The validator catches: malformed frontmatter, missing fields, slug-pattern violations, filename / slug mismatches, duplicate slugs, duplicate phase orders, broken pair references, missing body sections, agents in the wrong directory, and unknown frontmatter fields.
Run python3 scripts/validate.py --verbose any time you change an agent file.
- Drop a new
.mdfile under the right subdirectory (agents/phase/,agents/pairs/<pair-name>/, oragents/lenses/). - Match the frontmatter schema. Match the six required sections.
- Run
python3 scripts/validate.py. Fix what it complains about. - Run
pytest tests/. Should still pass. - Reinstall to your tool of choice.
If you are adding a pair, you must add both halves. The validator refuses one-sided pairs.
pip install -r requirements.txt
pip install pytest
python3 scripts/validate.py --verbose
pytest tests/ -vCI runs on push and pull request against main, on Python 3.10, 3.11, and 3.12. It validates all agents, runs the test suite, and dry-runs both install scripts.
A few decisions worth flagging.
Six sections per agent, not three. Most agent files have a name and instructions and call it done. Creative Agents adds Belief (the worldview), Failure Mode (when not to use), Trigger (when to use), and Output Shape (what to produce). Each of these closes a specific failure mode of vague agent files.
Failure Mode is mandatory. An agent that cannot articulate when it makes things worse is one that will be invoked indiscriminately. The mandatory section forces honesty.
Pairs reference each other in both directions. The validator enforces this. It is a small constraint that prevents a category of human error: editing one half of a pair and forgetting the other.
Lenses, not phases-with-different-names. The lens agents (User, Future-Self, etc.) are deliberately stage-agnostic. They can run anywhere in the cycle. This is structural: some perspectives belong to a moment, some belong to all moments.
No emoji, no buzzwords, no em dashes in the agent files. This is style, not function, but it shows up in the agents' outputs. The agents are supposed to sound like a clear-eyed colleague, not like a chatbot.
Read DISCLAIMER.md before using these agents on real decisions. The short version:
- Experimental. v1.0, not battle-tested at scale. Expect to modify the agents to fit your situation.
- Do your own research. Agent outputs are opinionated suggestions, not professional advice. Treat agent verdicts as prompts for your thinking, not as authority.
- Examples are fictional. The transcripts in
examples/runs/are illustrative compositions. Personas, companies, dollar amounts, and outcomes are made up to show what the agents do when they work well. - No warranty. Provided as-is under MIT. Authors and contributors are not liable for outcomes that result from using the agents.
- Use responsibly. Do not invoke an agent and follow its output without reviewing. Do not feed agents confidential information you would not put in a third-party LLM. Notice when output reads like flattery.
If you fork this and ship it, you are welcome to update the copyright line in LICENSE with your own name or organization. Contributions back to this repo are accepted under MIT.
The work is meant to be a shared toolkit, not a personal brand asset. Link to the repo if you want to credit it.
MIT. See LICENSE and DISCLAIMER.md.