Agent Pattern Picker
There is no single best way to wrap a model in an agent. Whether you reach for a plain single prompt, ReAct, Reflexion, a compiled DSPy pipeline, GEPA prompt evolution, ADAS meta-search, a multi-agent team, or the full self-improving Harness² (Google Cloud AI Research, arXiv:2610.14224) depends on your task, your data, your budget and your threat model. Answer eight questions and this tool ranks the patterns with a fully transparent heuristic — every point is traceable to an answer — and tells you, for each, when not to use it. Everything runs in your browser; nothing is uploaded, and no benchmark numbers are invented.
Describe your use case
Eight questions. Every answer moves the ranking by a fixed, visible amount — open “why this ranked here” on any result to see exactly which answer gave which points.
What kind of task is this harness mostly for?
The work shape decides whether a verifiable loop, tool use, or a fixed pipeline fits best.
How much should it get better over time?
Learning across runs is the dividing line between a static pattern and a self-improving harness.
What training / evaluation signal do you have?
Optimizing and evolving patterns need a metric to select against; without one they cannot improve.
How much cost and latency can you tolerate?
Parallel branches, retries and meta-search all multiply inference spend and wall-clock time.
How tight are your security / egress constraints?
Broad tools, open egress and self-modifying loops enlarge the attack surface a sensitive deployment must bound.
Is a human in the loop?
A human gate is the single most important control when a harness can change its own prompt, tools or guardrails.
Single agent or multiple?
Decomposition into planner + workers buys parallelism and specialization at the price of coordination overhead.
How reproducible must the behavior be?
Compiled, fixed-graph pipelines are the most reproducible; open-ended search and self-modification the least.
Recommended patterns
heuristicThe model alternates a reasoning step with a tool call, observing each result before the next step. Low setup, needs no training data, and is the natural fit for tool-using research and ops work.
When NOT to use: When you need learning that persists across runs, strict reproducibility, or a verifier — plain ReAct has none of these and can loop or wander on hard tasks.
Evolves the prompt by reflecting on execution traces in natural language and keeping the Pareto-front survivors across rounds. Sample-efficient — it can improve a pipeline with relatively few rollouts when you have an eval signal.
When NOT to use: When you have no eval signal to select on, or when you need a brand-new architecture rather than a better prompt for an existing one.
Adds an episodic self-reflection loop on top of ReAct: when an attempt fails a check, the agent writes a verbal lesson into short-term memory and retries. Strong when outcomes are automatically verifiable (tests, a reward signal).
When NOT to use: When there is no success signal to reflect against, when latency is tight (retries cost), or when you need lessons to carry across tasks — Reflexion forgets after the episode.
Declare a pipeline of typed modules, then compile it — the optimizer tunes prompts/demos against your metric offline. The deployed graph is fixed, typed and highly reproducible, and inference stays cheap.
When NOT to use: When you have no metric or trainset to compile against, or when the task genuinely needs open-ended runtime adaptation rather than a fixed, pre-optimized graph.
A planner decomposes the task, specialized worker subagents execute (often in parallel), and a critic reviews before any action. Scales to complex, decomposable work and lets you specialize each role.
When NOT to use: When the task is simple or single-threaded (coordination overhead dominates), when the budget is tight, or when the delegation trust and extra surface are hard to bound under strict security.
The full self-improving harness: a task-level Propose·Probe·Compose loop inside a harnessing-level loop that carries the adopted harness and its evidence-backed lessons into the next task. Broad tools, accumulated lessons, strongest on capability — and thin on governance unless you add controls.
When NOT to use: When security is strict and you cannot add a human gate and egress controls, when you need cheap or deterministic behavior, or when nothing about the work benefits from cross-task self-improvement.
A meta-agent programs new agents in code and searches a growing archive of designs against a metric. Self-improving at the design (harnessing) level — powerful for research into agent architectures, and compute-hungry.
When NOT to use: When cost/latency are constrained, when security is strict (a code-writing meta-agent is a large surface), or when you just need to ship a known-good pattern rather than discover one.
The floor: a well-written system prompt and one forward pass. Cheapest, fastest, most reproducible, and the smallest attack surface. Always the control you measure every more-complex pattern against.
When NOT to use: When the task needs tool use, multi-step reasoning it cannot do in one pass, or any ability to recover from its own first-draft mistakes.
Illustrative design heuristics computed from your answers via the weight table in this tool’s source — not measured benchmark results. The picker ranks all 8 patterns; treat the top two or three as candidates to prototype, not a single verdict.
What this tool is
- A free, fully in-browser decision tool: answer eight questions about your use case and get a ranked recommendation of agent-harness patterns — single-prompt baseline, ReAct, Reflexion, DSPy, GEPA, ADAS, multi-agent, or Harness². Nothing is uploaded; there are no server calls.
- The scoring is a transparent, deterministic heuristic. Every pattern has a visible base fit and a point value per answer, and each result shows exactly which of your answers contributed which points — no black box.
- It shows the top candidates with a plain-language rationale and an honest "when NOT to use" for each, so it narrows the field instead of pretending there is one right answer.
- Each pattern links to the matching PlayCISO lab — tool scope, memory governance, delegation trust, eval integrity, change-control — so you can drill into the risks of the one you pick.
- Harness² is Google Cloud AI Research (arXiv:2610.14224); the other patterns are named by their originating work for attribution only. No benchmark figures are claimed; anything unknown is shown as "—".
A recommender you can argue with
Most “which agent framework” advice is a vibe. This tool makes its reasoning inspectable instead: the patterns, the base fit of each, and the exact points every answer moves them by are all in the open, and each result shows its own arithmetic. If you disagree with where a pattern landed, you can see precisely which answer drove it there — the scoring is a position to debate, not an oracle to obey. The numbers are heuristics that encode documented tradeoffs (parallel branches and meta-search cost tokens; a verifier and provenance-carrying memory buy robustness; broad tools and self-modifying loops enlarge the attack surface), not measured results.
The honest part is the “when NOT to use” on every pattern. A self-improving harness is the wrong default for a locked-down, human-in-the-loop deployment; a compiled DSPy pipeline is the wrong choice when you have no metric to compile against; ADAS is the wrong tool when you need to ship rather than research. The picker is built to narrow the field to two or three candidates worth prototyping and to send you to the matching PlayCISO lab to pressure-test the risks of the one you choose — not to hand you a single answer and call it done.
Frequently asked questions
How does the picker decide which pattern fits?
It is a deterministic, fully visible heuristic. Each of the eight patterns has a base "fit" score and, for every question, a fixed point value for each possible answer — the whole weight table lives in the tool’s source. Your score for a pattern is its base plus the point value of each answer you gave. Every result card has a "why this ranked here" view that lists each contributing answer and its exact points, so nothing is hidden. The numbers are editorial heuristics expressing documented tradeoffs, not measured benchmark results.
Which patterns does it cover, and are the attributions real?
Eight: a single-prompt baseline, ReAct (reason + act), Reflexion (verbal self-reflection), DSPy (a compiled, typed pipeline), GEPA (reflective prompt evolution), ADAS (a meta-agent that designs agents), a multi-agent planner/workers/critic pattern, and Harness² (the self-improving harness). Harness² is Google Cloud AI Research, arXiv:2610.14224. The others are attributed to their originating work by author and year for identification only — no benchmark numbers are attached to any of them, and anything genuinely unknown is shown as a dash.
Does it give me one answer or several?
It ranks all eight patterns and highlights the top fit, but it deliberately surfaces the top two or three as candidates rather than a single verdict. Real selection depends on details the tool cannot see — your exact eval data, latency budget and threat model — so the right use is to treat the leaders as a shortlist to prototype, read each one’s "when NOT to use", and follow the linked lab to pressure-test the risks.
Can I share or save my result?
Yes, both locally. The page keeps your answers in the URL hash (base64url-encoded), so copying the shareable link reopens the exact same answer set and ranking for anyone — no account, no server. You can also export the full recommendation, including the rationale and the "when NOT to use" notes, as a Markdown file generated entirely in your browser.
Does anything leave my browser?
No. The whole tool is client-side React with static data and inline SVG. There are no network or API calls, no account, and nothing you answer is sent anywhere. The shareable link and the Markdown export are both built locally in the browser.