A dual-agent system for product managers: one agent to widen an idea, one to stress-test it.
At a glance
- 🤝 Accomplice widens a raw one-liner into a full product Intent (diverge)
- 🥊 Gauntlet stress-tests that Intent across adversarial review lenses (converge)
- 🧱 A structural boundary keeps the two apart — neither can do the other's job
- 🧠 Both reason over a federated, provenance-tracked PM Memory layer
- 📴 Runs fully offline with a pluggable model backend
Jump to: The problem · How it works · Memory layer · Why separation matters · Status
🔒 Showcase repository. This repo presents the design, architecture, and behaviour of the system. The implementation is kept in a private repository — the code is not published here.
Most "AI for PMs" tools do one of two things: they either brainstorm enthusiastically (and tell you everything is a great idea), or they critique harshly (and kill momentum before an idea is even formed). Real product thinking needs both, in the right order, and kept separate so neither contaminates the other.
Accomplice & Gauntlet splits the work across two purpose-built agents with a hard boundary between them:
| Accomplice (diverge) | Gauntlet (converge) | |
|---|---|---|
| Role | Creative partner / "friend" | Adversarial reviewer / "critic" |
| Question | "What else could this be?" | "What's wrong with this?" |
| Produces | Widened Intent (segments, jobs, metrics, framings) | Findings with severity + a go / no-go verdict |
| Never does | Adds constraints, risks, or verdicts | Invents scope or ideas |
The boundary is enforced structurally, not by convention: the Accomplice can only emit expansions and always ships an Intent with zero constraints; the Gauntlet is the only side that can raise a severity or a verdict. The two stages chain end-to-end — the Accomplice's output is exactly the Gauntlet's input.
PM one-liner
│
▼
┌──────────────────┐ grounded in
│ ACCOMPLICE │◀──── PM Memory (the "why": signals, history, precedent)
│ (ideation) │
│ │ • single-shot: fan out creative personas
│ │ • conversational: pick "moves" turn by turn
└────────┬─────────┘
│ Intent (outcome, audience, jobs, metrics, framings · constraints = [])
▼
┌──────────────────┐
│ GAUNTLET │ • fan out across adversarial review lenses
│ (adversarial) │ • each lens grounded in risk-side context
└────────┬─────────┘
│ Findings (severity) + cross-lens conflicts + themes
▼
┌──────────────────┐
│ HARDENER │ → a backlog-ready spec with a clear
│ (synthesis) │ go / hold / no-go recommendation
└──────────────────┘
Two modes:
-
Single-shot — fan out across a set of creative personas (segment finder, jobs-to-be-done, value angler, GTM/pricing, support & CX, competitive differentiator) and synthesize the result into one crisp Intent.
-
Conversational — a turn-by-turn brainstorming partner. Instead of always running the same fixed personas, each turn it selects a few moves from a vocabulary of ~16, grouped into four families:
- Reframe — problem reframer, assumption surfacer, intent clarifier
- Widen — segment, jobs, value, GTM, support, competitive, amplify, invert
- Ground — signal miner, history recall, precedent
- Converge — cluster, synthesize
It picks moves based on what the idea needs right now, accumulates the material across the session, and crystallizes it into an Intent on request.
The widened Intent is fanned out across a set of adversarial review lenses — governance, compliance & security, data & telemetry, responsible AI, reliability & operability, engineering feasibility, accessibility & localization, finance, competitive & ecosystem, GTM & pricing, customer & field signals, and more. Each lens is a focused critic grounded in the relevant risk-side context, and each returns structured findings with a severity and a verdict (blocker / flag / pass).
Cross-lens findings are synthesized into a single recommendation — proceed / hold / needs-revision — surfacing the before-spec blockers that must be resolved first and the cross-lens conflicts where two reviewers disagree and a human must make the call. The output is an approvable, backlog-ready spec.
Both agents reason over a curated PM Memory — the accumulated why behind a product area: customer signals, what's been tried and rejected, precedents, telemetry patterns, and open incidents. This memory is federated from multiple upstream sources through a uniform provider contract, so the agents stay domain-agnostic:
| Generic source | Contributes |
|---|---|
| Meeting-intelligence source | Decisions & signals from recorded meetings |
| Signal-clustering source | Recurring themes & root-cause clusters |
| Org-knowledge source | Curated, already-synthesized org memory |
| Incident source | Open/again-recurring reliability issues |
| Telemetry source | Live usage & adoption patterns |
| Service-catalog source | Ownership & dependency context |
Each contribution is tagged with provenance (verified vs. inferred) and graded for quality (coverage, grounding, freshness) before it ever reaches an agent — so ideation and critique are grounded in evidence, not vibes.
The single most important design decision is that the two agents cannot do each other's job:
- The Accomplice diverges — it only adds possibilities. It is structurally incapable of emitting a risk or a verdict, so it can never quietly kill an idea while pretending to explore it.
- The Gauntlet converges — it is the only place a blocker or a go/no-go can originate, so critique is explicit, attributable, and never smuggled into the ideation phase.
This keeps brainstorming generative and review rigorous, and makes the whole pipeline auditable: every constraint has a named lens behind it, and every idea has a named move behind it.
- Two working agents with a clean, structurally-enforced boundary.
- Single-shot and conversational ideation.
- Adversarial review across a full set of lenses with cross-lens conflict detection and a synthesized recommendation.
- A federated, provenance-tracked memory layer.
- Fully offline-capable pipeline with a pluggable model backend.
See docs/ARCHITECTURE.md for a deeper walkthrough and
docs/SAMPLE_SESSION.md for an illustrative run.
Designed and built by Srikanth Jaligam — a product manager who builds the tools he wishes existed. This showcase presents the design and behaviour of the system; the implementation is private.
© 2026. All rights reserved. This showcase is provided for demonstration purposes only. No source code is included, and no license to any underlying implementation is granted.