AI-Assisted Strategic Planning Tool

01

The problem: plans go stale before they're acted on

Canvas — reviewing an agent-proposed endstate rewrite

Canvas — an agent-proposed endstate rewrite. Scores stay provisional; nothing publishes until a human approves.

Strategic plans rest on assumptions about the future, and market signals invalidate them constantly. By the time a team knows its plan is wrong, they've already acted on it. The real question isn't whether to use AI for strategy; it's whether you can trust it in the room when the stakes are high.

The Real Problem

Leadership teams were building scenario maps manually, checking signals manually, and updating plans in quarterly reviews. The world moves faster than that. By the time a plan was published, assumptions were already shifting.

The Core Tension

Every design decision came down to one question: does this keep the user in control, or does it quietly take control away from them? Enterprise users distrust AI that acts autonomously — especially for high-stakes decisions.

"AI assists thinking — it never auto-changes your map."

The design philosophy, written into copy on every AI-facing surface

02

What made this role unusual

Monitoring — the Signal Agent's always-on surface: PESTLE-tagged signals, At-Risk / On-Track flags, Analyst on the right.

Joining as the only designer, I wasn't handed a brief and asked to draw screens. I helped figure out what we were building, then designed it.

The hard part wasn't the UI; it was defining what the agents could do, in what order, and why. That the Analysis Agent runs only when the user triggers it, and that the review panel is the only path to The Wall, I proposed these, because a fully autonomous agent would have broken trust with every enterprise user we built for.

Product direction

Defined what we built — including the two-agent architecture, the permission model, and the human approval loop

End-to-end UX

Flows, AI patterns, data viz, and a design system from scratch across 6 surfaces — no components to inherit

Agent architecture

Proposed and designed the distinct permission boundaries, timescales, and failure isolation between both agents

GWT spec writing

38 user stories across 7 epics with full acceptance criteria — written by me, not a PM

React prototyping

Built and deployed on Vercel via Cursor before engineering was in place — so we could test with real users early

Founder-facing

Every major product tradeoff — what to build, what to cut, what to defer — made directly with the founding team

Spec samplePublishing to The Wall

As a Workspace Admin, I want to publish the current aligned Canvas state to The Wall, so that it becomes a permanent, read-only strategic snapshot the wider organisation can monitor and share.

Givena Workspace Admin is on the Canvas with at least one scenario and endstate defined
Whenthey click “Publish to Wall” and confirm in the dialog
Thena read-only Wall snapshot is created, the “Wall” nav link becomes active, and the Canvas stays editable
Anda success toast confirms “Strategy published to The Wall”

1 of 38 stories · scenario 1 of 3 · full acceptance criteria omitted under NDA

AI ProductEnterpriseStartupNo PMMulti-agent0→1

03

Four decisions that made the AI trustworthy

Signals — market signals scored against the scenario

Signals — the week's signals clustered and scored against the live scenario.

Each was a deliberate choice against the obvious alternative. The obvious move was “let the AI do more.” The harder, more defensible one was “let the user decide more.”

01

Draft before Canvas

AI output never lands directly on the live canvas. Everything routes through a Draft state where the user reviews, edits, and commits. Per-item confidence scores make it obvious which items are worth reviewing vs safe to approve quickly.

Key TensionMaking review feel necessary, not annoying. Per-item confidence scores solved it, bulk-approve the safe ones, flag the rest.

02

Provisional scores

Likelihood and desirability scores update as pending states while users build. Nothing commits until Run Analysis. A relevance threshold filters noise — only shifts above a minimum delta surface at all.

Key TensionProvisional states risk feeling like noise. A delta threshold hides small changes, so only strategy-shifting updates surface.

03

Pre-framed prompts

No blank prompt fields anywhere in the product. Context-aware question cards shift based on the surface — Monitoring gets signal-oriented questions, Canvas gets scenario risk questions. Custom input sits below, not instead of, the cards.

Key TensionPower users want open prompts. Card-first nudges toward structure while keeping custom input a click away.

04

Philosophy as interface copy

"AI assists thinking — it never auto-changes your map" appears on every AI-facing surface in the product. Not in onboarding. Not in a modal. At the point of use, every time.

Key TensionIt felt like marketing copy, but testing showed enterprise users read it, and engaged with AI outputs instead of dismissing them.

04

Two agents — two different contracts with the user

Governance — the autonomy rules that bound each agent: confidence floors, and what it can never do alone.

The first concepts had one agent that did everything, monitor, update, publish. Testing killed it fast: users couldn't tell what it was doing, when, or why. Trust collapsed.

Splitting into two agents with different operating modes fixed it. Each has a clear contract: the Signal Agent watches; the Analysis Agent acts, only when asked, and never without review.

Signal Agent — Always On

Runs on a schedule. Scans market signals, matches them against published scenarios, recalculates whether assumptions still hold. Users see its outputs in Monitoring and Dashboard, but never trigger it. Its presence is a "Scanned 2h ago" pill — it speaks when it finds something worth surfacing.

Analysis Agent — On Demand

User-triggered only. The user hits Run Analysis, the agent scores all connected events in parallel and rewrites the endstate narrative. Every change goes through the Review panel before it can reach The Wall. Users can send changes back for revision or approve them — and approving doesn't publish. That's still a separate step.

Why two agents? Different timescales, different data, isolated failure modes. If the Signal Agent gets noisy, it doesn't touch the plan. If the Analysis Agent produces a bad rewrite, it's caught in Review before it reaches The Wall.

05

Key surfaces — each with clear trust boundaries

AI Analyst — pre-framed prompt cards keep questions structured; it never publishes without your call.

06

Where I took it next: decisions made together

Decision Room — two-lead approval thread

Decision Room — publishing to The Wall takes two leads; the agent stays to answer for its reasoning. Reversible 72h.

The biggest gap I'd flagged in “what I'd do differently”: no way to tell the agent why it was wrong, and no shared place for the highest-stakes calls. Governance required two reviewers to publish, but that rule had nowhere to happen. So I designed the room.

The Decision Room turns that rule into a conversation. When the agent proposes a rewrite, it opens a thread: both leads weigh in, and the agent stays to answer for its reasoning. Ask how sensitive the 86% is to one assumption, and it answers with the number. Approval clears only at 2 of 2.

The agent is a participant, not a black box

Anyone can @mention the Analysis Agent mid-decision and get a specific, sourced answer. This is the feedback loop the shipped product was missing: the reasoning gets interrogated at the moment of the call, in front of everyone who has to live with it.

The rule becomes a place

Governance defined dual approval; the Decision Room is where it lands. Quorum, approvers, who is in the room, and a reversible 72-hour window all sit on one surface, and every word goes on the record.

The honest next chapter of the trust thesis: the four shipped decisions kept one person in control of the agent. This one keeps the team in control of the decision, without ever letting the agent make it.

Explore the interactive prototype →

07

Shipped end-to-end — and what I'd do differently

Shipped

Live

6 surfaces, 2 agents, full approval flows deployed on Vercel with early enterprise customers

Spec coverage

38 stories

7 epics, full GWT acceptance criteria — written by the designer, not a PM

Architecture

2 agents

Distinct permissions, timescales, and failure isolation — each with a different user contract

Core differentiator

Human-gated

AI can never act on the plan without human approval at every step — by design, not as a limitation

What I learned

The hardest part of designing AI products isn't the AI, it's deciding what it's allowed to do without asking. Every capability is a potential moment of lost trust. The decisions I'm proudest of are the ones where I said “the agent shouldn't do that.”

Trust is also cumulative. The philosophy copy, the provisional scores, the Review panel, none builds enough on its own. Together they signal: this system is on your side, not working behind your back. By the first Review panel, the user already half-trusts the output.

What I'd do differently: the Decision Room lets the team interrogate the agent's reasoning at the moment of a call — but the agent still doesn't learn from those exchanges. I'd close that loop next: capture where the team pushed back and why, then feed it forward so the agent's future scores and rewrites measurably improve over time. That's the difference between an agent you can question and one that gets better because you did.

Multi-agent UXAI Trust DesignAgent GovernanceHuman-in-the-loop0-to-1React Prototyping