This console is the chat test bench — real phone calls are live via the Bland bridge. Sentiment starts at 100 for every conversation and any drop to 50 or below hard-escalates to a human — the same rule on chat and on the phone line. Live telephony runs through Bland AI (pathway → webhook brain → same KB/registrar/QA); completed phone calls land in Calls & QA automatically. Configure it on the Architecture tab → Live telephony — Bland bridge. Genesys Cloud CX remains the named production slot via the GenesysAdapter.
Start a simulated call
Pick which participant is calling. Their registrar record becomes the agent's only source of account truth.
The AI agent greets the caller first.
Orchestration pipeline
What the platform is doing on each turn — grounding, LLM calls, guardrail slots.
Idle
Start a call to see the pipeline.
Operations floor
AI agents answer calls themselves. Watch any call live, or jump in as the human agent — the caller keeps talking to whoever is on the line.
Completed calls
Every ended call is transcribed, sentiment-mapped and QA-scored automatically by the QA model — 100% coverage, no sampling. Click a call to open the full record.
| When | Caller | AI agent · senior | Topic / intent | Turns | Outcome | Final sentiment | QA score |
|---|---|---|---|---|---|---|---|
| No calls yet — take one in the Call console. | |||||||
QA Overview
Real-time view of quality performance across the global contact centre · 100% of interactions evaluated
Compared to the previous equivalent period · live
QA performance by region
Regions = operating teams (EMEA · LATAM · North America)
QA score trend
Per scored interaction, chronological
Quality signals
Areas requiring attention
QA category health, weighted-normalised
Compliance breakdown
Guideline adherence classification
Top insights
Auto-generated from this period's data
Drill down: QA score by country
| Country | Region | QA | vs prior | Compliance | Critical fail | Resolution | Calls | Trend |
|---|
Quick actions
Calibration status slot
Human-vs-AI QA calibration sampling arrives with the human QA team workflow — reserved.
Illustrative: 87% agreement target track
Human performance — takeovers & escalations
| Human agent | Team · country | Calls handled | ID verification compliant | Resolved | Caller had to call back | Avg professionalism |
|---|
AI performance — guideline adherence
| AI agent | Senior · team | Calls | Avg QA | Guideline adherence | Escalation rate | Callback rate |
|---|
Sentiment & drivers
Post-call sentiment distribution
Across all recorded calls in this workspace
Negative CX triggers
Utterances the QA model pinned as the cause of sentiment drops, aggregated.
Recent QA results
| Call | Outcome | QA | QA summary |
|---|
This is the "share plan brain" from your flow — the Build layer. Articles here are injected into the AI agent's context on every turn and are, alongside the caller's registrar record, its only permitted source of truth. Edit an article and the agent's behaviour changes on the very next call. Stored in this workspace via persistent storage.
Ticket mining — build the KB from resolved history
Upload past resolved tickets in bulk. The AI mines them for generalizable rules, procedures and resolutions, merges duplicates, and produces draft articles for the queue below. Nothing enters the live KB without your approval.
Before uploading: use anonymised/redacted exports only — strip participant names, account numbers, emails and any personal data. The miner is instructed to generalise and exclude identifiers, but redaction at source is the control that counts.
Draft articles — awaiting human approval 0 pending
Approve to publish into the live KB (the agent starts using it on the next call), edit first if it needs work, or reject.
Articles
New article
Plan rules, procedures, FAQs. Keep each article focused — the agent cites them by title.
Guardrails — placeholder. A policy layer (blocked topics, mandatory disclosures, PII rules) will sit between the KB and the agent. Slot: Guardrails.check(turn) in the Architecture tab. Currently only prompt-level rules apply (verification gate, no-advice boundary).
Systems-of-record integration, self-service. Register an API here (registrar, HR, dealing, or any new client database) and the AI agent can call it as a tool mid-call: it raises an api_call action, the platform executes the connector, and the reply is grounded in the result. Use Mock mode to define the response shape now and demo end-to-end; flip to Live when the real endpoint exists. Note: live calls from inside Claude's sandbox may be blocked by browser policy — in production these execute server-side.
Registered connectors
New connector
The description is what the agent reads to decide when to use it — write it like an instruction. Put path parameters in {braces}.
Security note: never paste real credentials, tokens or keys into this prototype — use placeholders. Production connectors hold secrets server-side in a vault, never in the browser.
Recognised callers
People on this list are recognised when they phone in: the agent greets them by name, treats them as identity-verified and can discuss their share plan record. Everyone else is handled as an unverified caller — general help only.
Callers who withhold their number can't be recognised, even if they're on this list.
Stack — as per the agreed flow
Buy / Integrate / Build status for each layer, and where its code slot lives in this app.
☎
Interim telephony (AI line) — Bland AI Integrate LIVE via bridge
Real phone calls today, ahead of the Genesys build: a Bland conversational pathway owns STT/TTS, barge-in and turn-taking, and calls this platform's webhook brain (/bland-webhook) every turn — same KB grounding, verification gate and sentiment-escalation rule as chat. Completed calls flow back through the post-call webhook into the same QA pipeline and dashboards. Configure below in Live telephony — Bland bridge.
☎
Reception line & live monitoring — Twilio Integrate LIVE — v1.17
Human-routed calls: Twilio answers the inbound number, starts native real-time transcription of both tracks, then bridges the caller to the specialist's phone — one webhook per utterance feeds Calls tab → Live now with rolling sentiment and a provisional QA pass while the call is still up. A browser softphone (WebRTC, Twilio Voice SDK) calls the same reception line for free. Twilio owns this leg because Bland stops transcribing the moment a call is transferred to a human — its transcription attaches to the AI, Twilio's to the call media.
1
CX platform — Genesys Cloud CX (client standard) Integrate Slot — not connected
The client already runs Genesys Cloud CX, so it owns PSTN/carrier, IVR (Architect flows), ACD queueing and the human-agent desktop. This app exposes GenesysAdapter with four reserved touch-points (detailed below) so chat and voice arrive without touching the orchestrator. Both interim voice seams map 1:1 onto Genesys: the per-turn webhook → Bot Connector, the per-utterance transcript stream → transcription notifications / AudioHook (note: voice transcription is license-gated — CX 3 or an add-on). NICE CXone / Five9 remain documented alternates only.
2
Voice AI agent — brain, speech & reasoning Buy / orchestrate LIVE in this v1
Running on Anthropic's API behind a provider-agnostic adapter — the reasoning loop, grounding, sentiment and escalation flags all work today. STT/TTS arrives with the telephony layer (or Sierra/Decagon/Cognigy if bought as a bundle).
3
Identity & fraud shield Integrate Stub — simulated
Candidates: Pindrop · Nuance Gatekeeper. The gate is already enforced: when the stub reports "failed", the agent's context is stripped of account data and it can only give generic help + route to verification.
4
Share plan brain & integration Build LIVE in this v1
The Knowledge Base tab (plan-rules corpus: vesting, dealing windows, leaver logic) + simulated registrar records standing in for the systems-of-record APIs.
5
Systems of record — via the connector registry Existing Mocked
Registrar (Computershare) · HR · dealing · any future client DB. v1 uses three mocked participant records plus the API connectors tab: register an endpoint (mock or live) and the agent can call it as a tool on the next call — no code changes.
＋
Market data — global share prices Integrate LIVE via web search
The agent can quote live/indicative prices for listed companies globally: it raises a market_lookup action, the platform resolves it through the LLM's web-search tool, and the answer is grounded in the result with an as-of time. Production slot: swap LLM.search() for a licensed market data feed (e.g. LSEG/Bloomberg) — quotes then become real-time and exchange-compliant.
＋
AI QA layer Build LIVE in this v1
A second, independent LLM pass scores every completed call against a 6-category weighted rubric with auto-fail conditions — see any call record for the scorecard. Calls in progress also get a throttled rolling pass on the fast model (live sentiment + provisional QA), shown on the Live now board as the call runs.
Live telephony — Bland bridge Interim not connected
Connects this workspace to the server backend: real phone calls handled by the same brain, completed calls imported into Calls & QA, knowledge-base edits pushed to the live line, and the phone registry that decides which callers are verified. Setup steps live in server/README.md.
Genesys Cloud CX — integration plan & reserved config
Four touch-points map Genesys onto what's already built. Nothing here is live yet — these are the seams the integration plugs into.
1
Open Messaging — web chat, first to go live Matches current chat-first mode
Genesys Open Messaging webhooks deliver each customer chat message to our backend; we return the AI agent's reply. Maps 1:1 onto the existing per-turn orchestration (KB grounding, verification gate, sentiment scoring). Escalation at ≤50 becomes a transfer into a Genesys ACD queue with the context pack attached.
2
Bot Connector — per-turn brain hookup for voice
Genesys calls our endpoint on every conversational turn (postUtterance-style contract) and speaks the returned text — the same receiver pattern already coded for Bland (/bland-webhook) with a different request/response mapping. Genesys owns STT/TTS, barge-in and turn-taking.
3
Architect Data Actions — in-flow lookups
Where the IVR needs a fact before the bot engages (e.g. dealing-window status for a fast self-serve branch), Architect Data Actions call the same connector registry endpoints defined in the API connectors tab.
4
Notifications / conversation-ended events → QA
Genesys conversation-ended events deliver the final transcript to the QA scorer, so Genesys-handled calls land in the same Calls & QA views and dashboard as chat-console calls — one system of record, multiple front doors.
Stored as reserved config — no live connection is attempted. The OAuth secret must never be entered in this browser app; it belongs in the backend's vault.
// genesys-adapter.js — Genesys Cloud CX [SLOT]
const GenesysAdapter = {
// chat first: Open Messaging inbound webhook -> orchestrator -> reply
onOpenMessage(cb) {/* POST from Genesys per chat message */},
sendOpenMessage(text) {/* reply into the conversation */},
// voice later: Bot Connector per-turn contract
onBotTurn(cb) {/* postUtterance -> orchestrator */},
// escalation: sentiment <= 50 or agent flag -> ACD transfer
transferToQueue(queue, ctxPack) {/* Genesys ACD + context pack */},
// post-call: conversation-ended -> QA scorer
onConversationEnded(cb){/* final transcript -> same QA pipeline */}
};
Team roster — 15 countries
Every senior agent, their login, region team, country and assigned AI agent. In production this mapping comes from the identity provider / HR directory, not code.
LLM provider — swappable
Everything routes through one adapter. To change vendor, implement complete() for the new provider — nothing else in the app changes.
// llm-adapter.js — the ONLY place a vendor is named
const LLM = {
provider: "anthropic",
async complete(system, messages, maxTokens = 1000) {
// Anthropic Messages API (key handled by runtime)
const r = await fetch("https://api.anthropic.com/v1/messages", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ model: CONFIG.model,
max_tokens: maxTokens, system, messages })
});
const d = await r.json();
return d.content.map(c => c.text || "").join("");
}
// To swap vendors: reimplement complete() with the same
// signature (system, messages[{role,content}]) => string.
// Orchestrator, QA and sentiment layers never change.
};
Integration slots — interfaces reserved
Deferred by design, per your instructions.
// telephony-adapter.js — NICE CXone / Five9 [SLOT]
const TelephonyAdapter = {
onCallStart(cb) {/* SIP/WebRTC leg attaches here */},
onCallerAudio(cb) {/* STT stream -> orchestrator */},
speak(text) {/* orchestrator -> TTS */},
transferToHuman(ctxPack) {/* CX platform routing */}
};
// identity-shield.js — Pindrop / Nuance [SLOT]
const IdentityShield = {
async verify(stream) {
// returns { verified, riskScore, signals[] }
return SIMULATED_RESULT; // stub in v1
}
};
// guardrails.js — policy layer [SLOT]
const Guardrails = {
check(turn) {/* TODO: blocked topics, PII,
mandatory disclosures, action gating */ return {ok:true};}
};
// escalation.js — human handoff logic [SLOT]
const Escalation = {
policy(turnMeta) {/* TODO: thresholds, routing,
context-pack build. v1: agent flag -> banner */ }
};