DialogWright

Voice and chat agents that understand people like an LLM, and act like code.

Callers say it their own way. A decision model works out what they mean, your code decides what happens, and they hear the words you approved. What is said and done is predictable, and replies are fast.

GitHub repository Quick start

Open source, Apache-2.0. Pre-release. Try it on your laptop, no keys needed.

How it is different

Three ways to answer a phone line or a chat.

Traditional IVRs and bots LLM agents DialogWright
Understanding Menus and rigid grammars Understands natural speech Understands natural speech
What callers hear Recorded prompts Generated, different every call The lines you approved
What it does A fixed flow Whatever the prompt leads to Decided by code, checked and audited
Each turn Fast Slower; pays for every word generated Fast; a fraction of a cent
Tuning Grammars and menu trees Editing the prompt Measured on recorded calls

Traditional IVRs and bots

Understanding
Menus and rigid grammars
What callers hear
Recorded prompts
What it does
A fixed flow
Each turn
Fast
Tuning
Grammars and menu trees

LLM agents

Understanding
Understands natural speech
What callers hear
Generated, different every call
What it does
Whatever the prompt leads to
Each turn
Slower; pays for every word generated
Tuning
Editing the prompt

DialogWright

Understanding
Understands natural speech
What callers hear
The lines you approved
What it does
Decided by code, checked and audited
Each turn
Fast; a fraction of a cent
Tuning
Measured on recorded calls

DialogWright: an LLM's understanding, with predictable words and actions, at a fraction of a cent a turn.

Decision models are the heart of it

A decision model reads what the caller said and answers typed questions: yes or no (a noul), which option (a choice), how much (a score), each with a probability. It never writes text. DialogWright asks all of a turn's questions in one request, and code acts on the answers with thresholds the app sets.

The question, as the app writes it apps/secretary/slots.yaml (excerpt)
recipient:
  type: choice
  options:
    riley:
      say: Riley Moreno
      means: The message is for Riley Moreno, or Riley, or the caller asks about them
    sam:
      say: Sam Okafor
      means: The message is for Sam Okafor, or Sam, or the caller asks about them
The caller says

It's not urgent, but could Sam call me back about the brochure?

What comes back An illustration: four answers, in the model's shape
intent        {"type":"choice","choice":"take_message",
               "probabilities":{"take_message":0.99,
                 "agent":0.01,"urgent":0}}
recipient     {"type":"choice","choice":"sam",
               "probabilities":{"sam":1,"riley":0,
                 "jordan":0,"anyone":0}}
messageGiven  {"type":"noul","noul":0.97}
urgency       {"type":"score","score":0,
               "probabilities":{"low":1,"normal":0,
                 "high":0}}
What code does with it intents.yaml and app.yaml (excerpts)
  urgent:
    priority: { correctsForm: true, threshold: URGENT_SURE }
thresholds:
  URGENT_SURE: 0.4

Urgent reads 0, under 0.4: no transfer. The message form starts, Sam filled in, and asks the caller's name.

Jev is the default, TypeSafe's decision model (jev-1.13). Any model that speaks the same System One API can replace it, measured on the app's own recorded calls, as Microsoft-Decision-1 has been.

Why it is cheap: it writes no text, only a few probabilities, so a turn pays almost only for reading.

Decision models in depth

Questions in a turn
about 20, in one request
Answered in
about 90 to 150 ms at p50, 150 to 250 ms at p95
Cost
309 requests to Jev for about $0.046, about $0.00015 a turn

The maintainer's recordings, 2026-10-14; the cost is the secretary's recording.

Why you would use it

Describe your line in a paragraph. Claude Code builds the app.

DialogWright ships a Claude Code skill, create-app, in every project npm create dialogwright makes. Say what callers can ask for, who must verify, what must be confirmed and what goes to a person. Claude Code plans the app, scaffolds it, writes the YAML, the code, the corpus and the scripted calls, and works until the checks, the type check, the tests and the stub regression are green. Then it hands you the recording command, and triages the recording.

The utility and the front desk were each built this way, from one paragraph.

  1. Your paragraph
  2. A worksheet
  3. The scaffold
  4. YAML, code, corpus, scripted calls
  5. Checks, types, tests, regression: green
  6. Your recording, triaged

Examples

Four fictional organizations, none needing a key to run.

Example Family Practice

Appointments: schedule, reschedule, cancel. The app to learn from.

Read about the clinic

Example Power & Light

Outages, balances and payment plans behind a one-time code. The app for policy.

Read about the utility

Harbor Mutual

Claims, and coverage questions answered from a knowledge base; brokers on the chat. The app for the knowledge base.

Read about Harbor Mutual

Quick start

Node 22.19 or later and pnpm. No keys: each app answers from its own labelled examples.

  1. Clone and install.

    git clone https://github.com/DialogWright/dialogwright.git
    cd dialogwright
    pnpm install
  2. Talk to the clinic in a text console.

    pnpm --filter @dialogwright/example-clinic cli --client heuristic
  3. Start an app of your own.

    pnpm create-app <name>

A real phone line needs a carrier account and a decision model's key (and a render model's for generated wording): run it on a machine you own.