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. It has twelve components, in no particular order, and each is 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. The ritual is to name them, score them, and design to the scores.
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 doesn't know where to start. Agent Redwood answers 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 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's 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's explicitly in no particular order, so the sequence carries no ranking; the scoring does the ranking, per agent.
- Personality. This is how the agent presents and behaves: its voice, its register (how formal or casual it sounds), its character sheet, and who it is when it acts.
- Planning. Planning covers how the agent decomposes a goal into steps and sequences them, the machinery that does its reasoning and ordering.
- Mission. The mission is what the agent exists to accomplish, the single directional truth every other component serves.
- Constraints. These are the boundaries the agent operates inside: what it must not do, its rails, its non-negotiables.
- Memory. Memory is what the agent remembers and for how long, covering working memory, episodic recall, and the persistence model.
- Evaluation. This is how the agent's output is judged, through the rubrics, checks, and gates that decide whether the work is good.
- Tools. Tools are the capabilities the agent can call: the functions, the actions, the things it can do in the world.
- Awareness. Awareness is what the agent knows about its situation: its context, its state, and its read on where it is and what's happening around it.
- Reward model. This is what the agent is optimizing toward, the signal that says this outcome is better than that one.
- Metadata. Metadata is the structured data about the agent and its work: the tags, the provenance, and the record that makes the agent legible and auditable.
- Strategy. Strategy is the higher-order approach the agent takes, one level above the step-by-step plan: its posture, meaning how it chooses which plans to make.
- Integrations. This is how the agent connects to everything else: the other agents, the systems, and 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 states how much this component matters to what this agent is being built to do, not how good the component is, 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 doesn't 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.
In practice, each of the twelve gets a score from 1 to 5 against this agent's mission and value, and the design follows 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 the start-simple posture.
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're willing to spend. The suggested presets are small, medium, large, and the guidance is to do the large one.
The large questionnaire is the one to do because 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 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 work here. The design interview is plugged into the WikiDesignCo metagraph (the data platform the ecosystem's content and intelligence run on) 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's 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, so every agent the harness produces is shaped by the twelve-component ritual rather than assembled ad hoc.
It's 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 how the ecosystem designs its agents and also how it teaches the design skill to the people who freeze at the blank canvas.
In both places Agent Redwood is the same ritual of naming the twelve, scoring them, and designing to the scores, grounded in the metagraph.