For twelve months we tried to design with AI the way everyone else was: prompt, copy, paste, retry. It worked for blog posts. It broke for everything that required structure, memory, and human judgment in the middle of the process.
The conversation scrolled away. Methods we'd practised for years didn't fit into a text box. The model's reasoning was invisible. Our outputs were good prose and bad product.
Plooi is what we built instead. A canvas where research, methods, and AI agents are objects you arrange, not turns you take. Where every method shows its working, every workflow keeps a human in the loop, and the graph itself becomes the artefact you ship.
This page is the long answer — the philosophy, the architecture, the trade-offs, the methods, the people we built it for. If the overview made you curious, you're in the right room.
The canvas zooms semantically. Pull back for the whole shape of the work; lean in for one cluster of methods; lean further to read a single method's prompt. Same surface, three levels of detail.
Whole-workflow shape. You read the topology — branches, fan-outs, dead-ends — without reading any labels.
Cluster scale. Names visible. You decide which branch to dive into.
Inside a single method — prompt, model, confidence, output. Full glass-box.
Plooi is built on three principles we refuse to compromise on. None of them are about AI doing more — all three are about you doing more with AI, on a surface your brain was actually built for.
You make it well
We refuse the boilerplate AI-generated soup. Every method in Plooi was hand-built from research literature, tested with practitioners, tuned to support thinking — not replace it.
You see every step
Every fold is visible. Every transformation is auditable. No black-box outputs — you can trace any insight back through the methods that produced it. Glass-box reasoning, not magic.
You decide what stays
AI proposes; you decide. Plooi generates variations, alternatives, refinements — and waits for your call on which to keep. Human-in-the-loop is non-negotiable.
Folding is the metaphor; methods and connections are the mechanism. Each fold adds discipline; each connection adds a path your insight can travel down.
Drop your brief, your research dump, or your half-finished spreadsheet. Plooi reads it and suggests methods — empathy work for users, JTBD for unmet needs, Simulation for service flows.
Drop in an Empathy Map. Or Jobs-to-be-Done. Each method is a self-contained agent — feed it inputs, get structured outputs you can keep building on.
Pleat findings into a Synthesizer. Pleat the synthesis into a Critic. Plooi handles the data passing; you watch the structure emerge.
A Plooi is a reusable workflow — sheet music for research. Run the same stack on a new brief; the structure stays, only the inputs change.
These aren't tutorials — they're the canvases real teams use Plooi for, every week. Each is a starter template you can fork and remix.
Drop your screens in. A Persona agent walks the flow exactly as the user would. A Heuristics agent flags violations. You get a ranked friction list — and never debate 'is this a problem?' in the design crit again.
Customer Journey → Service Blueprint → branch into Happy / Unhappy paths → run a Simulator agent over each. The blueprint is no longer a static deliverable — it iterates with your data.
Brief → "How Might We" reframes → Splitter fans out 5 strategy directions in parallel → Storyboard methods render each → a Critic agent ranks them against your brand guidelines. You arrive at the deck with options, not opinions.
A Plooi isn't a one-shot output — it's a workflow that gets better with every run. Refinements, feedback loops, and branches accumulate. Below: the same Plooi at four stages of its life.
A skeleton you fork from the library. Connections in place, methods empty.
Filled with project brief and one set of source documents. Output: rough but real.
You added a Critic agent, a feedback loop, and a branch for edge cases. Output: trusted.
Team-owned, branched per project type, exports to JSON for CI. Now reusable.
Every Plooi canvas — no matter how big — is made of the same four primitive shapes. Once you can read them, you can build anything.
One method feeds the next. The simplest discipline: A produces, B refines, C delivers.
Pick the right next step based on the input. Negative sentiment? Send to escalation. Positive? File and move on.
One brief, five concepts at once. Fan out the work, let agents run in parallel, gather and rank the results.
Generate → Critique → Generate again. The output keeps refining until the Critic agent gives a green light.
Connections in Plooi aren't just lines — they carry meaning. A solid line says "this data flows directly here". A dotted line says "this influences that conceptually". A curved-back line says "iterate until this is good enough".
Direct data transfer
The output of A becomes the input of B. Strict type-check, no ambiguity. The bread-and-butter of any workflow.
Conceptual influence
B is influenced by A but doesn't consume its raw output. Used for shared context, themes, or system-prompt inheritance.
Iterative refinement
B's output cycles back to A. Used in evaluator-optimizer loops — keep generating until the Critic approves.
Every Plooi method is a glass box. Hover it to see what prompt it's running, which model is wired to it, what its confidence score is, and where the output came from. No black-box magic — just legible craft.
Service-design example. The Orchestrator spins up three sub-agents — User, Backend, Support — to simulate a "lost credit card" journey in real time. Their messages stream into a single timeline so you can see exactly where the failure modes happen.
Every method wears its confidence on its border. Green for high, coral for medium, amber dashed for low. Locked methods pause the workflow until a human signs off. You always know when to trust, when to read, and when to intervene.
Ship it.
Worth a glance.
Read carefully.
Re-prompt or replace.
Human pending.
Must approve.
Eight of them shown — Discover, Synthesize, Define, Ideate. The full library is in the app.
Says / Thinks / Does / Feels — assumptions stripped to facts.
Features reframed as jobs people hire you to do.
Cluster qualitative data; Plooi proposes, you sharpen.
Evidence-grounded archetypes — no stock photos.
Emotions, frictions, opportunities along the spine.
Jobs/pains/gains matched against your offering.
Eight sketches in eight minutes. Discipline of quantity.
Six frames; a user, a moment, an arc.
Plooi's methods cluster naturally into four phases — Discover, Synthesize, Define, Ideate. Common workflows trace a path through several phases. Some methods belong to two clusters; the constellation shows their gravitational pull.
Generate, capture, observe — raw material in.
Cluster, label, surface patterns — sense out of noise.
Frame the problem, scope the bet — sharp questions.
Generate concepts, sketch futures — quantity then craft.
Seven methods don't belong to a single cluster — they pleat across phases and act as hinges in most workflows.
Drag any method onto your canvas — Plooi reads the context of where it landed and auto-fills the prompt template.
The Plooi method library splits into four functional categories. Mix them like Lego — most workflows use one or two of each.
Where raw stuff enters
The thinking layer
Side effects on the world
The conductor
Plooi is unapologetically for the expert-generalist — the role that owns the bridge between research, design, and product strategy. If that's the cap you wear, this is your tool.
Research lives in Dovetail, ideation in Miro, drafts in Figma, copy in ChatGPT. Every transfer is a context loss.
One canvas: transcripts cluster into themes, themes hatch into personas, personas critique your wireframes — all linked back to the original quote.
Static service blueprints go stale before they ship. Stakeholders argue about edge cases we never modeled.
Living blueprints. Branch into Happy / Unhappy paths and run a Simulator agent over each — fail-modes surface before launch, not after the postmortem.
Generating five concepts in parallel costs a week of team time. By the time we pitch, the market has moved.
Brief in, five concepts out — each with a storyboard, each Critic-ranked against your brand. Walk into Monday with options, not a single half-cooked direction.
Conversational AI is excellent for ad-hoc queries. For professionals doing iterative, multi-step work, it breaks down. Plooi is built for the work the chatbox can't hold.
from the Plooi white paper — "Beyond the Chatbot: The Era of Spatial Agentic Interfaces."
Today's research-to-product handoff bounces through five or six tools. Each handoff loses context. Plooi keeps all of it on one surface.
Research lives in Dovetail. Ideation in Miro. Prompts in ChatGPT. Wireframes in Figma. Specs in Notion. Tickets in Linear. The "stack" is mostly copy-paste.
Every task above becomes a method on a single canvas. The connections between them carry the context automatically — no exports, no re-pastes, no stale links.
Credits cover AI-assisted methods. The canvas, the methods, the collaboration — those are free.