Deutero — Interviewing, integrated. | The agentic interview primitive

// Try It

Get started with one command and one prompt.

Coding agents

Recommended

Add the Deutero MCP server to Claude Code, Codex or any other coding assistant. If you've connected PostHog or another analytics service, your agent can help you identify research priorities and launch a study in minutes.

Claude Code

claude mcp add --transport http deutero https://dashboard.deutero.ai/mcp

Codex

codex mcp add deutero --url https://dashboard.deutero.ai/mcp && codex mcp login deutero

then run your first study

Review usage analytics data for the product using your available tools and identify the most urgent user research priority area - one where interview data would clearly move the needle. Then, use Deutero to create a study to address the questions you have identified: first review the available tools, including question types, then build your study. Share the dashboard and interview link with the user. When the study is set up, ask me if I to run a simulated interview to test it or embed the study on the product site (there is a tool to set up embeds - make sure you set the allowed origins correctly) or share the link with an email audience, but do not publish it to users without confirmation.

Claude Code · Codex · any MCP client

Personal agents

Add the Deutero MCP server to Hermes or OpenClaw, then let it interview you about what you actually need from your personal agent — with one command you can take personalized software to the next level by giving your agent a user researcher.

Hermes

hermes mcp add --url https://dashboard.deutero.ai/mcp --auth oauth deutero

OpenClaw

openclaw mcp add deutero --url https://dashboard.deutero.ai/mcp --transport streamable-http --auth oauth

then start the self-check-in

Use the Deutero tools to create a user interview which will gather data to significantly improve your performance and ability to meet the user's needs. Review memories, personality documents/configuration, self-created skills etc to identify areas of uncertainty where direct user research data would be valuable.

live today: Hermes co-pilot check-in

Agent Skill & SDKs

Skillnpx skills add deutero-ai/agent-skill

CLIbrew install deutero-pp

Pythonuv pip install deutero

soon

CLI Repo Agent Skill Repo PyPI Package

MCP Server

// Official MCP Server

{
  "mcpServers": {
    "deutero": {
      "url": "https://dashboard.deutero.ai/mcp",
      "auth": "oauth"
    }
  }
}

Read the Docs →

// For Every Research Interview

From user research to incident postmortems, Deutero powers every interview.

User research — discovery that closes the loop

Turn "why do users churn?" into a study, real interviews, and requirements your agent ships against — without leaving your terminal.

Interview your own users where they already are — on WhatsApp, on your site, in Discord or Slack, or send a link to your users by email.
Follow-ups that probe the why, not just a survey that collects the what.
Themes clustered, linked to the exact quotes, ready for your team and agents to extract precise requirements.

> create_study name="churn drivers, Q3" survey_type="customer_development"

> create_question question="Walk me through the week you decided to cancel." follow_up=true

> update_recruitment short_url_slug="churn-q3"

> list_interviews completed=true → 38 interviews

> search_transcripts q="switched to a competitor" mode="hybrid"

> run_clustering question_number=2 n_clusters=4

> bulk_transcripts completed=true → transcripts + variables

4 themes, each traceable to its transcripts

Market research — concepts, pricing, positioning

Test the thing before you build it. Show the artefact, ask what they'd actually do, and get the reasoning behind the number.

Show a stimulus — a mock, an ad, packaging, a shelf — and probe the reaction. Our agent can understand and chat about the images in depth.
Reach beyond your own userbase: recruit from Prolific with screening criteria.
Scale, ranking, card sorting and multiple choice questions alongside open probing — collect qualitative and quantitative data in one interview.

> create_study name="concept test — pricing v3" model_tier="standard"

> create_screening_question options=[…] acceptable_options=["Weekly","Daily"]

> create_question question="How likely are you to buy at this price?" qtype="scale"

> create_question question="Upload a screenshot of the plan you'd pick." qtype="image_upload"

> update_recruitment max_responses=400

> get_scale_responses question_id=q_intent

1:4 · 2:9 · 3:31 · 4:52 · 5:24

> run_clustering question_id=q_why_price n_clusters=3

Opinion polling — the poll that asks the follow-up

A poll tells you what people picked. An interview tells you what would change their mind — at a sample size a human moderator will never reach.

Screening questions and participant characteristics define exactly who you're hearing from.
Any scale or choice answer can trigger a probe on the reasoning behind it.
Structured variables for the tally, clustered rationales for the story — each traceable to a quote.

> create_study name="approval tracker — October" survey_type="polling"

> create_screening_question options=["18-24","25-34","35-54","55+"] acceptable_options=[…]

> update_recruitment max_responses=800 short_url_slug="oct-tracker"

> list_interviews completed=true → 800 interviews

> get_options_responses question_id=q_switch

5 options + "Prefer not to answer"

> run_clustering question_number=4 n_clusters=4

> search_transcripts q="cost of living" question_id=q_switch

Tacit knowledge — what never got written down

The person who knows why the process works that way retires in March. Interview the people who actually do the work, before the knowledge walks out with them.

Graph-designed flows that walk a process step by step, with bounded loops for "and then what?".
Capture from response pulls out the steps, tools and exceptions as typed variables.
Send a signal webhooks them straight into your knowledge base — or an agent's memory.

> patch_graph add_node id="q_step" type="question" config={qtype:"text",text:"What do you do next?"}

> patch_graph add_node id="x_extract" type="extract" after="q_step"

> patch_graph add_node id="wh_notify" type="webhook" after="q_step"

> patch_graph update_node id="loop_back" max_revisits=6

> check_graph → valid, 0 problems

> list_interviews completed=true → 14 interviews

> get_interview_fetches_and_signals interview_id=… → 200 delivered

> bulk_transcripts → transcripts + variables

Incident postmortems — the retro that doesn't lose the timeline

Get every responder's account while it's still fresh — detection, escalation, mitigation, root cause — instead of one blurry retro meeting two weeks later.

Branch on role — on-call, incident commander, engineer — so each person is asked what they actually saw, not a generic template.
Extract steps pull timestamps, actions taken and blockers into structured fields as each person answers.
Send a signal ships the reconciled timeline to your incident tracker the moment the last responder finishes.

> create_study name="INC-482 postmortem" survey_type="customer_development" anonymous=false

> patch_graph add_node id="role_branch" type="decision" config={mode:"rules"}

> patch_graph add_edge from="role_branch" to="q_oncall_timeline" condition={var:"role",op:"eq",value:"on-call"}

> patch_graph add_node id="x_timeline" type="extract" after="q_oncall_timeline"

> check_graph → valid, 0 problems

> list_interviews completed=true → 6 interviews

> get_interview_fetches_and_signals interview_id=… → 200 delivered to jira webhook

> bulk_transcripts → transcripts + variables

Don't see your use case?

If you can phrase it as a question you'd ask a person, Deutero can probably run it. Tell us what you're trying to learn.

Talk to us →

// Modalities & Channels

Meet your people where they are.

One study definition. Video, voice, chat, or the app they already have open — same graph, same policy, same analysis.

Two-way video, avatar interviewer

A photoreal interviewer that looks at the participant while they answer — and a participant camera you can record for the moments a transcript loses.

Photoreal avatar Participant camera Type while you talk

Two-way voice

Real spoken conversation, barge-in and all — for participants who'd never type three paragraphs but will happily talk for twenty minutes.

on-device inference option — audio never leaves the device

Chat

The default modality. Async, low-friction, works on any phone — and on Team plans and above, text-only interviews have no usage cap once your included credits run out.

Embedded copilot

Drop the interviewer into your own product as a copilot — it asks in context, while the thing you want to hear about is still on screen.

Images, both directions

Show a stimulus — a mock, an ad, a shelf — and probe the reaction. Or ask the participant to upload a photo, and interview them about what's in it.

Where they already are

No portal, no panel login, no "click this link before Friday." The interview arrives in the app that's already open.

Slack

Discord

Web & embed

Or build your own surface

Every modality is the same durable, server-owned session behind an HTTP API. Python and TypeScript bindings for custom UI, custom channels, custom connectors — bring your own front end and let the engine keep the state.

REST API Python SDK TypeScript SDK MCP

No participants? We'll find them.

Recruit straight from Prolific without leaving Deutero. Set your screening criteria, launch the study, and vetted participants arrive in the interview — landing in the same transcripts, the same clustering, the same graph as everyone else you talk to.

early access Team plan and above

// Interview Design

Start with a list. Graduate to a graph.

Most studies never need more than an ordered list of questions — write them, and the interviewer handles the follow-ups. When the study outgrows a straight line, promote the same questions to a graph: branch on what they said, pull live data in from your API mid-conversation, extract structured variables as they're spoken, and fire a webhook the moment you have them.

Question list

default

Add questions, set the order, ship. Open, scale, choice and ranking questions, adaptive follow-ups, screening and participant characteristics — all of it works without ever opening the canvas. Add a question, reorder the list, and you're done — that's the whole workflow.

Graph

when you need it

Branching, live data fetches, captured variables, webhooks and bounded loops. Use the drag-and-drop editor, or let your agent build it and handle coupling interviews to your codebase: it's easy to inject user data into the agent's context for personalized questioning.

Interview Flow building flow… validating… graph valid validated on save scroll →

What the canvas adds on top of a question list:

Interview start — a hard consent gate before a single question is asked. Never inferred.

Question — open, scale, choice, ranking. Piped text drops earlier answers straight into the wording.

Branch & Smart Branch — route on a deterministic rule, or let the model read the answer and choose the path.

Bring in data — call your API mid-interview and ask the next question with their account, order, or usage in the interviewer's context.

Capture from response — extract typed variables from responses in real time, trigger a branch or pass them to other nodes.

Send a signal — webhook the extracted data to your systems while the interview is still running. Ideal for RL.

Interview end — send a webhook notification to your systems when the interview is complete to manage incentives and more.

Build it by hand or just prompt — the canvas and the API describe the same object.

Complete agent support

Our agent skill includes a reference file for graph design, and all editor functionality is available through our MCP tools - including graph compile checks for error-free deployments.

visual canvas MCP REST API import from question list

agent edits the flow

> get_graph study_id=…

9 nodes · 9 edges · graph_version 7

> patch_graph add_node type="context_fetch"

before=q_plan

> check_graph valid · no unreachable steps

> activate_graph interview_mode="graph"

next interview runs the new flow ▍

// Simulation

Test, debug and sample with simulations.

Generate personas, run them through the same engine as real interviews, and check the results. Identify unclear questions, see how the agent probes, and test graph integrations before your interview goes live.

A cheap first signal

Run a panel of personas in minutes to see whether the questions produce answers worth analysing, and pipe them through clustering to check the analysis end of the pipe before recruitment starts.

Exercise every path

Craft personas to check the branching logic in your interview graph or "red team" the agent with off-topic responses (and see how it guides the interview back to the guide) - without wasting time answering your own questions.

Integrations, end to end

Simulated runs hit your real data fetches and fire your real "send a signal" webhooks. Bad auth, a slow endpoint, a payload your system rejects, a captured variable that arrives empty — all of it surfaces before your participants hit bugs.

one agent session, start to fielded

— 1. build the panel

> generate_personas study_id=st_4f2 count=6

from screening + characteristic questions

6 personas · 2 churn-risk, 3 active, 1 trial

— 2. dry run

> run_simulation persona_ids=[…] model_tier="standard"

> get_simulation complete · 6/6 · 41 credits

— 3. read the failures

> get_interview_fetches_and_signals sim_id=sm_08

200 GET /account · 6/6 ok

401 POST /hooks/blockers · stale key

> get_graph study_id=st_4f2

branch_pricing fired 0/6 — condition never true

q_blockers: 4/6 answered "not sure what you mean"

— 4. fix

> patch_graph branch_pricing.condition plan != "free"

> update_question q_blockers text="Walk me through the last time…"

> check_graph valid · no unreachable steps

— 5. re-run the same panel

> run_simulation persona_ids=[…] same 6

200 POST /hooks/blockers · 6/6 ok

branch_pricing fired 4/6 · both paths covered

> activate_graph interview_mode="graph"

— 6. field it to real people

> create_embed_key label="churn-wave-1"

> update_recruitment target_n=120 completion_webhook=…

> resend.send_batch audience="lapsed-90d" n=1,400

personalised link per recipient queued

— 7. wait

> webhook study.completed · 120/120 interviews

> run_clustering question_id=q_blockers k=auto

5 themes · every claim linked to its quote

the simulated run is not in the analysis ▍

What it isn't

Simulated participants are not a substitute for the people you're studying. A model has no account history, no last-week frustration, and no stake in the answer — it will fill a gap plausibly where a human would push back, ask what you meant, or tell you something you never thought to ask about. Treat a simulated run as a test suite for the instrument and a rough first read on the questions. Findings you'd act on come from real participants; that's why simulated transcripts stay tagged as simulated everywhere they appear — in the transcript list, in exports, and in analysis.

// Pricing

AI moderated interviews for every budget

$0 free forever $29 solo $99 pro $299 team self-host free under $1M (coming soon)

Run a real study every month for free, forever — no credit card needed for Hobby plan.

Team: up to 5 seats flat, no per-seat fees Unused credits never expire 30% off non-profits Cancel anytime · 14-day refund

Calculate your credits →

// Why It's Trustworthy

Dynamic dialogue, backed by decision theory.

Research-grade methodology

Deutero's interviewing strategies are based on established qualitative research methodology, and our founder's research on optimizing interviewing.

Formal rigor

Our unique interviewing harness architecture ensures the conversation always stays safe and on-topic, while flowing naturally and respecting time limits.

No vanity metrics

Some vendors offer "response quality scoring" that relies on proxies like surprisal. The literature and math show these don't work, so we don't ship them.

Model agnostic by design

Deutero doesn't use fine-tuned models: we don't use your data for training. We select the best-performing models for our open weights tiers; our self-hosted option will support any Anthropic-compatible endpoint.

DFA-enforced policy Graph-compiled flows Durable engine Insight → quote On-device voice — audio never leaves the device

// Why Deutero?

Powering the autonomous learning organization.

Organizations are becoming autonomous — agents write the code, run the ops, make the calls. A system that can't hear the people it serves is flying blind, however fast it moves. Deutero is the missing organ: the primitive that lets an agent, a product, or a whole company ask, listen, and change because of the answer. First we gave software the ability to act on its own. This is how it learns to observe.

Deutero: teaching agents how to learn.

Ask your first question.

Free to start. One prompt to feel it. No demo in sight.

Let Your Agent Set It Up →

Interviewing, integrated.

The fastest way to run research on real users.