The canonical capture of Andy's Agent Redwood framework, the twelve-component design ritual behind every agentic solution the ecosystem builds. Agent Redwood is a design framework, not an architecture. It is the structured questionnaire you run before you build an agent, so the thing you build is shaped by understanding rather than by a blank canvas and a guess. Source: Andy's 2026-06-19 recording (the Agent Design Pro segment) plus the SuperHarness master brief, where Agent Redwood is the design layer blended through the whole stack. Voice cleaned, Andy's meaning preserved. Agent Redwood is the formula behind SuperHarness and behind every agent the ecosystem ships. Agent Design Pro runs it as its core teaching mechanic. This doc is the framework underneath both.
0. The one-line
Before you build an agent, you design it. Agent Redwood is the twelve-part design interview that turns a vague "I want an agent that does X" into a real specification the build can execute against. Twelve components, in no particular order, each scored for how much it matters to this particular agent, so the design concentrates effort where the value is and stays simple everywhere else.
The twelve are personality, planning, mission, constraints, memory, evaluation, tools, awareness, reward model, metadata, strategy, integrations. Name them, score them, design to the scores. That is the ritual.
1. Why a design ritual exists at all
The market says anyone can build agents now. The reality is a blank canvas and a person who does not know where to start. Agent Redwood is the answer to that gap on the design side: instead of improvising an agent from whatever the model recalls, you run a deliberate interview that drills for the context the build actually needs.
The discipline underneath is Andy's value-first, start-simple posture. You begin from value (make money, save money, or mitigate risk), brainstorm across all three, and narrow by what is worth building. Then you reach for the simplest shape that could work before you reach for complexity, the same policy-first discipline Warren Powell's unified decision framework teaches: most of the time a simple policy is all you need, and you increase complexity only as the value substantiates it. Agent Redwood carries that posture into the design of the agent itself. You score the twelve components, and the scores tell you where a simple treatment is enough and where the agent earns real depth.
2. The twelve components
The list is verbatim from the recording, in the order Andy named them. It is explicitly in no particular order: the sequence carries no ranking. The scoring does the ranking, per agent.
- Personality. How the agent presents and behaves. The voice, the register, the character sheet. Who this agent is when it acts.
- Planning. How the agent decomposes a goal into steps and sequences them. The reasoning-and-ordering machinery.
- Mission. What the agent exists to accomplish. The single directional truth every other component serves.
- Constraints. The boundaries the agent operates inside. What it must not do, the rails, the non-negotiables.
- Memory. What the agent remembers and for how long. Working memory, episodic recall, the persistence model.
- Evaluation. How the agent's output is judged. The rubrics, the checks, the gates that decide whether the work is good.
- Tools. The capabilities the agent can call. The functions, the actions, the things it can actually do in the world.
- Awareness. What the agent knows about its own situation. Context, state, the read on where it is and what is happening around it.
- Reward model. What the agent is optimizing toward. The signal that says this outcome is better than that one.
- Metadata. The structured data about the agent and its work. The tags, the provenance, the record that makes the agent legible and auditable.
- Strategy. The higher-order approach the agent takes. Not the step-by-step plan but the posture: how it chooses which plans to make.
- Integrations. How the agent connects to everything else. The other agents, the systems, the data platforms it plugs into.
3. The scoring ritual: design to the scores
Each of the twelve components is scored for importance at design time, on a simple 1-to-5 scale, for this specific agent. The score is not a grade of quality. It is a statement of how much this component matters to what this agent is being built to do, and it drives the trade-offs the build has to make.
The reason to score rather than to build all twelve to the same depth is the start-simple discipline. An agent whose whole job is a single scheduled lookup does not need an elaborate reward model or a deep memory system, and building one is wasted effort that adds fragility. An agent that runs a long autonomous mission needs memory, evaluation, and awareness scored high, because those are what keep it coherent over a long horizon. The scores let one framework serve both without over-engineering the simple case or under-building the hard one.
So the ritual runs: name the twelve, score each 1 to 5 against this agent's mission and value, then design to the scores. The high-scored components get real depth and real engineering. The low-scored ones get the minimum that works. The result is an agent that is exactly as complex as its job requires, which is the whole point of starting simple and adding complexity only as the value substantiates it.
4. The adjustable-intensity questionnaire
The ritual is run as a questionnaire, and its intensity is a dial. You choose how intensive you want the interview to be, measured either by how many questions you answer or by how much time you are willing to spend. The suggested presets are small, medium, large, and the guidance is to do the large one.
The reason to do the large questionnaire is direct: the more context you give the system, the better the thing it builds for you. Letting the interview drill hard extracts insights that a shallow pass would miss, and those insights are exactly what separate a generic generated agent from one that actually fits the problem. The questionnaire compiles its answers into the agent's specification: the state it tracks, the graph it runs on, the prompts it uses, the tools it calls, and the evaluation machinery that judges it.
Because the ritual is grounded in the ecosystem's real, current knowledge base rather than the model's stale recall, the agent it produces is built on patterns that actually work here. The design interview is plugged into the WikiDesignCo metagraph and the harnesses already built for the relevant technologies, so the output is grounded in the ecosystem's live understanding rather than improvised from scratch.
5. Where Agent Redwood sits in the ecosystem
Agent Redwood is the design formula, and it shows up in two places.
It is the design layer of SuperHarness. The harness runs on a stack (the scaffold, the model, the interface), and Agent Redwood is the framework blended through all of it: the harness design is Agent Redwood layered through the stack, so every agent the harness produces is shaped by the twelve-component ritual rather than assembled ad hoc.
It is the core teaching mechanic of Agent Design Pro, the brand that both builds agents and teaches people to build them. There, Agent Redwood is run as the adjustable questionnaire that walks a learner from a vague intent to a real, grounded agent, so the framework is not only how the ecosystem designs its own agents but how it teaches the design skill to the people who freeze at the blank canvas.
Both uses are the same ritual: name the twelve, score them, design to the scores, grounded in the metagraph. That is Agent Redwood.