Jev call copilot CurrencyTransfer research and architecture built 2026-09-24

Prior art survey: Jev-based call copilots, TypeSafe patterns, and real-time sales coaching UX

Date: 2026-09-24. Author: research subagent (Fable 5.1). Scope: everything found that is relevant to building a CurrencyTransfer (CT) call copilot on Cloudflare Workers with typesafe/jev, for (1) client onboarding calls and (2) customer-success calls, where clients ask about exchange rates, safety/security of funds, settlement, fees and timing.

Conventions used below:

Fetch failures worth knowing about (so nobody re-tries them): balto.ai/real-time-guidance/ (404 via fetch; content recovered from search snippets and balto.ai/real-time-agent-assist/), cresta.com/products/agent-assist (404; cresta.com/agent-assist works), lindy.ai/blog/gong-review (404); ZeroGold/call-coach-ai raw files decide.js and playbook.js live under public/, not the repo root (root-path fetches 404).

0. Executive summary

  1. The reference project (Moritz Kremb's jev-sales-copilot) is a complete, well-engineered instance of TypeSafe's own recommended architecture: one speculative fan-out request per utterance (37 typed questions, ~7.5k tokens, ~$0.0003), all arithmetic in code, a hand-written playbook that Jev only picks from, confidence gates everywhere, and a replay/eval harness. It is Python + FastAPI, not Cloudflare, and its playbook is generic B2B SaaS. Everything structural transfers; nothing domain-specific does.
  2. There are at least six other public Jev call/meeting copilots (call-coach-ai, jev-sales-calls, jev-support-copilot, cuecard, jev-voice-browser, slidepilot). Each contributes one reusable mechanism: hysteresis/cooldown on cues, a capability library turned into Nouls, a closed-world "unlisted request" guard, per-turn cue rate limits, partial-transcript commit logic, and a Cloudflare Agents + Workers AI Flux STT + Jev pipeline respectively. One "Jev" project (jev-sales-radar) does not actually call Jev at all.
  3. TypeSafe's own docs (local copies) supply the four load-bearing patterns (fan-out, confidence routing, composite scoring, intent routing), the jaggedness list (literal reading, no arithmetic, no dates, context rot, structural invariants do not hold), and cookbooks that map directly onto CT needs: classification_using_confidence (fall back to a coarser label), consistency_* (an explicit uncertain band routed to a human), parallel_questions (batching is 12.2x cheaper / 10x faster with zero change in answers), autoresearch_feature_discovery (learn which questions predict an outcome), skill_suggestion (Choice to pick + Nouls to decide whether to pick at all).
  4. The independent pre-registered test (primeline.cc) is the most important external evidence: Jev's yes/no (Noul) answers are far better calibrated (ECE 0.012) than Choice (0.086) or Score (0.254); at confidence >= 0.9 it is right ~92% of the time; and the accuracy ranking between Jev and LLMs flipped between two tasks, so "benchmark your own task" is the only safe conclusion.
  5. Commercial real-time products (Balto, Cresta, Attention, Convo, Avoma, Clari) converge on the same UI vocabulary: a smart checklist that ticks itself as required items are covered, dynamic prompts / battlecards that fire on detected objections or topics, a listening state that avoids alert fatigue, and a manager-side playbook designer / scorecard per role, region, stage. Gong and Chorus are post-call; their metrics (talk ratio, monologue length, trackers) are the review-mode vocabulary.
  6. Nothing found in the Jev ecosystem covers FX, payments, onboarding, or customer-success calls specifically. The CT copilot would be the first; the corpus (objection taxonomy, fact checklist, playbook lines, labeled utterances) has to be authored, and prior art says exactly how to structure it so an admin can tune it without re-prompting.

The ranked top-10 list of transferable ideas is in section 8.

1. The reference: moritzkremb/jev-sales-copilot

Sources: [local] /home/stevan/dev/jev/reference/jev-sales-copilot/README.md, DEMO.md, copilot/constants.py, copilot/engine.py, data/playbook.json, data/calls/cloudtalk.json, eval/integration_report.json; [web] https://github.com/moritzkremb/jev-sales-copilot (1 star, 2 forks, single commit as of fetch); [web] https://madewithjev.com/builds/sales-copilot; original post https://x.com/moritzkremb/status/2102537239662096658 (text via fxtwitter: "Listens to sales call live / Tells you what to say next / Helps you follow the script and handle objections / Shows you what stage of the call you're in / Gives you live signals and probability of closing", posted 2026-09-22, 192 likes, ~19.9k views at fetch).

1.1 What it does

Per utterance (replayed transcript, typed text, browser mic, or a YouTube-synced real call), one request to jev-1.13.0 answers ~37 atomic questions and within a few hundred ms the dashboard updates: closing probability line chart, live signal badges, call stage, open objection type, next-best-move coaching card with a highlighted pre-written line, talk ratio/pace, and an optional LLM-tailored phrasing that Jev verifies before it is shown. Measured on a real 9-minute CloudTalk call: 48 utterances, ~$0.014 per call, Jev latency mean 345-391 ms, p95 ~525 ms (client-side, macOS, including TLS) (README.md, "Last real run" table).

1.2 Dissection (this is the part to copy)

State sent to Jev (engine.py: build_state): a compact object, not the whole call.

call_facts: {duration_min, talk_ratio_rep, stage_history[-6:], known_facts[], objection{open,type}}
recent_transcript: last 12 utterances [{t, speaker, text}]
latest_utterance: {t, speaker, text}

RECENT_WINDOW = 12 (constants.py:25). Facts detected earlier persist in code and are fed back as known_facts, so "ask about budget" stops being suggested once budget is known.

Questions (constants.py:118-269), all with full sentences referencing backticked state paths (latest_utterance.text, recent_transcript):

Speaker masking in code: speaker-specific Nouls are asked every turn and zeroed in code when the speaker does not match (engine.py: extract_features, PROSPECT_ONLY_SIGNALS, REP_ONLY_SIGNALS). Rationale in README: "Jev is literal; conditionals belong in code."

Closing probability = code (constants.py:284-322, engine.py: composite):

inst = STAGE_PRIOR[stage] + sum(w_i * x_i)      # nouls/facts/code signals: w*x; scores centred: w*(x-0.5)*2
p_t  = 0.40*inst + 0.60*p_{t-1}                  # EMA, clamped [0.03, 0.95]

18 weights in SIGNAL_WEIGHTS (e.g. prospect_disengaging -0.16, commitment +0.15, objection_open -0.14, rep_talking_too_much -0.10). Every raw answer is stored per step (Step.answers), so changing a weight in the UI recomputes the whole timeline with zero new Jev calls (README: "change a coefficient, not a prompt"). A sensitivity panel shows the three contributions that moved most.

Confidence gates (constants.py:324-337):

decision gate
show coaching card next_move.confidence >= 0.35, else "listening..." (leaning move greyed)
highlight a phrasing phrasing::<move>.confidence >= 0.30
open objection prospect_objecting >= 0.60 on a prospect turn; type from objection_type if confidence >= 0.40
clear objection acceptance/buying/commitment/next-step Noul >= 0.60 AND prospect_disengaging < 0.60; or 8 utterances without re-raising
persist a fact Noul >= 0.70
light a signal Noul >= 0.60

The objection lifecycle (engine.py: _update_objection) has one non-obvious rule worth keeping: "a disengaging turn never clears an objection" ("Sure, okay, I have to run" is not acceptance).

Playbook as data (data/playbook.json): 15 moves, each {id, title, what, not_for, phrasings[3]}. what/not_for become the Choice option descriptions; phrasings are candidate rep lines. The README's phrase: "Jev picks; code shows the text."

Tailored phrasing (copilot/personalize.py, constants.py:339-376): only when the move changed, a new fact locked, or the same move held 8 utterances; cooldown 2 utterances; Claude Haiku 4.5 writes one sentence <= 32 words from the last 6 utterances + known facts + the move's generic lines; code validates length; Jev then answers two Nouls on the candidate (invents_fact drop if >= 0.5, on_move drop if < 0.5); a stale check drops it if the move changed meanwhile. Off the critical path (~1 s later via a separate WebSocket message). Real run: 7 LLM calls over 48 utterances, 2 shown, 5 dropped (one for inventing a feature, invents_fact 0.80).

Eval harness: 25 unit tests on the arithmetic; 19 hand-labeled utterances with 56 threshold checks against the real API (eval/integration_report.json: "passed": 56, "total": 56, model pinned jev-1.13.0; each case records observed values, e.g. price objection -> prospect_objecting 0.98, objection_type price (1.00), next_move handle_price_objection_roi (1.00)); replay e2e asserting the good call ends >= 0.70 and > bad + 0.30, etc. Transcript format (data/calls/cloudtalk.json): {id, title, description, expected, source, video{youtube_id,start}, utterances[{t, t_end, speaker, text}]}.

1.3 Stated limitations (README "Limitations")

No diarization in the browser (Web Speech API, Chrome only, manual speaker toggle); rolling 12-utterance window only; objection_type is asked speculatively and will name a type even for a neutral price question (hence the separate prospect_objecting gate); weights tuned on 3 hand-written calls + 19 labeled utterances ("treat them as starting points"); phrasing Choices add ~1,900 tokens/~20 ms; model pinned, re-run integration test on upgrade.

1.4 CT-transfer

Everything in 1.2 is domain-agnostic scaffolding and should be ported to TypeScript on Workers more or less one-to-one: state shape, question-authoring style (full sentence + backticked path + {true,false} examples), speaker masking, fact locks fed back as state, objection lifecycle, confidence gates, playbook-as-data with what/not_for, stored raw answers + free recompute, the labeled-utterance integration test, and the JSON transcript format. What must be re-authored for CT: the stage set (onboarding vs customer-success have different stages), the objection taxonomy (rate, safety/security of funds, settlement timing, fees, "I'll use my bank"), the durable facts (assumption, to be validated with Stevan: e.g. safeguarding_explained, fees_disclosed, rate_mechanism_explained, settlement_timeline_explained, kyc_docs_requested, next_step_agreed), the playbook moves and phrasings (which for a regulated FX firm may need compliance sign-off, which "Jev picks, code shows" supports well), and the weights. The closing-probability hero should probably become a scenario-appropriate score (e.g. "onboarding completion likelihood" / "retention risk") but the arithmetic is the same.

2. Other open-source Jev call, meeting, sales and support copilots

2.1 ZeroGold/call-coach-ai (MIT, 42 stars, 8 forks)

[web] https://github.com/ZeroGold/call-coach-ai, schema.json, public/decide.js, public/playbook.js.

What: browser mic -> Web Speech API -> Node proxy injects the key -> one Jev request per speech turn over the last 40 turns -> a Choice next_best_action (8 options incl. no_action), a 4-level Score buying_stage, and 7 Nouls (asked_about_pricing, mentions_timeline, discusses_budget, decision_maker_involved, uses_ownership_language, has_blocking_objection, is_returning_prospect). UI: buying gauge 0-100, stage label, one suggested action with up to 3 tips, speaker toggle (S), dismiss (D).

The reusable part is decide.js, a pure local decision layer whose comments read like a spec:

minScore 0.4        below this the screen says "Keep listening"
tieMargin 0.08      options within 8 points of the leader count as tied -> broken by playbook priority
switchMargin 0.12   a challenger must lead the current suggestion by this much to replace it at once...
confirmUpdates 2    ...or stay on top for this many updates in a row (stops flickering)
minRemaining 0.3    if skipped options held >70% of the probability, the rest is too thin to trust
doneCooldownMs 3min rep marks an action done -> skipped for 3 minutes
stageSmoothing 0.8, stageHysteresis 0.05   stage changes only when the smoothed score passes a boundary by 0.05
confidenceHigh 0.7 / confidenceMedium 0.45 -> "High/Medium/Low confidence" label

Plus playbook rules (has_blocking_objection >= 0.7 blocks send_proposal, with a note shown when a rule overrode the model's top pick) and priority ordering for ties. Tips are conditional on Noul signals ({signal, min|max, text}).

CT-transfer: the hysteresis/switch-margin/confirm-streak/cooldown/rule-block set is exactly what keeps a live card steady; adopt it wholesale. The "rule overrode the model, here is why" note is a good honesty affordance for reps.

2.2 wsmoak/jev-sales-calls

[web] https://github.com/wsmoak/jev-sales-calls.

What: reads a whole call transcript against a capability library (one markdown file per capability with YAML frontmatter id, name, category, summary, tiers; only summary is sent to the model). Each capability is auto-converted into a Noul ("did the prospect ask for it or say they need it" = true; "the rep pitching it does not count" = false). 26 questions ride in one ~5,000-token request. Recommended tier is a deterministic lookup (cheapest tier containing all capabilities above threshold), not a question. Also a Choice primary_blocker and a Score deal_temperature.

Its key insight is the closed-world failure: a prospect asking for something not in the library "produces a confidently wrong report". Mitigations added: unlisted_request (flag that an extraction pass is needed), rep_declined, and rep_misinformed ("whether reps incorrectly denied capabilities the product ships, a coaching signal"). Transcripts are generated from the library brief by a separate model across four scenario types to exercise each flag.

CT-transfer: the library-to-Nouls generator is the right shape for a CT fact/topic library (rates, fees, safeguarding, settlement, limits, supported currencies/corridors, onboarding documents). rep_misinformed is directly useful for customer-success QA ("rep said we can't do X but we can"). Always include the unlisted/none escape hatch. Synthetic transcripts per scenario are a cheap way to build the first test set before real transcripts are cleaned.

2.3 zfrqbl-CW/jev-support-copilot

[web] https://github.com/zfrqbl-CW/jev-support-copilot.

What: as a support agent types a reply, one parallel Jev request scores tone (Choice: empathetic/neutral/curt/defensive), commitment risk (Noul: promises about refunds/timelines), escalation flag (Noul), predicted satisfaction (Score). WebSocket server; two-layer cache (settled + in-flight, so identical text arriving during a pending call is deduplicated); measures Jev latency and keystroke-pause-to-screen round trip; mock mode from text hashing when no key.

CT-transfer: the "commitment risk" Noul is a compliance-relevant idea for CT (rep promising a rate, a settlement date, or "guaranteed" anything). The in-flight cache is a small but real engineering detail for a live stream where the same partial text can be re-sent.

2.4 abhitsian/cuecard (macOS menu-bar meeting copilot, MIT)

[web] https://github.com/abhitsian/cuecard.

What: two-sided on-device transcription (mic via AVAudioEngine, system audio via Core Audio process tap, each into its own SpeechAnalyzer, so every sentence is attributed to you or them). Jev categorises each finished turn (~0.4 s) into Asked You / Action Item / Decision / Open Question / Next Step / Risk-Blocker / Key Fact, applies mode-specific signals, matches open questions, picks prepared questions. Claude (via claude -p) writes SAY/ASK cards when a prepared one does not fit. Latency budget quoted: transcription ~0.3 s after speech ends, categorisation ~0.4 s, first LLM output ~0.8 s, total ~1.5 s. Seven meeting modes including "Customer Call". Output filtering is deterministic: "maximum two captures per turn, one signal card per turn, no repeated suggestions within four minutes". Panel hides during screen sharing.

CT-transfer: per-turn cue budgets and a repeat suppression window are the alert-fatigue controls the commercial products describe but do not quantify. The mode concept maps onto CT's two scenarios (onboarding vs customer success) as different signal sets and question banks over the same engine.

2.5 moritzkremb/jev-voice-browser (MIT, 110 stars)

[web] https://github.com/moritzkremb/jev-voice-browser.

What: streams partial Web Speech transcripts, debounces 200 ms, one Jev call per transcript update (11 questions incl. is_command, intent, complete, destructive, is_correction). Commit rules: is_command >= 0.5, intent.confidence >= 0.55, complete >= 0.6, or 900 ms silence, or a final result; free-text intents wait for finality or 600 ms silence. Measured ~330 ms average Jev latency (p50 ~300 ms), 3-6k tokens/request, ~$0.0002/call; first request ~700 ms (TLS). Thresholds "calibrated for jev-1.13.0... should be re-checked for model updates".

CT-transfer: this is the reference for acting on interim STT results (Workers AI Flux emits interim text too, see 2.7). A complete Noul plus a silence timer decides when an utterance is "done enough" to fire the fan-out; a is_correction Noul lets a rep verbally retract.

2.6 AiPersonacademy/jev-sales-radar (Rust, MIT, 0 stars): caution

[web] https://github.com/AiPersonacademy/jev-sales-radar, src/engine/jev_gateway.rs, src/rag/playbooks.rs, Cargo.toml.

README claims a "TypeSafe Jev System One Gateway (20ms)" that "detects hidden fears" and predicts the next objection, then serves counter-scripts from Voss/Klaff/Rackham/Cialdini/Challenger in <25 ms. The code does not call Jev: Cargo.toml has no HTTP client, jev_gateway.rs does an in-memory Battlecard::find_best_match(query) over trigger_patterns (literal strings like "too expensive", "over our budget") and hard-codes confidence: 98.4 and model: "jev-system-one-local". Treat it as a keyword battlecard demo, not Jev evidence.

What is still useful: the battlecard schema is a good checklist of fields for a CT objection card: category, trigger_patterns, state_of_being, customer_unspoken_thought, customer_next_trajectory, framework_name, psychological_principle, exact_script, secondary_followup, tone_delivery_guide, and its 10 categories (PriceAndBudget, GuaranteesAndRisk, ReviewsAndSocialProof, TimingAndStalling, AuthorityAndPartner, TrustAndSkepticism, StatusQuoAndDiy, BandwidthAndTime, CompetitorComparison, GeneralDiscovery) are a reasonable superset to prune for FX. The 70/30 talk-ratio meter is also on screen.

2.7 harshil1712/slidepilot (Cloudflare Agents + Workers AI Flux STT + Jev): the closest Cloudflare architecture

[web] https://github.com/harshil1712/slidepilot (4 stars).

What: "Slidev addon -> VoiceClient -> Cloudflare Voice Input Agent -> Workers AI Flux STT -> Jev -> policy -> Slidev navigation". Mic audio streams over WebSockets to a Cloudflare Agent (Durable Object); Workers AI Flux (Deepgram) produces interim text and completed utterances ("Flux streaming STT works with a local Durable Object and Wrangler's remote Workers AI binding"). Jev answers four Nouls per utterance (advance feels natural / core idea complete / presenter still speaking / natural boundary). "TypeScript, not the model, applies the navigation policy": thresholds advanceThreshold 0.68, completeThreshold 0.65, stillExplainingCeiling 0.55, confidence 0.30 minimum; advanceDelayMs 1000 cancellable if the speaker resumes; cooldownMs 2000; staleness guards. Limitations: thresholds need rehearsal calibration; large state truncated server-side; audio processed by Workers AI/Deepgram Flux only.

CT-transfer: this is the pipeline skeleton for the live phase: one Durable Object per call session holding the rolling window and facts, Flux for streaming STT with interim/final events, env.AI.run('typesafe/jev', ...) per completed utterance, policy in TS. Assumption: Flux gives no speaker diarization in that setup; CT will need either a diarized feed from the telephony platform or two audio legs (as cuecard does), which is the same limitation the reference copilot notes.

2.8 Cloudflare-side Jev demos

2.9 Admin-curation prior art (how others let humans define "good")

CT-transfer: the CT admin console should (a) store every raw answer per utterance, (b) treat weights/thresholds/playbook text as a versioned policy whose edits recompute historical calls for free, (c) capture per-utterance corrections ("this was a safety objection, not a fee question"; "this move was wrong here") and show the lowest-confidence items first, and (d) keep rep-quality and call-outcome scores separate.

2.10 Not Jev, but adjacent

3. madewithjev.com: relevant builds

[web] https://madewithjev.com/ (295 builds, 91 guides at fetch; per-build pages under /builds/<slug>). Entries relevant to calls, sales, support, coaching, real-time, voice, or routing, with what each contributes:

build author what it does CT-transfer
/builds/sales-copilot Moritz Kremb the reference above section 1
/builds/realtime-clippy Marek Sotak assistant that "only wakes up when it thinks you're struggling" ("Hesitating? Confused? Stuck?"), reactions themselves gated by Jev the silence-by-default stance: cue only on detected struggle/objection, not continuously
/builds/mac-app-support-answers Malek Ould-Oulhadj Jev routes user questions to built-in manual articles; "the whole built-in manual as state"; handles paraphrases, typos, FR/DE/ES, features that don't exist; "42/42 on a held-out set", median 0.93 s; "Jev decides, the app answers from its own docs" the pattern for a CT knowledge card: Jev picks which approved answer (fees page, safeguarding explainer, settlement timeline), code shows the vetted text; include a "no article" option
/builds/no-llm-chat-bot CJ (Coding Garden) Jev "picks the tool and its arguments"; "instant, no hallucinations" same: closed-set answer/tool selection
/builds/on-device-audio-pipeline Desert Ant Labs on-device STT (Voz) + language detect (Ear) + PII redaction (Redact); "Jev makes about 20 decisions in one call and picks which local model runs" a redaction stage before transcripts leave the device/edge is the privacy pattern CT will want for client PII
/builds/ambient-assistant Max Blade always-on, no wake word; "knows (from probabilities) if I'm asking my computer to do something or blabbering" is_addressed_to_me-style gating Noul
/builds/voice-computer-assistant Marc Kohlbrugge local Whisper + accessibility tree as closed options; "Jev decides which action to take" closed-option selection over screen state
/builds/lead-outreach-scoring Roman 700 leads scored in 40 s for $0.09; flags lead/message mismatches batch scoring economics for the historical transcript corpus
/builds/inbox-triage-1500-emails, /builds/500-emails-3-cents vogel, Riley Brown volume/cost anecdotes (500 emails for 3.5 cents) same
/builds/fraud-detection-jev-kimi Hassan Jev first; anything under 95% confidence escalates to Kimi K3; 100 emails, 1.42 s, 96/100 correct, ~$0.07 (Jev $0.003, Kimi $0.068) cascade: Jev gates, expensive model only for the uncertain band
/builds/slack-agent-skill-routing John Yeo Jev pre-picks skill/tool/params before the agent runs; 2x faster pre-routing before any generative step
/builds/jev-moderation-bot, /builds/agent-safety-monitor, /builds/pi-heed various safety/verification uses same shape as compliance checks on rep speech
/builds/job-match-prediction Sarvagya Kulshreshtha 400 companies matched to one candidate many-vs-one scoring
/builds/typesafe-ai-playground Val Alexander 110 editable use-case prompts with A/B comparison (github.com/BunsDev/typesafe-ai-playground) quick place to try question wording
/builds/predictive-launcher, /builds/live-viral-post-analyzer, /builds/gesture-canvas nader dabit, Riley Brown, Jack Cheng real-time/voice demos evidence of sub-second UI loops

Directory metadata: madewithjev.com/github-repos lists 275 repos; awesome-jev-use-cases (github.com/walidboulanouar/awesome-jev-use-cases) adds two more voice entries (jev-use (voice), jev-use (mac), 87 stars) and quotes the limits page: "reads literally, is weak at math, counting and dates", "accuracy drops with irrelevant state", "$42 per billion input tokens, and output tokens are free".

4. TypeSafe official material (local copies) and which parts apply

All paths under /home/stevan/dev/jev/docs/vendor/typesafe/.

4.1 Patterns (patterns.md, patterns__*.md)

4.2 Concepts

4.3 Demos

4.4 Cookbooks that apply (with the numbers)

cookbook (file) what it shows CT-transfer
cookbooks__parallel_questions.md 13 questions over a 54k-char document: batched vs single calls give identical answers (std dev 0.0 on 11/13; the two noisy ones equally noisy either way); one call $0.000497 / 0.27 s vs 13 calls $0.006090 / 2.71 s: "12.2x cheaper, 10.0x faster" justifies one request per utterance with 30-50 questions
cookbooks__classification_using_confidence.md 75-way Choice; at confidence >= 0.9 the confident half is right 90%, the unsure half 40%; reporting the parent division for unsure cases lifts them to 70% when objection_type is unsure, show the parent bucket ("concern about money" vs "rate" / "fee") rather than nothing
cookbooks__consistency_noul_cookbook.md 14 Nouls on an insurance claim repeated 15x: Jev mean per-question std dev 0.0102, below all LLM conditions; a borderline covered answer spanned 0.43-0.53 across a 0.5 threshold; 0.30-0.70 mapped to an explicit uncertain outcome for human review define an uncertain band per gate; never let a cue depend on a 0.5 knife-edge
cookbooks__consistency_choice_cookbook.md 8 moderation Choices repeated 15x; plurality label repeated 90.8%; requiring top probability >= 0.60 raised agreement to 99.2% with automatic labels on 74.2% the same >= 0.60 style floor for stage/objection labels
cookbooks__autoresearch_feature_discovery.md LLM proposes questions, Jev answers them per row, CatBoost trains on the answers against a real outcome; 38 questions after 5 rounds beat asking for the score directly (RMSE 1.77 vs 2.15) and word counts (2.47); "Next steps" include screening candidate questions with Nouls before paying to answer them CT has ground-truth outcomes (onboarded? traded? churned?). Run this over historical transcripts to discover which signals predict outcomes, then use them as weights instead of guessing
cookbooks__skill_suggestion.md Choice over 182 skills + Nouls "need a skill at all?"; two-request rank-then-verify; wrong loads cut from 16.8% to 7.3% two-stage move selection if the CT playbook grows large: Choice over all moves, then re-check the top 3 with full text
cookbooks__semantic_find.md Choice over line IDs to point at the answering line + a Noul exists because "Choice probabilities always add up to 1, so some line ranks first even when the document doesn't answer"; thresholds FOUND 0.7 / ABSENT 0.35 pointing at the right knowledge-base paragraph for a live answer card, with an existence check
cookbooks__llm_guardrails.md one request screens an LLM input/output with a Noul battery + harm Score, thresholds decide pass/review/block/support screen any generated phrasing (and, later, rep speech) for prohibited claims ("guaranteed rate", advice)
cookbooks__sde_cascade.md cheap model extracts, Jev per-field Nouls verify (FIRE_T 0.7), expensive model only when a verifier fires the tailored-phrasing verify step generalised
cookbooks__hierarchical_classification.md beam search over a taxonomy with Choice at each node; observability per node if CT's topic taxonomy becomes deep (product > corridor > issue)
cookbooks__classifying_rag_passages.md, cookbooks__rerank_typesafe.md Nouls per query-passage pair (relevant / usable / contradicts / instructs the model); BM25 shortlist then Noul re-rank (top-1 5% -> 18%) selecting which historical "good call" snippet or KB passage to surface
cookbooks__function_calling.md closed-set arguments become Choices, an optional argument gets a stated Noul, the request's confidence is the least certain judgement if the copilot ever fires actions (create task in CRM, send document link)
cookbooks__date_extraction_cookbook.md extract date parts as Choices, compare in code settlement dates and value dates mentioned on calls

4.5 TypeSafe workflow evals

[web] https://evals.typesafe.ai/ lists four workflow evals; customer_service is the relevant one: "Decide what customer service assistants should communicate and execute next" (actions SAY / REFUND / FREEZE CARD / SET INTENT / HAND OFF / FLAG FOR REVIEW / CLOSE), structured as (1) an initial assessment across eleven dimensions, (2) conditional follow-ups only when warranted, (3) integrity verification of assistant claims against records, (4) policy execution in nine safety-first sections. Reported: "Sol workflow 78.3% $0.0323 10.1 s", "DS v4 flash workflow 76.8% $0.0029", "Luna workflow 71.4% $0.0013 8.8 s", "Haiku 4.5 workflow 55.4% $0.0074". CT-transfer: the four-stage decomposition (assess -> conditional follow-ups -> verify claims against records -> policy in code) is a template for the customer-success scenario where the copilot could also check "did the rep's statement match the client's actual account state" if CRM/trade data is in the state.

5. Third-party write-ups

CT-transfer from these: design Noul-first (best calibrated), use Score sparingly and never for numeric magnitude, keep a CT-specific labeled set and measure calibration per question type before choosing thresholds, and expect Jev to be good-but-not-magic on accuracy (68% internal benchmark claim; the wins are cost, latency, calibration and consistency).

6. Commercial real-time sales coaching products (design reference only)

Nothing here is Jev-based; the point is how live cues are presented and configured. All are vendor or third-party marketing claims unless stated.

Balto ([web] https://www.balto.ai/, https://www.balto.ai/real-time-agent-assist/, search snippets from balto.ai/real-time-guidance/, cxponent.com, wiki.wfmlabs.org): connects to the phone/contact-centre system, converts speech to text, "matches phrases against rules, playbooks, and scoring models", pushes prompts to the agent and alerts to managers. UI: Dynamic Prompts ("phrases and questions when they need them most"), Smart Checklist ("tracks completion of required conversation elements, such as identity verification steps, disclosure statements, and closing procedures... checked off automatically, providing agents with a live progress view"), Playbook Designer (managers "author call flows and trigger prompts without code"), live manager alerts, AgentGPT knowledge answers "from proprietary knowledge bases", pain questions with outcome nudges ("This question could reduce your no-shows by 20%"). A third-party page claims "sub-200ms latency" (unverified). Agents pin/collapse modules to control density; layouts persist.

Cresta ([web] https://cresta.com/agent-assist, https://cresta.com/blog/what-is-real-time-agent-assist-and-how-does-it-work): "real-time hints, reminders, and workflows tailored to each conversation"; Knowledge Assist "combines what's being said with on-screen context to deliver exact, source-backed answers" with sources shown; checklists that "generate throughout each conversation" (e.g. "Verify identity", "Explain the waiver", "Offer two flight options"); behavioural hints "trained on top performers and successful outcomes"; no-code "Opera" workflow engine; "near-zero latency". Their pipeline article: "Every step inherits the quality of the one before it... If transcription lags, every downstream prompt lags with it"; "Guidance that arrives after the agent has already answered is a report, not assistance. Latency is the whole game"; static scripts "break the moment a conversation goes off-track, and agents learn to ignore them".

Attention ([web] https://www.attention.com/, /solutions/sales-reps, /product/ai-coaching-scorecards, search snippets): "AI powered battlecards help you answer any prospect question while on the call"; scorecards graded post-call against "MEDDIC, BANT, SPICED, or your own framework", and teams "build and assign multiple scorecards based on role, region, deal stage, or product"; insights pushed to Slack/Notion/Sheets. Battlecard triggering details are not published.

Gong ([web] https://www.gong.io/product/, https://www.oliv.ai/blog/gong-features, search snippets from lindy.ai, medium.com/@solironus): post-call conversation intelligence: recording, transcripts, Smart Trackers (keyword-based; "cannot tell 'we looked at Salesforce years ago' from 'we are in a bake-off with Salesforce right now'" per oliv.ai), talk ratios (a lindy.ai snippet cites top performers at "43:57"), coaching scorecards, call libraries, deal-risk warnings. Multiple sources state Gong has no in-call intervention: "Gong will flag it after the fact, not during."

Chorus (ZoomInfo) ([web] https://www.zoominfo.com/products/chorus): post-call; "average talk time, average filler words, and actionable tagging"; "winning behaviors that uplevel team skills"; no live assist on the page.

Meeting copilots and dialers ([web] https://www.itsconvo.com/blog/real-time-sales-coaching-software, a competitor's comparison): Convo (on-screen overlay, objection-handling frameworks, BANT/SPICED/MEDDPICC fill-in, talk-to-listen nudges, local audio capture so the overlay is hidden from screen share); Avoma Answer Cards ("Cards appear on screen for 20 seconds; framework checklists tick off MEDDIC or BANT topics", triggered by pre-configured keyword/phrase); Clari Copilot (live battlecards fired by keywords/topics); Cluely (overlay measured at "4 to 7 seconds" delay, "arrives after needed moment passes"); Trellus and Dialpad (coach cards inside dialers).

Design takeaways for the CT dashboard

  1. Two persistent surfaces: a checklist of required items that ticks itself (this is the copilot's fact locks with a UI), and a stage strip.
  2. One transient surface: a single cue card (objection card or next-move card) with a short "say" line and a why; hold it steady (hysteresis), expire it (20 s in Avoma's case; cooldown in cuecard/call-coach-ai), and default to "listening".
  3. Knowledge answers must be source-backed and pre-approved text (Cresta shows sources; the mac-app-support build answers only from its own docs). For a regulated FX firm this is also the compliance story.
  4. Manager side: a playbook designer (trigger -> card), scorecards per scenario (onboarding vs customer success), and post-call review metrics (talk ratio, longest monologue, items missed).
  5. Latency budget: sub-second from end of utterance to cue, or it is "a report, not assistance". The Jev numbers (300-500 ms) plus STT finalisation (~300 ms on-device in cuecard) fit; a generative step does not, which is why generation belongs off the critical path.

7. Gaps: what prior art does not cover for CT

8. Ranked: the 10 most useful transferable ideas

  1. One speculative fan-out request per utterance; code owns every number. Ask all ~30-50 questions every turn (signals, facts, stage, objection type, next move, per-move phrasing), mask irrelevant ones in code, combine with weights/EMA in code. Evidence: reference copilot (37 questions, ~350 ms, ~$0.0003/request); patterns__fan-out.md; cookbooks__parallel_questions.md (12.2x cheaper, 10x faster, identical answers).
  2. Playbook as data, with contrastive what / not_for option descriptions; Jev picks, code shows the text. Author separate onboarding and customer-success playbooks (moves + 2-3 approved lines each) and stage sets; the same engine loads either. Evidence: data/playbook.json; concepts__how-to-build-with-system-one.md contrastive criteria; mac-app-support-answers (answers only from own docs, 42/42).
  3. Store raw answers; make weights, thresholds and playbook text a versioned policy that recomputes history for free. This is the admin "what good looks like" console: change a coefficient or threshold, every past call re-scores with 0 Jev calls; only new questions cost tokens. Evidence: copilot "Apply weights -> 0 Jev calls"; cv-screen ("about 20 ms and costs exactly nothing"); patterns__composite-scoring.md.
  4. Confidence gates scaled to risk, an explicit "listening" state, and anti-flicker mechanics. Per-decision thresholds (higher for "quote the rate" than "ask an open question"), an uncertain band routed to nothing/human, switch margin + confirm streak + cooldown + rule blocks, one card per turn, no repeat within N minutes, card expiry. Evidence: copilot gate table; call-coach-ai/public/decide.js; cuecard (max 2 captures/turn, no repeats within 4 min); slidepilot cooldown/staleness; patterns__confidence-routing.md; consistency_* cookbooks (0.30-0.70 = uncertain; >= 0.60 floor).
  5. Durable fact locks fed back into state = the smart checklist. Once a Noul >= 0.70 says "safeguarding explained" / "fees disclosed" / "settlement timeline explained" / "next step agreed", persist it in code, tick it in the UI, feed it back as known_facts so the copilot stops suggesting it. Evidence: copilot FACT_PERSIST_THRESHOLD; Balto Smart Checklist; Cresta generated checklists.
  6. Cloudflare-native pipeline: Durable Object per call session + Workers AI Flux streaming STT (interim vs final) + env.AI.run('typesafe/jev') through AI Gateway + policy in TypeScript. Replay mode first (JSON transcripts over WebSocket), live mic second. Evidence: slidepilot; flue-jev-demo (no keys, Gateway logs); zeke/jev; [local] cloudflare/ai__models__typesafe__jev.md (32k context); jev-voice-browser for acting on partial transcripts (complete Noul + silence timer).
  7. State and question hygiene against Jev's jaggedness. Rolling window (12 utterances) plus compact facts, not the whole call; speaker masking in code; literal, single-judgement questions with backticked paths and {true,false} examples; a none/unlisted option in every Choice and an existence Noul beside any "which one" Choice; never compare a Noul threshold with a Choice threshold; arithmetic, counting and dates in code. Evidence: model-jaggedness__jev-1.13.md; wsmoak/jev-sales-calls (unlisted_request, rep_misinformed); cookbooks__semantic_find.md (exists); cookbooks__skill_suggestion.md.
  8. A hand-labeled CT utterance suite with threshold checks, run against the pinned model, before any tuning. 20-40 utterances covering rate, safety, settlement, fees, timing objections, acceptance, disengagement, rep monologue, etc.; assert Noul/Choice ranges; plus replay assertions on a good, a bad and a recovered call. Measure calibration per question type on CT data (Noul best, Score worst). Evidence: copilot tests/test_integration_jev.py / eval/integration_report.json (56/56); primeline (ECE 0.012 / 0.086 / 0.254; "benchmark your own task"); jev-voice-browser thresholds "re-checked for model updates".
  9. Generative text only off the critical path, and only after Jev verifies it. The generic approved line shows immediately; a tailored sentence may arrive ~1 s later only if a small LLM wrote it and Jev's invents_fact / on_move / (for CT) makes_promise_or_guarantee Nouls pass. Consider keeping it off for onboarding until compliance signs off. Evidence: copilot personalize.py and VERIFY_QUESTIONS; demos__smart-home.md; cookbooks__llm_guardrails.md; cookbooks__sde_cascade.md; fraud-detection-jev-kimi (95% gate).
  10. Outcome-driven curation of "good": store corrections, surface the least confident items, and learn signal weights from real outcomes. Admin marks per-utterance corrections that are kept and shown on later runs; an "Unsure" queue sorted by lowest confidence; keep rep-quality and opportunity-quality scores separate; then run the autoresearch loop over historical transcripts with outcome labels (onboarded / first trade / retained) to discover which questions actually predict outcomes and set weights from data rather than guesses. Evidence: jev-triage; semarize blog; cookbooks__autoresearch_feature_discovery.md (38 discovered questions, RMSE 1.77 vs 2.15 asking directly); concepts__use-case-map.md (feature extraction); kenhuangus/jev-usecases (thresholds "not fitted to a measured false-positive rate" is the trap to avoid).

9. Source index

Local files read:

Web (fetched 2026-09-24):

7,592 words · Internal working documents. Do not share outside CurrencyTransfer.