Research doesn’t always lead to one answer.
Signal · UX + AI Product Design
Research rarely arrives as a clear answer. Different sources often point in different directions, yet most tools are designed to flatten that disagreement into a single answer. Signal is an AI agent that helps teams make sense of conflicting information. It synthesizes evidence, surfaces key insights and reveals where findings are strong, weak or unclear. When the evidence cannot support a defensible conclusion, Signal stops instead of pretending otherwise.
Duration
4-week sprint · Figma · Claude Code
Signal doesn’t start with a form. It asks you a question first.
The problem: AI tools are optimized to appear confident. But in research workflows, confidence is often the wrong goal because ambiguity, contradiction and incomplete evidence all matter.
The decision: A form assumes the system already knows what it needs. A question finds out. Starting with what the designer is actually trying to decide means the system is oriented correctly before it touches anything.
The result: Without knowing what decision the research is supposed to support, the system has no basis for deciding what's relevant, what conflicts matter or what the brief needs to say. The opening question isn't onboarding. It's calibration.
The tradeoff is a slower start. Most people opening a research tool want to do something right away. This asks them to think first and that only works if the system makes it clear it was worth stopping for.
Wireframes
Left drawer + source list
Two surfaces competing. Sources managed separately from the conversation. Abandoned when it became clear chat needed to be the only surface.
Static brief, export and done
Signal produced findings and went quiet. No way to question a finding or correct an inference. The only action was to export.
“Ask about this finding” side panel
Evidence retrieval worked: quotes, reasoning, source data all surfaced. But the panel closed every time you moved to another card. Context reset with every question. The container was wrong.
Signal diagram flow
How evidence becomes a decision
The problem: Research tools typically present information as a single output rather than a process that evolves over time.
The decision: Signal is structured as a state-based system that moves through distinct phases of understanding.
The result: The system progresses through four stages.
Each stage defines how information is handled, and transitions between stages are as important as the states themselves.
Stage 1: Setup
The system orients itself before it does anything. The question comes before the sources.
Stage 2: Ingestion
Sources enter with their limitations visible. Evidence quality is assessed before it influences anything downstream.
Stage 3: Triangulation
Where disagreement becomes visible before it becomes a problem.
Stage 4: Handoff
The brief doesn't leave the system. It travels with everything attached.
Mid-Read: Signal Stops Itself
The problem: AI systems typically continue processing until a full output is produced, even when conflicting evidence emerges mid-analysis.
The decision: Signal introduces a pause state that triggers when a decision-blocking conflict is detected, stopping synthesis before a brief is completed.
The result: Instead of a completed but unreliable brief, the system surfaces the conflict in context and returns control to the designer for direction.
The tradeoff is interruption. The user came to get a brief and the system stopped short of giving them one. That only works if the pause is legible enough that they understand why it happened, otherwise it just feels broken.
Control Paradox sidebar
CRITICAL badge, 83% asked / 3% used, source attribution on each row, three action buttons
Paused here chat message
Distinct visual treatment, red tint, Signal's full narrative
Designer's typed response
These interviews predate the Q3 redesign. The analytics reflect the old version.
Hard States as Safety Architecture
When evidence is stale, thin or contradictory, most systems keep going. Signal stops and says why.
The problem: AI tools treat failure as an edge case rather than something worth designing for explicitly.
The decision: Hard states are treated as primary system behavior, with explicit handling for conditions that would otherwise produce misleading synthesis.
The result: Each failure condition becomes a visible state with its own treatment and recovery path rather than an invisible degradation of output quality.
The tradeoff is that the system looks less capable than one that always produces output. Surfacing failures explicitly means users see the limits. That's the point but it requires the system to earn enough trust that visible limits feel honest rather than unreliable.
Stale Evidence
Research has a shelf life. Outdated sources are flagged at upload before they shape a brief that no longer reflects reality.
Interpretive Leap
There's a difference between what data shows and what it suggests. Any reasoning beyond direct evidence is marked as inference so the line stays visible.
Single Source
One source can't be meaningfully compared against itself. The system flags it and identifies what additional evidence would actually close the gap.
Gap Report
Some evidence is too thin to safely support synthesis. Instead of producing a weak brief, the system names what's missing and why it matters.
Making conflict visible.
The problem: Research presented sequentially makes contradictions easy to miss until after synthesis has already occurred.
The decision: Signal introduces a spatial model where evidence is mapped across dimensions rather than read linearly.
The result:Designers can inspect evidence strength, compare contradictions and annotate findings before synthesis occurs.
The tradeoff is cognitive load. A spatial map requires more effort to read than a list. That's only worth asking if the contradictions it forces you to see would have been easy to miss otherwise. Which is exactly the condition this screen is designed for.
Bidirectional Synthesis
The problem: AI outputs are typically static. They can be annotated but not meaningfully challenged or changed.
The decision: Researchers don't receive findings passively, they react to them. The brief is designed to work the same way, updating its reasoning as the designer challenges it, the way a thinking partner would.
The result: The synthesis evolves as it is challenged, while a full audit trail preserves what changed, when it changed, and why.
Push back and it updates its reasoning in real time. Most tools give you outputs you can annotate around. Signal gives you outputs you can argue with.
Most synthesis tools produce a document.
Signal produces multiple views of the same evidence.
The problem: A single research output is expected to serve multiple roles, even though designers, PMs and researchers interpret evidence differently.
The decision: Signal generates role-specific views from the same evidence: Designer briefs, Gap Reports and shares a preview before sending.
The result: Research adapts to its audience instead of being flattened into a single static document.
Brief tab — Finding cards, risk badges, source chips, design implications. What the designer reads before making a call.
Gap Report tab — Named gaps, what's missing, what research would close it.
Map tab — The spatial view. Optional.
Signal composes the email, frames findings for the right audience, and sends a live link not a PDF.
The brief travels. Signal writes the email.
The problem: Research briefs lose context when exported as static PDFs.
The decision: Signal delivers briefs as role-specific, live links instead of attachments, preserving context and enabling interaction.
The result: Attribution, caveats and system flags remain attached to the brief and recipients can continue the analysis directly in Signal.
Eight principles, embedded in interaction
Each principle is mapped to a specific screen and a specific interaction moment.
The inference badge isn’t defined in a terms of service. It appears directly on every finding where the system has reasoned beyond the source evidence.
Bias disclosure isn’t a checkbox buried in onboarding. It is surfaced at the moment of use, inline on each source card as it enters analysis, not as a setup step.
In Signal, principles don’t live in documentation. They live in the interface as visible constraints that shape how the system behaves in real time.
Bias Awareness
Consent isn't a setup step. It appears at the moment a source enters analysis, inline, where it's actually relevant.
Human Agency
The system can stop itself. When judgment is required, it interrupts its own process and returns control.
Harm Prevention
Temporal risk is surfaced before it can shape the output.
Reliability
When evidence isn't strong enough, the system says so instead of producing output anyway.
Transparency
What the system observed and what it inferred are always visually distinct.
The hardest problem in AI is not generating output, it’s knowing when not to.
Signal challenges the default toward confident output and instead supports slower, more careful reasoning where uncertainty is visible and decisions are better supported.
The harder design problem isn't generating output. It's knowing when the system should stop.