Agent Design Pro · Looikos

Project: Agent Design Pro
Looikos cluster: Infrastructure & Agent Platforms (the design layer: where agents are made and where people are taught to make them)
One-line: The graph-based agent-building platform fused with a gamified agent-design school, where the 98% who are not comfortable building agentic workflows learn to think in graphs and design value-first agents, grounded in the Agent Redwood twelve-component framework and Warren Powell's policy-first decision discipline
Status: Concept (depends on the harness, the metagraph, and the design framework it operates on)

1. What it is (the one-paragraph truth)

Agent Design Pro is where agents are made and where people are taught to make them. In Andy's words, it's the brand that does "both build and teach people how to build agents." It's the design layer, separate from the brand where agent tools are made (MCP Scientists) and the one where finished agents are deployed and sold (Agent Shipyard). The product is a graph-based agent builder that runs from no-code to low-code. It takes the node-and-workflow approach ordinary people already half-recognize from n8n, Make, and Zapier and carries it to the next stage, agentic automation, on the insight that a graph is the best way to model an agentic workflow. A node is simply something that happens and updates state, whether it's a function, an agent, an API call, or a user action, and the edges carry the flow. Fused into that builder is a school, designed by people who are video-game engineers, so that diving in feels like a game: simple things are simple, each success earns a reward and provokes the question "what else can I do," and the progression carries the learner from their first result toward real mastery. Its target is precise and large: the 98% of people who aren't intuitively comfortable building agentic workflows. It teaches them how to think rather than only which buttons to click, starting from value (make money, save money, or mitigate risk) and from the simplest decision policy before reaching for complexity. That method is grounded in two frameworks: Warren Powell's unified framework for sequential decisions, and Agent Redwood, Andy's twelve-component design framework, which the product runs as an adjustable questionnaire that drills the user for the context the system needs to build something good. Because it's plugged into the WikiDesignCo Metagraph, a shared knowledge graph, and already carries agent harnesses for the relevant technologies, the agent a learner designs is generated against a real, current knowledge base rather than improvised. For the people it serves, Agent Design Pro is the answer to a specific and widely felt humiliation: the gap between the hype that says anyone can build agents now and the reality of staring at a blank canvas not knowing what a node even is.

Andy's words (verbatim from the recording): "Agent Design Pro is where we both build and teach people how to build agents. So it's something where agents are weird because it's like you take the traditional automation of n8n and make.com and zapier and these various automation tools and you take that to the next logical evolutionary stage and that would be agentic automations. So you take the same node workflow approach... what we found is that a graph is the best way to model agentic workflows. And so you could use Lang Graph, Llama Index has a graph implementation. Pyganic AI, they have a graph implementation. I personally use Lang Graph because that's what I trained on... I love their memory systems, I love the send API. I'm a huge fan of the way that they make it where I don't have to give a shit about what's inside of the node. All that a node is is that something happens inside of it that causes a change in the state... my point is that with Agent Design Pro what we do there is we help teach people how to get an intuitive sense of graph thinking or agent automations. So we take both sides where we teach and we have the platform. And the idea is we take it like a video game where you should be able to dive in, it should be simple enough to do simple things. And then... as you do the simple things, you get a reward and you start to think, well, what else can I do... we're video game engineers so we're going to be masterful in the way we design the user Experience... Agent Design Pro is meant to bridge that gap between the 98% of people that really are just not intuitively comfortable with building agentic workflows and helping to bridge the gap to where they can feel confident in understanding what is their problem that they're facing, the world model surrounding that and the full story... And then to be able to break down how could automations help to make money, save money or mitigate risk? We like to start from there... This is why I love Professor Warren Powell's Unified Decision Framework. Because most people try to start off with a DLA or a VFA when the fact is the vast majority of time all people need is a [PFA]... you want to start off simple... that gets you a general ballpark estimate to let you know if you even barking up the right tree. And then as necessity requires as the value substantiates it, that's when you increase complexity... Agent Design Pro, this is where we leverage Agent Redwood, what I call our design framework. It's a 12 component system... personality, planning, mission constraints, memory, evaluation, tools, awareness, reward model, metadata, strategy integrations... we take this and we go through a questionnaire and you can dial in how intensive you want the questionnaire to be... let the system drill the hell out of you, extract a bunch of insights because the more context you can give the system the better it's going to make something for you... the system is plugged into the Metagraph data platform Wiki design company and it already has agent harnesses for all these technologies."

Reading between the lines: Andy's seed compresses five claims, each load-bearing.

First, the dual nature, "both build and teach," is the brand's defining structure and its defensibility. The market has builders that expose a tool and educators that teach concepts, and almost nobody fuses the two so that learning and building are the same activity in the same environment. Andy's instinct to take both sides is the instinct to own the fusion the market leaves unbuilt.

Second, the graph-as-the-right-model claim is the technical thesis, and it's precise. Andy's definition of a node ("something happens inside that causes a change in the state," whether a Python function, a PydanticAI agent, a Hermes agent, an API call, or a user action) is exactly the LangGraph model, where the application is a stateful directed graph, a node updates a typed state object, edges and conditional edges route on state, the Send API fans out, and checkpointing persists. The teaching payoff is large: it gives the non-coder a single legible mental model, the evolving state and the transitions over it, instead of a pile of disconnected wires, which is the thing the visual builders hide and the thing a learner copying nodes without understanding them most needs to see.

Third, the video-game framing is a teaching method grounded in what makes technical education work, not a marketing flourish. The principles Andy names (simple things are simple, each success earns a reward and provokes the next question, the team are video-game engineers who will design the UX masterfully, with guide modes and interactive in-product guidance) line up with the research on effective gamification: meaningful goals with immediate feedback, mastery-based progression up a skill tree, self-determination (autonomy, competence, relatedness), light narrative identity, and learning by modifying and running real artifacts rather than passive quizzes. Gamification comes in two kinds, shallow badges and the real thing, and Andy is describing the real thing: progression tied to competence and to building real agents.

Fourth, the value-first methodology plus the Powell discipline is the intellectual spine that separates Agent Design Pro from every tool tutorial. Andy teaches people to start from value (make money, save money, or mitigate risk), brainstorm across all three, and narrow by value, then to think in the simplest decision shapes first. His invocation of Warren Powell's unified framework for sequential decisions (the four policy classes, policy-function-approximation and cost-function-approximation and value-function-approximation and direct-lookahead, with the principle of starting with the simplest policy class that could work before escalating) is a sound and rigorous pedagogical spine. Almost no builder or course embeds a research-grounded decision framework; they teach LLM-plus-tools-plus-prompt-plus-retry. That depth is what turns "drag some nodes and pray" into a transferable cognitive skill.

Fifth, Agent Redwood as a twelve-component structured questionnaire that drives generation is a proven pattern with real analogues. The twelve components (personality, planning, mission, constraints, memory, evaluation, tools, awareness, reward model, metadata, strategy, integrations) form a specification schema for an agent, and structured-elicitation-to-generation is sound: it is the same pattern as spec-driven development and API-first design (OpenAPI specs elicited by form, then generating stubs and SDKs and tests) and questionnaire-driven codegen. Andy's adjustable-intensity questionnaire ("dial in how intensive, let the system drill the hell out of you, the more context the better it makes something") is the design-interview that compiles the answers into the agent's state schema, graph template, prompts, tools, and evaluation machinery. And because the Metagraph behind it already has harnesses built for the relevant technologies, the generation is grounded in a real current knowledge base rather than the model's stale recall, which is the difference between a generic generated agent and one built on the ecosystem's actual patterns.

3. The three-angle valuation (the core of a self-standing brand)

Like every Looikos brand, Agent Design Pro is valued on three angles (finance, software, and service), and it's the one brand in the family whose finance angle reaches higher valuation multiples than pure infrastructure, because it braids a prosumer SaaS builder with a gamified education product, and gamified-engagement businesses earn a premium the capital markets pay explicitly. Its software angle is a build-plus-learn platform, and its service angle is the enterprise AI academy that anchors the blended multiple.

3a. Finance (credit and capital access)

The corporate-finance read draws on two adjacent sets of comparable companies (comps). On the builder side, the no-code and AI-agent platforms: Zapier at roughly $5-7B against an estimated $350-450M ARR, an 11-18x ARR band; Retool at $2.5-4B; Bubble's $1B unicorn round; n8n in the mid-stage open-source band at 8-15x ARR; Make embedded in Celonis after its acquisition. The Finro Q1-2026 AI-agent comps anchor the live multiples: best-in-class agent platforms that own recurring workflows trade at 10-18x ARR with strong growth, mid-tier at 5-9x, and pure tooling without workflow lock-in at 3-7x. On the education side, the decisive comp is Duolingo, the gamification premium made legible: it trades at roughly 8-14x forward revenue against Coursera's 3-5x and Udemy's 1.5-3x, on the strength of consumer-app metrics (a high ratio of daily to monthly active users, or DAU/MAU, plus retention and streaks) that investors price as an engagement-and-gamification moat rather than as edtech. The edtech M&A comps confirm strategic buyers pay double-digit revenue multiples for skills-based brands: Pluralsight's $3.5B take-private at 8-9x revenue, Codecademy's $525M acquisition at 10-15x revenue.

For Agent Design Pro itself, the valuation is a blend, because its revenue segments earn different multiples: the builder SaaS at the Zapier-Retool band (8-15x ARR if growth and NRR are strong), the enterprise academy at the Coursera-B2B and Pluralsight band (4-8x revenue, sticky multi-year), the consumer learning subscriptions at the edtech band (2-5x), and any cohort revenue at the lowest band (2x, lumpy). The fusion creates upside above the sum: when learning and building are the same activity in the same environment, the Duolingo gameplay-to-monetization loop applies to agent skills, and the workflow ownership that AI-agent investors prize most layers on top, so investors may tilt the blended multiple toward the Duolingo-plus-Zapier end (roughly 9-15x blended revenue) rather than the generic-edtech end (3-6x). The engagement premium is worth 2-4x on the revenue multiple if the consumer-app metrics are there, which is why the video-game-engineer UX is a finance decision as much as a product one.

That blend also sets how the brand gets credit and capital. The recurring builder and education subscriptions plus the multi-year enterprise academy contracts are the credit-bearing base, underwritten like SaaS (revenue-based financing at 0.3-1.0x ARR repaid as a percentage of monthly revenue, requiring greater than 70% gross margin and low churn). Prepaid cohort revenue improves cash conversion and can underpin a larger facility. And the distinctive lever here is that the gamified-engagement metrics (consistent DAU, high retention) de-risk the cash flows directly: they support lower churn assumptions and higher LTV, which lets a lender underwrite a higher advance rate and an equity investor accept a higher multiple. There's even an optional credentialing-and-income-share extension (packaging future cash flows from successful learners), though that's a later-stage option, not a base-case assumption. The accumulated proprietary state an acquirer pays for is the structured telemetry on skills and workflows: what each user can do, what they built, what outcomes it delivered, which feeds the personalization, the credentialing, and the pattern library, and which a competitor can't clone.

A market maker would read it on three levels. On fundamentals, it's a fused build-plus-learn platform with a defensible pedagogy and a real decision framework, in two large and growing markets. On technicals, the supply of products that fuse building and teaching is near zero (the builders teach the tool, the educators teach concepts), against a demand of millions of intimidated would-be builders, which is a favorable order book. On sentiment, the "anyone can build agents" narrative is loud and the reskilling wave is well funded, with the named risk that a builder bolts on shallow tutorials or an educator bolts on a thin builder; the hedge is the depth (the Powell-grounded curriculum, the Agent Redwood elicitation, the metagraph pattern library) that a bolt-on can't replicate.

3b. Software (the interface stack)

Agent Design Pro's software is a graph-based visual builder fused with a gamified learning layer, and each piece maps onto a documented 2026 architecture.

The builder is a visual layer compiled to LangGraph. The core move is to expose the global state as a first-class entity (a State Designer where the user defines typed fields and marks some as persistent memory, compiling to a Pydantic or TypedDict state), map node types to LangGraph nodes (LLM node, tool node, user node, control node, each carrying which state fields it reads and writes), compile the visual graph from JSON into a LangGraph StateGraph, expose conditional edges as conditions on state (a simple dropdown mode and an advanced restricted-expression mode, both compiling to add_conditional_edges), surface fan-out and multi-agent via parallel and agent nodes (compiling to the Send API and subgraphs), and make checkpointing and replay toggles on nodes. The gap this closes is the one the existing visual builders leave open: they hide the global evolving state and show only local wires, so the user never builds a mental model; making the state legible is the pedagogical difference.

The model layer underneath belongs to the harness (LangGraph nodes can wrap a function, a PydanticAI agent, a Hermes agent, an API call, or a user action, as Andy describes), so Agent Design Pro runs on Symphony AGI, the agent harness the Looikos brands share.

The learning layer is the gamification-that-works pattern: a skill tree of agent-design competencies with mastery-based progression (you advance only when you demonstrate competence, and errors route to targeted review), in-product learning where the tutorials are real LangGraph graphs the learner edits and runs (the write-run-see loop that accelerates learning over video), project-based quests with concrete success criteria, and light narrative identity (progressing as an agent architect, unlocking the components of the framework). The progression is mapped onto the Powell policy classes as difficulty tiers: level one is a simple policy-function-approximation agent (one or two nodes, simple routing), level two adds cost-function-approximation (a generator-then-evaluator-then-choose pattern), level three adds value-function-approximation (a value estimate in the state), level four adds direct-lookahead (planning subgraphs), so the curriculum is the applied tutorial of the decision framework.

The Agent Redwood elicitation is the third software surface: the twelve components as a structured questionnaire (the design interview) that compiles answers into the agent's state schema, graph template, prompts, tools, and evaluation nodes, with an interactive refinement loop where running the agent and adjusting answers regenerates only the affected parts. The product surfaces and monetization decompose cleanly: the builder is the prosumer-and-SMB SaaS (subscription per seat and tier); the learning is the consumer education subscription; the enterprise academy is the B2B contract; the agents a learner builds deploy onto Agent Shipyard and use tools from MCP Scientists; and the whole thing is plugged into the WikiDesignCo Metagraph so the pattern library and the generation are grounded in the ecosystem's real, current knowledge. The architectural signature is the dual teach-mode and build-mode: in teach mode every node and edge carries definitions and analogies and a "show theory" overlay revealing how the current graph instantiates state and policy and reward; in build mode the overlays hide and the user ships, but the evaluation and metrics still respect the twelve-component framework. Builders and educators each lack that dual mode on their own.

3c. Service (premium-at-accessible boutique delivery)

The service angle is the enterprise AI academy, and it's the segment that anchors the blended multiple because it's sticky, multi-year, and high-NRR. The target operator is the company, from the sub-25-employee shop up to the mid-market, that has been told to adopt AI across the org and has staff who can't code and can't start. The Looikos model of premium quality at accessible prices is delivered through the fused platform: instead of buying Coursera licenses plus a separate Make subscription plus a consultant to teach AI and then leaving staff to improvise, the company gets one environment where employees learn and build internal agents, and where L&D can track both the learning progress and the business impact (hours saved, errors reduced, revenue from automations).

The retainer economics follow the ecosystem standard plus the academy structure: $1-2k accessible at the individual and small-team entry, $2-12k+ for the real engagements, with enterprise academy contracts running larger and multi-year (the corporate AI-training budgets run roughly $0.5-3M per large enterprise over two-to-three years, and academy revenue with high NRR trades closer to B2B SaaS than to classic edtech). The 100-250-customer target floors the broader service angle around $1M/month and scales above. The trust differentiator answers the buyer's deepest fear, which the Lexicon of Pain (Andy's term for the words buyers use about their pain) surfaces as the dread of being an impostor and being left behind. Instead of handing staff a blank canvas and a "drag and drop AI agents in minutes" promise, the academy walks them from their first result through real mastery with the pedagogy and the framework built in, so the company gets people who can design agents rather than people who watched ten hours of videos and still can't build the thing they need. The long-tail academy delivery and the ongoing learner support go to the affiliate network the Looikos brands share. That work runs on the shared-floor model, where rotating senior people and agents work from one shared record, and the senior talent comes from emerging markets, working through the Looikos tools on a franchise-style path to ownership. The prosumer-to-enterprise ladder is the flywheel: individual learners become builders, top builders become the internal champions who pull their company onto an enterprise academy contract, which drives the logo expansion and the NRR that the valuation rewards.

4. The personas (5+, modeled to world-experience depth)

The language here is pulled from the actual Lexicon of Pain mined in the voice-of-customer research (the second research query). The texture of this pain is intimidation and impostor shame more than technical failure, the specific humiliation of being told something is easy and finding it impossible, and the fear of being left behind in the AI wave, which is the deepest emotion in this market and the one the brand must speak to directly.

Persona 1: The locked-out business owner

I'm a small business owner who keeps hearing that automation will transform my business, and every time I open one of these tools "it's just boxes and arrows and jargon, I have no idea what I'm looking at." "Every video is like it's super simple and then the first thing they say is just use a webhook like I'm supposed to know what that is." "I've watched like 10 hours of n8n tutorials and I still don't know how to build the one workflow I actually need." "Half the tutorials start with assuming you already have your API keys and environment set up, I don't, that's the part I'm stuck on." I'm not a programmer, "I just want this crap to work," and "why is no-code still 90% code terms and dev brain?"

All of this hits me in a place I don't admit easily. "People keep saying this is idiot-proof which just makes me feel like the idiot." "It's like I missed the boat, I was busy running my business and suddenly AI is everything and I don't speak the language." "My younger staff mess around with these tools for fun and I'm here struggling to connect a form to a spreadsheet," and "I'm scared I'm going to look like a dinosaur to my team." Underneath is the real fear: "if I don't figure this out, my competitors will, and we're dead," and "I've been good at what I do for years, but for the first time I feel like that doesn't matter anymore if I can't do AI." I got here because I was running a real business while the wave arrived, and the tools were built for developers. What I need is someone who starts me where I actually am, with simple things that are simple, and walks me to a real result, teaching me the concepts along with the buttons. Most people in my seat give up, because the tutorials assume too much and the blank canvas is intimidating. Staying stuck puts me on the wrong side of history, and getting out means admitting I need to be taught, not just handed a tool.

Agent Design Pro gives me the on-ramp the tools refuse to build: a start as simple as a video game's, where the first thing works, and a system that teaches me to think instead of assuming I already know what a node is.

Persona 2: The cargo-cult learner with a mess they don't understand

I'm someone who actually built something, and it's held together with hope. "I Frankensteined together an automation from 3 different YouTube videos and now I'm terrified to touch anything because it might break." "It works, until it doesn't, then I just delete the whole thing and start over because I have no idea how to debug it." "I can't tell you why it works, I just copied what someone did and changed the names." "My workflows look like spaghetti, if one thing fails I have no clue which node is responsible." "Templates are useless if you don't understand the logic behind them," and "everything feels like a black box, if it breaks the only solution people give is check the logs which is just more gibberish." "I'm basically cargo-culting nodes and hoping for the best." "I know enough to be dangerous but not enough to feel safe."

The whole setup leaves me with a quiet, constant anxiety. "I'm scared my whole business is now depending on something I cobbled together and don't understand," and "I feel like a fraud when I talk about automation because inside I know it's duct tape and prayers." I got here because the only way to learn on offer was copying templates, and copying a template without the mental model leaves you with something you can't reason about. I need to understand the thing I'm building: what the state is, how it changes, why a branch goes one way or the other, so when it breaks I can see which node is responsible and fix it. Most learners like me stay stuck because every resource hands them another template instead of the mental model, and the mess compounds. Staying put means living with the duct tape and the dread of touching it; the price of getting out is learning the model instead of copying the nodes.

Agent Design Pro gives me the mental model the templates never did: the state made visible, the transitions explained, and a teach mode that shows me why my graph does what it does, so a break becomes a thing I can find and fix instead of a thing I delete and restart.

Persona 3: The value-paralyzed builder making cool useless things

I'm someone who can build a little now and freezes on what to build. "I know I should be automating, but I stare at my business and have no idea what to start with." "Every day I'm like, do I automate leads, customer support, bookkeeping, content, my brain just short-circuits and I do nothing." "I keep building cool automations that don't really move the needle, because they're easier than tackling the messy core problems." "I built an AI agent that writes motivational quotes for my team, meanwhile I'm still manually sending invoices." "I can't tell the difference between this would be fun and this would actually make money or save time." "I'm scared to invest a week building something and then realize it doesn't really help the business."

Freezing like that turns into a guilt that compounds the paralysis. "I'm scared of wasting time on automation theater that looks fancy but doesn't move revenue," and "I don't trust myself to pick the right thing to automate, so I just don't start." What I'm asking for is explicit: "I don't need more tool tutorials, I need someone to tell me, for a business like yours, automate this first," and "I want to understand the concepts, not just be told drag this here and that there." I got here because the tutorials teach building, not choosing, and choosing by value is the harder and more important skill. The way out is a method that starts from value (will this make money, save money, or reduce risk), brainstorms across all three, and narrows by what's actually worth it, and I need to start with the simplest version that tells me whether I'm even barking up the right tree before I invest in complexity. Most builders like me default to the fun build, because no resource teaches us to prioritize by value. Staying stuck costs me automation theater and wasted weeks, and getting out costs me learning to choose by value before learning to build more.

Agent Design Pro teaches the value-first method I keep asking for, simplest policy first, so I stop building motivational-quote bots while the invoices pile up.

Persona 4: The professional with impostor syndrome, afraid of being left behind

I'm a capable professional who feels, for the first time, like I'm falling behind. "Everyone on here acts like this stuff is so easy and I feel like the only idiot who doesn't get it." "I keep seeing I built this in an afternoon posts while I've been stuck on the same error for three days." "Honestly it's humiliating to ask what a node is when people are posting these insane AI agent diagrams." "The vibe is if you're not building agents you're already obsolete, and I'm like, I just learned what an API is last week." "I feel like I showed up to the exam and everyone else got the study guide but me." "The marketing says drag and drop AI agents in minutes but then you open it and it's a blank screen with no clue what to do next."

Falling behind hits my identity directly. "I used to be the smart one in my circle, now I feel like the old person who needs everything explained twice." "Admitting I don't understand this stuff out loud feels like admitting I've failed." And the fear is existential: "I'm genuinely afraid that if I don't figure this AI stuff out in the next year, I'm going to be unemployable," "it feels like there's a train leaving the station and I'm still on the platform reading the map," "I built my career on knowing my industry, and now it feels like none of that matters if I can't speak AI." I got here because the hype set an expectation of effortlessness that the reality of a blank canvas violently contradicts, and the gap registers as personal failure. I need a place to learn that meets me without judgment, makes the first step small and successful, explains rather than assumes, and rebuilds my confidence by showing me real competence growing. Most professionals like me stall because the communities are intimidating and the resources assume the study guide I never got. If I stay stuck, I keep the impostor dread and the fear of obsolescence; getting out takes letting myself be a beginner in a place built for beginners.

Agent Design Pro is that place, a gamified path built for where I am, with a progression that lets me feel my competence grow, so the train I'm afraid of becomes one I can actually board.

Persona 5: The enterprise L&D leader rolling out an AI mandate to non-technical staff

I'm the learning-and-development (L&D) leader at a company where the executives mandated AI adoption across the org, and now I have to make thousands of non-technical employees capable of using and building agents. My current options are bad: buy a stack of Coursera licenses that teach concepts but leave people with nowhere to build, plus a separate automation tool they won't understand, plus consultants who teach a workshop and leave staff to improvise in random tools. The result is staff who watched the training and still can't build anything, and I can't show the executives any business impact because the learning and the building live in different places and neither is instrumented.

I'm the person accountable for whether the mandate produces capability or just completion certificates. The fear is concrete: spending a large budget on training that doesn't transfer, and being asked for the ROI of the AI-upskilling program and having nothing but course-completion rates to show. I got here because the market sells education and tooling separately, so the learning never becomes building and the building is never measured. What I need is one environment where employees learn and build internal agents in the same place, where I can track both the learning progression and the business impact (hours saved, errors reduced, automations deployed), and where the curriculum is grounded in a real framework so people learn a transferable skill rather than a tool's buttons. Most L&D leaders in my seat buy the separate pieces and hope they connect. Staying stuck leaves me a program that produces certificates and no capability, and getting out means consolidating onto a build-plus-learn platform with a real academy.

Agent Design Pro is the enterprise academy the separate pieces can't be, so I can prove the mandate produced people who can actually design agents.

5. The world model (run the PST framework)

Echolocate the world. The setting is the 2026 moment when the message "use AI or fall behind" is universal and the ability to act on it is rare: every large organization has the mandate, and only a small single-digit percentage of people can code, so a vast population is expected to build agentic workflows and can't. Read institutionally, two large markets are converging here, the no-code agent-builder market (low-to-mid single-digit billions inside a much larger low-code-and-automation market) and the AI-upskilling market (high-single-to-low-double-digit billions across corporate training, platform learning, and cohort courses), both growing fast, both structurally split between tools and education. In the ecosystem's metagraph, Agent Design Pro is the node where ordinary people enter the ecosystem's agent-building capability, so its customer is the would-be builder and, at scale, the enterprise that needs its whole workforce to become builders. Echolocating the learner means seeing that the public conversation is "anyone can build agents now" and the private reality is millions of people staring at a blank canvas feeling stupid.

Locate the Problem. The learner is stuck in a loop that runs from intimidation to impostor shame to avoidance, and it's unusually acute because the hype directly contradicts the experience. The pain is concrete: the tools are overwhelming, the tutorials assume too much, the templates are black boxes, the canvas is blank, and the learner can't tell what is worth building. The fears underneath are specific and heavy: the business owner's fear of being on the wrong side of history and dead to competitors, the cargo-cult learner's fear that the business now depends on duct tape they don't understand, the value-paralyzed builder's fear of wasting weeks on automation theater, the professional's fear of being unemployable within a year and watching the train leave, the L&D leader's fear of a budget spent on training that doesn't transfer. The shame is the sharpest of them: "people keep saying this is idiot-proof which just makes me feel like the idiot," "it's humiliating to ask what a node is," "I used to be the smart one and now I feel like the old person who needs everything explained twice," "admitting I don't understand feels like admitting I've failed." The red line, where accountability lives, is the moment a person stops treating the difficulty as proof of their inadequacy and recognizes it as proof that the tools were built for developers and never taught the mental model. Most of this market lives below that line, in the loop, which is why the content must speak to the intimidation and the impostor dread directly and gently.

Reconstruct the Story. The belief structure that built this suffering starts from a true and load-bearing self-concept: "I am capable, I am the smart one, I can learn things." The hype then bent it: "anyone can build agents now" set an expectation of effortlessness, so the first encounter with a blank canvas and a webhook registered as "I am the one who cannot do the easy thing" instead of "this was built for developers." Each humiliating tutorial and each spaghetti workflow deposited another layer of impostor feeling, and because the social environment broadcasts "I built this in an afternoon," the shame had nowhere to go but inward. The origin of the mess is a market that sold the capability as effortless while building the tools for coders and teaching the buttons instead of the model, so each failed attempt was a reasonable response to a badly designed on-ramp. Under that sits the identity layer: a competent professional whose self-worth rests on being capable and current is failing at the thing the whole culture says is easy and necessary, and is performing either confidence or avoidance about it, and the performance is exhausting and the fear of obsolescence is real. The story each tells is "everyone else gets this and I am the exception," and that story is the trap, because the truth is the opposite: the difficulty is near-universal and the tooling, not the learner, is the failure.

Design the Transformation. The bridge has courage as its hinge, and the courageous act is small and specific: letting yourself be a beginner in a place actually built for beginners, instead of pretending or avoiding. From courage flows truth: the tools were built for developers, the difficulty is near-universal, and not understanding a node isn't a personal failing. From truth flows responsibility: choosing to learn the mental model and the value-first method rather than copying another template or doom-scrolling another demo. From responsibility flows healing: the first step is small and it works, the state becomes legible, the value-first method tells you what to build, the competence grows visibly, and the impostor dread is replaced by actual capability. From healing flows forgiveness of the earlier self who felt stupid, who wasn't stupid, who was handed a developer's tool and a lie about how easy it would be. The transformation is crossable because the entire product is designed as a calibrated bridge: video-game-simple at the start, mastery-based progression, a teach mode that explains, a value-first method that removes the paralysis, and a real framework underneath so the skill transfers. For the intimidated would-be builder, the brand proves it understands the impostor shame and the fear of being left behind better than the learner says it aloud, and that recognition, offered without judgment, is what earns the right to walk them across.

6. Competitive and market read (the alpha / third door)

The competitive field is two non-overlapping camps, and the gap between them is the opening. The agent builders each optimize for one thing: time-to-first-agent (Arahi, Lindy, Tars, Dify, Flowise, Langflow), depth for developers (n8n, LangGraph, LlamaIndex, PydanticAI, Retool), or breadth of automations (Make, Power Automate, Zapier), and none is primarily optimized to teach the 98% to think in and design agent graphs in a gamified, value-first way while they build. The education players each teach concepts or buttons: the platforms (Coursera, DeepLearning.AI, Udemy) teach AI literacy and technical tracks but won't host your agents or be a builder, the cohort courses (Maven) teach in sessions without a persistent build environment, the interactive coding platforms (Scrimba) teach code not no-code agent design, and the corporate L&D vendors teach vendor-agnostic workshops without a unified build-and-deploy platform. Education players teach tools and literacy; builders expose the tool; neither fuses them so that learning and building are the same activity.

The alpha, in the spirit of Andy's idea of a third door, is a graph-native agent builder and a gamified, pedagogy-first, value-first agent-design school in one environment. The existing players skip five specific things, and together those five are the alpha: they don't teach the mental model (they expose the tool), they don't embed a serious decision framework (Powell's policy-first unified framework is absent; agent behavior is LLM-plus-tools-plus-prompt-plus-retry), they don't link design decisions to economic value at design time (they market "save time" but don't ask the builder to define money saved or earned or risk reduced and instrument it), they don't gamify mastery of agent design (any gamification is shallow badges, not progression that unlocks real patterns tied to value-grounded scenarios), and they don't embed a knowledge graph of patterns (templates are flat lists, not a related, mined library of agent patterns). Agent Design Pro assembles all five, which is the combination the two camps decline to build because a builder's business is the tool and an educator's business is the content, and fusing them into a pedagogically-opinionated, value-first, gamified, knowledge-graph-backed platform is a harder and different business than either runs.

On a Wardley map, which plots each component's evolution from genesis through custom-built and product to commodity, the visual agent builder itself is heading to commodity: Flowise, Langflow, and the platform builders are converging, and a competent visual layer over a graph framework is becoming table stakes, which is why Agent Design Pro adopts LangGraph and the visual-builder primitives rather than competing on the canvas. The fusion of build-and-teach, the Powell-grounded curriculum, and the value-first method sit at custom-built heading toward product, and are worth owning because they're the pedagogy the market doesn't deliver. The gamified mastery progression tied to real value-grounded scenarios and the metagraph-backed pattern library sit in genesis: nobody is mining what users build to teach new users, nobody is running a knowledge graph of agent patterns as the world-map of the learning environment, and that's the lane to own hardest because it's genesis-stage, it has data-and-network effects (more builders means more patterns means better teaching), and it accumulates the skills-and-workflow telemetry moat a competitor can't clone. So the strategy reads: adopt the commoditizing builder primitives, own the build-plus-teach fusion and the Powell-grounded value-first curriculum and the metagraph pattern library, and make the brand's signature being the place that teaches the mental model, not just the tool.

The market is two large converging markets (no-code agent building and AI upskilling), both growing fast, with the demand signal amplified by the universal mandate and the small fraction who can act on it. The precise carve-out for the fused build-plus-teach niche is not separately sized, but the demand is unmistakable in both the market figures and the Lexicon of Pain: millions of people under a mandate to build agents, intimidated and ashamed and asking explicitly for the mental model and a value-first roadmap, is a market with enormous latent demand for the one product that meets them where they are.

7. The build (what this brand needs, where Track R feeds Track P)

Agent Design Pro's build is well-specified because the three pillars (the LangGraph visual layer, the Powell pedagogy, the gamified-learning patterns) are documented. The open-source repo research feeds this build through two of its clusters, reasoning and orchestration: the decision-framework and graph-workflow harvests feed the builder and the curriculum.

The builder is built as a visual layer compiled to LangGraph, adopted not reinvented: the State Designer compiling to typed Pydantic state, the node-type mapping to LangGraph nodes, the JSON-to-StateGraph compiler, the conditional-edge UI compiling to add_conditional_edges, the parallel and agent nodes compiling to the Send API and subgraphs, and the checkpoint-and-replay toggles. The curriculum is built on the Powell policy-class progression (PFA to CFA to VFA to DLA as difficulty tiers) and the gamification-that-works principles (mastery-based skill tree, in-product learning on real graphs, project-based quests, light narrative identity). The Agent Redwood elicitation is built as the structured-questionnaire-to-generation pattern (the design interview compiling to state schema, graph template, prompts, tools, and evaluation nodes, with partial regeneration on refinement), the proven spec-driven-development analogue. Building LangGraph or the gamification engine from scratch would be the anti-pattern; the leverage is in the fusion, the curriculum, the elicitation, and the pattern library.

The data models follow Scatter Model's schema, an entity-component-system (ECS) layout written as typed Pydantic models, which here types the core entities: the agent design (its twelve-component spec, its graph, its state schema), the learner (skill profile, progression, mastery state), the lesson and quest (objectives, success criteria), and the pattern (a reusable agent design with its graph-level explanation and its relationships to other patterns). The pattern library accumulates in medallion tiers, the data-engineering pattern of successively refined stages: a freshly-built learner agent enters at bronze, a proven and reused pattern rises through silver and gold, and the diamond tier is the canonical, widely-taught patterns that anchor the curriculum and the knowledge-graph world-map.

As the software angle set out, the Metagraph grounds the generation and the pattern library, and the agents a learner builds run on Symphony AGI, deploy onto Agent Shipyard, and use tools from MCP Scientists. Of the open-source repo research, the harvests that serve it most sit in the reasoning cluster, whose decision-framework, optimization, and graph-workflow harvests feed the Powell curriculum and the builder semantics, and in the orchestration cluster, whose multi-agent harvests feed the advanced multi-agent modules. One item is still open: the exact repo-by-repo harvest list has to be checked against the summaries of those research clusters as they land.

8. Priority read (feeds the value rubric)

Agent Design Pro sits on top of the substrate (it needs Symphony AGI to run the agents, Scatter Model's typed schema to type the designs, MCP Scientists for the tools, Agent Shipyard for deployment, and the WikiDesignCo Metagraph for the grounded knowledge), so its readiness depends on those being in place. But it has a distinctive strategic property: it's the brand most directly tied to the ecosystem's external growth and revenue, because it's a customer-facing product and a customer-acquisition engine in its own right, and it's the brand that makes the rest of the ecosystem's agent-building capability accessible to the market rather than internal to Andy.

On the value rubric's launch tiers, the first-pass instinct is Next, with a strong case for an early slice of Next because of its revenue and growth potential. The substrate must exist first (the builder needs a harness to run on, the pattern library needs the metagraph), so the full platform is gated. But the education-and-academy revenue can begin earlier and more cheaply than the full gamified builder, because the curriculum and the value-first method and the Agent Redwood elicitation are teachable before the entire video-game UX is built, and the enterprise academy is the highest-value, stickiest segment.

So the priority read is Next: build the builder on the substrate while standing up the curriculum-and-academy revenue early, then layer in the gamified progression and the pattern library as the metagraph fills. The internal sequence within Agent Design Pro is curriculum-and-framework first (cheap, teachable, the academy revenue), then the LangGraph visual builder (the platform), then the gamified mastery and the metagraph pattern library (the genesis-stage moat that compounds). Every brand still gets weighed against the others on the value rubric, and this deck's grounded read is that Agent Design Pro is a high-value Next with an unusually strong revenue-and-growth profile (the Duolingo-style engagement premium plus the enterprise academy's stickiness), gated on the substrate but partly freed from that gate by the early academy. The gamification claim also goes through the seven-sins gate, Andy's check of a claim against seven classic failure modes of judgment, from look-ahead bias to overfitting. Its answer: the pedagogy and the builder are buildable on documented primitives, but the Duolingo-style engagement that justifies the premium multiple must be demonstrated with real DAU and retention, not assumed, so the engagement metrics are the thing the build must prove.