diff --git a/docs/reviews/2026-07-03-adversarial-review.md b/docs/reviews/2026-07-03-adversarial-review.md new file mode 100644 index 0000000..2ef424b --- /dev/null +++ b/docs/reviews/2026-07-03-adversarial-review.md @@ -0,0 +1,348 @@ +# Adversarial Review — Direction & Progress + +- **Date:** 2026-07-03 +- **Scope:** Project direction (ADRs 0001–0008, vision revision, README/ARCHITECTURE/PORT_PLAN) + and progress to date (slices 1–3, all six crates, tests, CI) — reviewed adversarially, at the + request of the maintainer. +- **Method:** Full read of the ratified docs; source-level review of the shipped code; market + claims pressure-tested against the July-2026 landscape (web-verified, sources at the end). +- **Repo state reviewed:** `main` @ `c30a452` (Slice 3 — OpenAI Realtime brain, merged 2026-07-01). + Initial commit 2026-06-26 — the project is **one week old** at review time. +- **Status of findings:** Advisory. Nothing here is ratified; each finding names the doc or code + it attacks so it can be accepted, rebutted, or amended per the ADR process. + +--- + +## Verdict + +The direction has survived its own internal pressure-tests well. ADR-0007 (rent the trunk) was +the right kill, ADR-0008 (FOB/green-zone) is a genuinely useful mechanical rule, and the doc +discipline is why a review this specific is even possible one week in. + +But three things have shifted under the docs: + +1. **The knife that killed the SIP moat now hangs over the reflex loop** — the plank everything + currently rests on — and the docs still state it as durable white space. +2. **Two external events** (LiveKit's up-stack march; OpenAI Realtime SIP going GA) have eroded + competitive claims the README and ADR-0002 still assert. +3. **Two ratified ADR claims are now factually wrong** (ADR-0002's "structurally impossible" + spend argument post-0007; ADR-0004's AGPL escape hatch) and need amendment before anyone + else makes these arguments in public. + +Progress is genuinely fast — three spearhead steps in one week, green CI, honest ADRs — but all +of it so far is the commodity layer every voice-agent framework ships as a quickstart, and the +project's single most important proof artifact (a latency/barge-in benchmark) does not exist. + +--- + +## Part I — Direction + +### D1. The reflex loop fails the test ADR-0007 invented — and it's now the whole moat + +**Attacks:** ARCHITECTURE.md ("Biggest technical risk"), README pillar 1 / wedge bullet 1, +ADR-0002 §Consequences. + +ADR-0007 killed first-party SIP with three arguments: highest cost, lowest differentiation, +everyone credible already stands on something mature. Apply the same test to the reflex loop, +which ARCHITECTURE.md now names "the risk that remains… also the most-differentiating work": + +- **LiveKit Agents ships semantic turn detection today**, plus interruption handling, DTMF, + warm/cold SIP transfer, and sub-500 ms end-to-end voice agents as the documented 2026 default + stack. +- **Pipecat ships interruption handling** as a configuration flag. +- **OpenAI Realtime does server-side VAD and barge-in natively** — and slice 3 already consumes + OpenAI's `speech_started` rather than running local VAD. + +Barge-in and turn-taking are **table stakes implemented by every voice-agent framework**, not +white space. Turn-taking *quality* is increasingly fought inside the speech-to-speech models +themselves — the layer rutster explicitly rents. + +What residually differentiates is the **quality floor under load**: p99 barge-in kill-latency +when a GC'd Python framework is running 50 concurrent calls. That is a real claim but a narrow +one — and rutster currently has zero measurement infrastructure to demonstrate it (see P3). + +Meanwhile the genuinely undisputed white space in the project's own competitor table — **ACD, +queues, human escalation, supervisor tooling, CDR-you-own** — sits at capability-ladder rungs +2–3, *behind* spearhead steps 4–6. + +**The uncomfortable question:** if every framework has interruption handling and the s2s models +are internalizing turn-taking, what does an ADR-0007-style strategic review conclude about +step 4's billing as "the most-differentiating work"? + +**Assessment:** barge-in is still worth building — core-authoritative playout demands it, and it +is needed plumbing. But it is *plumbing you need*, not *the moat*. The sequencing conclusion is +in R1 below. + +### D2. OpenAI Realtime SIP is GA and the docs don't account for it + +**Attacks:** README competitor table, vision-revision §10 (the momentum-fuel thesis), +spearhead step 5. + +A SIP trunk can now be pointed **directly at `sip:$PROJECT_ID@sip.api.openai.com`** — with call +transfer via REFER and a hangup endpoint. Twilio ships a first-party tutorial for exactly this. + +Consequences, stated bluntly: + +- The spearhead's emotional payoff — *"I called my Rust box and an AI answered the phone"*, which + vision-revision §10 explicitly names as the momentum fuel for a solo multi-year build — is now + a **no-code product feature of the brain vendor**. +- Step 5's topology (CPaaS media fork → rutster → OpenAI) is a strictly more complex path to the + same demo. +- Even primitive escalation (REFER to a human's SIP URI) is achievable OpenAI-direct. + +The README competitor table has rows for LiveKit, cloud CCaaS, cloud AI-voice, and dated OSS — +but **no row for the brain vendor itself**, which is now the most dangerous competitor on the +board: it is eating the transport and the reflexes from the other side. + +What survives is real: multi-vendor brains, data ownership, recording, queueing, containment +analytics, the auditable boundary. But the pitch must be re-aimed at what trunk→OpenAI +*structurally cannot be*, and step 5 needs an honest answer to "why is this better than pointing +the trunk at OpenAI directly?" + +### D3. The compliance wedge's target customer can't run anything currently built or scheduled + +**Attacks:** README wedge bullet 2, ADR-0007 §"What this costs", vision-revision §3. + +The wedge is declared "strongest for PCI / HIPAA / TCPA." Walk a regulated buyer through the +actual topology: layer-1 PSTN audio traverses the CPaaS's infrastructure, and *all* audio +traverses OpenAI's. The buyer who cares about the auditable boundary is precisely the buyer who +refuses both. + +For that buyer, rutster needs **two things that don't exist**: + +1. The out-of-tree SBC graduation path — green zone, unbuilt, not scheduled as a deliverable. +2. A self-hosted brain — and the open speech-to-speech ecosystem remains the weak link. The + viable self-hosted stack in mid-2026 is *cascade* (Whisper-class STT + open LLM + + Kokoro/Chatterbox-class TTS); true open s2s is immature. Yet the tap protocol and slice 3 are + shaped around an s2s API. + +So the moat, today, is a **promissory note whose redemption depends on two third-party +ecosystems maturing**. ADR-0007's "What this costs" section underprices this: the cost is not +"data-ownership dilutes for PSTN in layer 1," it is "**the flagship customer segment cannot +deploy at all until graduation, and graduation depends on components nobody is building**." + +Meanwhile the segment the built path *does* serve (CPaaS + OpenAI, indifferent to the boundary) +is Vapi's and OpenAI-direct's home turf. + +**Two concrete moves:** (a) prove the tap is brain-agnostic *now* — a cascade-stack example brain +(Whisper + Llama + local TTS) in `examples/` would make the sovereignty story demonstrable and is +roughly a day of work given the existing Python brain examples; (b) promote "SBC-graduation +reference configuration" from a footnote to a scheduled deliverable. + +### D4. The "structurally impossible for a 3-vendor stack" spend claim died with ADR-0007 + +**Attacks:** ADR-0002 pillar table, README pillar 3, PORT_PLAN §10 (toll-fraud row). + +Under ADR-0003 (rutster terminates the trunk) the claim was structural: the brain can't spend +because rutster holds the wire. Under ADR-0007, **rutster doesn't hold the wire either — the +CPaaS does.** The gate is now "rutster holds the provider API credential and the brain doesn't," +which is an IAM/configuration property, not a structural one: + +- Any orchestrator that holds the credentials can make the same claim (Pipecat with a spend + counter and scoped credentials). +- The CPaaS itself ships spend limits. +- A mis-scoped provider credential bypasses rutster entirely. + +ADR-0002's pillar table still reads "structurally impossible for a 3-vendor stack" while the +ADR-0007 architecture **is** a 3-vendor stack (CPaaS + rutster + brain). The pillar is now +self-describing. + +**What remains genuinely structural** and should replace the current language: pacing, +half-duplex, and playout enforcement over media rutster terminates — the brain proposes audio +but cannot place it on a wire rutster doesn't authorize, and the gate cannot be *skipped* on any +egress rutster mediates. That is a true and defensible claim. The current one is not. + +### D5. The AGPL escape hatch in ADR-0004 is legally broken + +**Attacks:** ADR-0004 §"Trade-off accepted deliberately". + +ADR-0004 states: *"this ADR's 'or-later' clause permits that transition [to AGPL-3.0-or-later] +cleanly, since GPL-3.0-or-later is a strict subset of AGPL-3.0-or-later for recipients."* + +This is incorrect. The "or-later" proviso (GPLv3 §14) covers **later versions of the GNU GPL**. +AGPL is a *different license*, not a later GPL version. GPLv3 §13 permits *combining* GPL and +AGPL works into a larger work — it does not permit relicensing GPL-3.0 code as AGPL-3.0. + +Today this is moot: a sole copyright holder can relicense at will. But **the first external +contribution accepted without a CLA or copyright assignment permanently closes the AGPL +option** — every contributor would need to consent. Asterisk's own lineage is the precedent: +Digium required copyright assignment precisely to retain relicensing power. + +Three options; pick one deliberately, before the first external PR: + +1. **Decide AGPL now**, while it costs nothing. +2. **Institute a CLA / DCO-plus-assignment policy** from day one, preserving the option. +3. **Delete the claimed escape hatch** from ADR-0004 and accept GPL-3.0 permanently, mitigated + by the wedge as the ADR already argues. + +The current ADR records a hedge the project does not actually hold. + +### D6. The Asterisk-position analogy has a scarcity gap (noted, not fatal) + +**Attacks:** ADR-0002 §Context, vision-revision TL;DR. + +Asterisk won because it made the *expensive thing* — PBX/PSTN interop — free. The expensive +thing in 2026 is the model, and rutster explicitly rents it. The scarcity rutster arbitrates is +**trust and data sovereignty**: real, but thinner, and maturing on a slower clock than the +demo-driven voice-AI wave. + +This creates a tension the docs don't name: the project's *emotional* engine (demos, momentum +fuel) and its *strategic* engine (sovereignty, compliance) pull in different directions — +compliance buyers don't show up for demos, and demo-chasers use OpenAI-direct. Given the stated +goal is strategic relevance rather than revenue, this is acceptable — but sequencing should +consciously serve the strategic engine (see R1). + +--- + +## Part II — Progress + +### Credit first + +Initial commit 2026-06-26; slices 1–3 merged by 2026-07-01. In one week: + +- A working WebRTC media core (`str0m` sans-IO, spec-driven). +- A versioned tap protocol with forward-compat by construction (`#[serde(other)]` catch-all). +- An OpenAI Realtime adapter with a pure-function translator layer and a mock brain enabling a + credential-free dev loop. +- ~7,200 lines landed with green CI, cargo-deny, rustfmt/clippy clean, and integration tests + that exercise the actual seams (reconnect, teardown ordering, playout flush). +- ADRs that record reversals honestly (0003 → 0007) instead of retconning. +- A teaching-grade codebase (LEARNING.md concept index) serving the stated learning goal. + +For a solo-plus-agents week this is an outlier pace, and the docs-as-agent-context methodology +is visibly working. Now the adversarial part. + +### P1. Three slices in, the claimed differentiator is untouched + +Everything shipped — browser echo, WS tap, OpenAI adapter — is the commodity layer that exists +as a quickstart in every voice-agent framework. The advisory interruption events are decoded and +deliberately dropped (`crates/rutster-tap/src/tap_client.rs:409` — *"advisory interruption event +observed; not acted on in slice-3"*). + +The pattern to watch: ADR-0003 declared SIP the hard, differentiating core — then ADR-0007 +deleted it. The docs now declare the reflex loop the hard, differentiating core — and three +slices have shipped *around* it. Step 4 is where the thesis first touches reality; it should be +treated as the project's actual first proof, not step 4 of 6. + +### P2. Doctrine-vs-code drift on the hot path, one week in + +ARCHITECTURE.md (Media plane): *"Dedicated timing threads for the 20ms loop, **never the shared +tokio pool**."* + +The implementation: a single `tokio::spawn` task with `tokio::time::interval(10ms)` driving +**all sessions serially**, with per-session `.await`s and async-mutex acquisitions inside each +tick (`crates/rutster/src/session_map.rs:215-224`, `251+`). That is the shared pool — plus +head-of-line blocking: one session stalled on a lock delays every other session's media. + +Fine at slice scale. But pillar 1 *is* deterministic timing, and the code contradicts the +doctrine with no tracking issue, no debt comment, and no measurement that would reveal when it +stops being fine. Either amend the doctrine ("dedicated threads when N concurrent calls demand +it, measured by X") or file the debt explicitly. Silent drift between ratified docs and code is +the exact failure mode the ADR apparatus exists to prevent. + +### P3. The wedge is unmeasured — README's latency numbers are arithmetic, not data + +The ~250 ms (mock) and ~700 ms (OpenAI) figures in the README are estimates summed from +component guesses ("slice-1's 200 ms + tap round-trip + OpenAI latency + 100 ms playout +buffer"). `TapMetrics` (`crates/rutster-tap/src/metrics.rs`) is drop/gap counters only — no +latency histograms, no jitter measurement, no barge-in kill-time. + +For a project whose entire technical claim versus a weekend of Pipecat is "tighter real-time +behavior, deterministically, under load," the missing artifact is a **repeatable benchmark**: +p50/p99 mouth-to-ear latency and barge-in kill-time at 1 / 10 / 50 concurrent calls, run in CI, +regressed per commit. Until it exists, the no-GC pillar is a brochure claim. + +It is also the only credible marketing asset the project could produce this year: *"rutster vs +LiveKit Agents vs Pipecat, p99 barge-in kill latency under load — reproduce it yourself."* +Recommendation: make it part of step 4's definition of done (R2). + +### P4. Doc rot at one week old + +- `README.md` Status (both the §Status block and the mid-file callout) still says *"Slice 1 + (WebRTC media loopback) is the active build target"* directly beneath a quickstart + demonstrating slice 3. +- `fuzz/README.md` still plans SIP/SDP parser fuzz targets landing at step 5 — ADR-0007 + abolished the SIP parser. The fuzz story should re-aim at what actually parses hostile-ish + bytes now: tap protocol frames, the provider media-fork framing (step 5), RTP. + +Small in isolation — but this repo's methodology is docs-as-agent-context, and stale docs are +corrupted context for every future agent session. + +### P5. Process weight is worth an honest measurement + +The slice-3 implementation plan is 2,967 lines — roughly 40% the size of the entire codebase it +produced. The spec/ADR discipline is clearly paying for itself (this review is downstream of +it). The per-task SDD scaffolding (briefs, reports, review diffs per task) may or may not be. +The data to check exists in `.superpowers/sdd/`: correlate review-cleanliness per task with +brief length. If short briefs review just as clean, the ritual is costing slices. + +### P6. The tap protocol has no auth story, and protocols ossify at first adoption + +The core listens plaintext on `0.0.0.0:8080` (`crates/rutster/src/main.rs:38` — documented, +acceptable for slices). The tap dials `ws://` with no authentication in either direction. + +Core-as-client is genuinely good design. But "security-as-product" plus the ambition of +tap-as-open-protocol means **v1 of the protocol should carry an auth field** (even a static +bearer token; mTLS later) *before* third-party brains exist. The moment someone else implements +the protocol, mandatory auth becomes a breaking ecosystem change instead of a line in the spec. + +--- + +## Part III — Recommendations + +### R1. Re-run the ADR-0007-style strategic review on the spearhead's back half + +Likely outcome: barge-in stays (needed plumbing; the benchmark vehicle) but **rung-2 escalation +is pulled forward, ahead of step 5**. Human-takeover with queueing and recording is the actual +white space — the thing none of LiveKit / Pipecat / Vapi / OpenAI-direct ships — and it is the +capability that answers D2's "why not point the trunk at OpenAI directly?" If accepted, this is +an ADR (it amends the spearhead sequence ratified in the vision revision). + +### R2. Make the latency/barge-in benchmark harness part of step 4's definition of done + +It is simultaneously: the wedge's proof (P3), the doctrine-drift detector (P2), and the only +demo that differentiates rather than reproduces (D1, D2). + +### R3. Amend the two false ADR claims now + +| Doc | Current claim | Amendment | +|---|---|---| +| ADR-0002 / README pillar 3 / PORT_PLAN §10 | Spend control "structurally impossible for a 3-vendor stack" | Narrow to what is true post-0007: co-located, unskippable on mediated egress; brain never holds provider credentials; pacing/playout structurally enforced over terminated media (D4) | +| ADR-0004 | "or-later permits [AGPL] transition cleanly" | Choose: AGPL now / CLA before first external PR / delete the hatch and accept GPL-3 permanently (D5) | + +### Smaller items (cheap, do opportunistically) + +- Add a **cascade-stack example brain** (Whisper + open LLM + local TTS) to `examples/` — proves + brain-agnosticism and the sovereignty story (D3). +- Add "the brain vendor itself" as a row in the README competitor table (D2). +- Schedule the SBC-graduation reference config as a named deliverable (D3). +- Fix README status staleness; re-aim `fuzz/README.md` at the post-0007 parser surface (P4). +- Add an auth field to tap protocol v1 before third-party adoption (P6). +- File the dedicated-timing-thread debt as a tracked issue or amend the doctrine (P2). + +--- + +## Appendix — What was reviewed + +**Docs:** README.md; docs/ARCHITECTURE.md; docs/PORT_PLAN.md; ADRs 0001–0008; +vision-revision (2026-06-26); slice 1–3 design specs; LEARNING.md; fuzz/README.md; +`.superpowers/sdd/progress.md`. + +**Code:** all six crates (`rutster`, `rutster-media`, `rutster-tap`, `rutster-tap-echo`, +`rutster-brain-realtime`, plus the `rutster-call-model` / `rutster-spend` / `rutster-trunk` +stubs); integration tests; CI workflow; git history (d3bd621..c30a452). + +**Market claims verified (July 2026):** + +- LiveKit telephony + Agents: SIP inbound/outbound, DTMF, warm/cold transfer, semantic turn + detection, sub-500 ms default stack — + [LiveKit voice agents](https://livekit.com/voice-agents), + [LiveKit telephony docs](https://docs.livekit.io/telephony/), + [2026 LiveKit Agents guide](https://www.forasoft.com/blog/article/building-multimodal-ai-agents-with-livekit-guide) +- OpenAI Realtime SIP, GA, with REFER transfer + hangup endpoints — + [OpenAI Realtime SIP guide](https://platform.openai.com/docs/guides/realtime-sip), + [Twilio × OpenAI Realtime SIP trunking](https://www.twilio.com/en-us/blog/developers/tutorials/product/openai-realtime-api-elastic-sip-trunking), + [Introducing gpt-realtime (GA)](https://openai.com/index/introducing-gpt-realtime/) +- Self-hosted brain landscape: cascade (Whisper + open LLM + Kokoro/Chatterbox-class TTS) + viable; open s2s immature — + [Self-hosted voice AI stack 2026](https://blog.dograh.com/complete-self-hosted-voice-ai-stack-in-2026/) diff --git a/docs/reviews/2026-07-03-market-feature-scan.md b/docs/reviews/2026-07-03-market-feature-scan.md new file mode 100644 index 0000000..9f56759 --- /dev/null +++ b/docs/reviews/2026-07-03-market-feature-scan.md @@ -0,0 +1,260 @@ +# Market Feature Scan — Enterprise Voice-AI Cohort & Natural Adjacencies + +- **Date:** 2026-07-03 +- **Scope:** Feature surfaces of the enterprise conversational/voice-AI cohort (boost.ai, Parloa, + PolyAI, Cognigy) and the builder-tier platforms (Vapi, Retell), mined for capabilities that + translate to **engine primitives** — plus a map of the natural adjacencies that fit rutster's + niche. Companion to the + [adversarial review](2026-07-03-adversarial-review.md) of the same date. +- **Framing constraint (maintainer-stated):** rutster is a toolkit for DIY builders and + integrators — *not* another UCaaS/CCaaS product. Every feature below is evaluated as an engine + primitive a builder composes, never as a turnkey SaaS feature to clone. The filter is + ADR-0008's FOB/green-zone test plus the capability ladder. +- **Status:** Advisory research record. Items marked ★ are candidates for future specs/ADRs. + +--- + +## Part I — The cohort, briefly + +| Player | What they are | Why they matter to rutster | +|---|---|---| +| **boost.ai** | Gartner-MQ-leader enterprise conversational-AI suite (chat+voice), regulated-industry heavy, quote-priced SaaS | Their feature surface is a map of what regulated contact-center buyers pay for | +| **Parloa** | Voice-first "AI agent lifecycle" platform (Design/Test/Scale/Optimize), PCI DSS/DORA positioning | Their **Test** phase (simulation + evals) is the single most engine-translatable idea in the cohort | +| **PolyAI** | Voice-specialized agent platform, caller-interaction craft | Less to mine — differentiation is craft, not primitives | +| **Cognigy** | Omnichannel enterprise platform; acquired by NICE for ~$955M (closed 2025-09) | The acquisition price validates the domain; omnichannel is the anti-pattern to refuse | +| **Vapi / Retell** | Builder-tier cloud voice-agent platforms, per-minute pricing | Closest to the rutster persona; sets the **developer-ergonomics bar** (not the enterprise-surface bar) | + +**Structural observation:** every serious player is enterprise-only or cloud-only. There is no +self-hostable engine in the category — the "Asterisk slot" is empty. Separately, a dedicated +SaaS category exists just for voice-agent *testing/evals* (Cekura, Coval) — confidence is a +product buyers pay for on its own. + +**boost.ai's most instructive move:** their voice line splits into **Express Voice** +(speech-to-speech, direct to multimodal models) and **Enterprise Voice** (cascade STT/LLM/TTS +for regulated scenarios). The market leader productized exactly the s2s-vs-cascade duality — +independent confirmation of adversarial-review finding D3: the tap must treat both brain shapes +as first-class, and a cascade reference brain belongs in `examples/`. + +--- + +## Part II — Features worth incorporating (ranked by engine-fit) + +### F1. ★ Simulation testing / synthetic callers (`rutster-sim`) — the standout + +**Source:** Parloa Test — thousands of simulated conversations pre-deployment (one model plays +the caller, one runs the agent), scored by deterministic checks + LLM-as-judge. Cekura/Coval +sell this as standalone SaaS. **Nobody ships it self-hosted.** + +**Why rutster is structurally close:** the tap is symmetric. A synthetic *caller* is just a +media-leg ingress speaking audio, and the slice-3 mock brain is already half the harness. A +`rutster-sim` that runs scripted/LLM-driven caller scenarios against a call flow **in CI, from +the terminal** is perfectly shaped for the git-versioned builder persona. + +**One build, three payoffs:** +1. Regression evals (rung 3–4: "eval sets that regression-test past failures" — already in the + vision doc, now with a mechanism). +2. Load testing (N concurrent synthetic callers). +3. The latency/barge-in benchmark from adversarial-review R2 — the *same harness*. + +**Disposition:** FOB-adjacent tooling (differentiating). Strongest single feature candidate in +this scan. + +### F2. ★ Warm handoff as a protocol, not just a barge (rung-2 sharpening) + +**Source:** 2026 table stakes across the cohort — structured pre-transfer summary (who's +calling, what they want, what the AI attempted, why escalating, sentiment) delivered to the +human via whisper-audio or screen-pop before bridging. + +**Engine translation:** rung 2 currently reads "human agent barges in / takes over." Sharpen to +a **handoff protocol**: +- A **typed handoff artifact** as a first-class event in the tap protocol / event stream. +- Whisper-play into the human leg before bridging (the audiohook primitive already retained + from Asterisk covers the media side). +- Call variables passed to the destination via the event stream. +- Reverse direction (cheap, later): brain stays on post-handoff as a **copilot whispering to + the human** — same audiohook, Cresta-shaped, also unshipped self-hosted. + +**Disposition:** FOB (differentiating; the escalation primitive is the white space). + +### F3. Outcome-native CDR + the call-record bundle + +**Source:** boost.ai CX Insights — auto-review of every conversation, outcome categorization +(why automated vs escalated), quality rating/tagging; their sales pitch is the numbers +("70% automation, 75% FCR"). + +**Engine translation:** +- **Containment / escalation-reason / resolution as native CDR schema fields**, not + integrator bolt-ons. Containment rate and first-contact resolution are *the* KPIs of the + category; the schema should speak them natively. +- A canonical **call-record bundle** (audio + transcript + event timeline + outcome) plus a + post-call hook, so a builder points any LLM at it for automated review. rutster ships the + bundle format and the hook; the ecosystem ships dashboards. + +**Disposition:** schema = FOB-adjacent (call model / CDR); review loop = green zone via hook. + +### F4. Mid-call brain transfer ("squads-lite") + +**Source:** Vapi Squads — one call routed across specialized agents (triage → specialist → +closer). + +**Engine translation:** slice-2's tap reconnect machinery already survives brain disconnects; +making the brain URL switchable per-call via the API turns that into a **brain-transfer +primitive**. Small delta, large composability win for integrators. + +**Disposition:** FOB (tap engine); near-term cheap. + +### F5. Cost metering inside the spend gate + +**Source:** Vapi/Retell per-call cost breakdowns per component. + +**Engine translation:** `rutster-spend` is planned as a *cap*; it should also be a *meter* — +per-call attribution of CPaaS minutes + brain usage, emitted into the CDR. For integrators this +is load-bearing unit economics: they resell on margin, and **cost-per-contained-call** is their +P&L line. + +**Disposition:** FOB (spend gate is constitutive); extend step 6's scope. + +### F6. PCI redaction primitive + +**Source:** Parloa's PCI DSS/DORA positioning; standard enterprise requirement. + +**Engine translation:** pause-recording / segment redaction + DTMF masking on the audiohook +path during payment capture. FOB by ADR-0008's own test (security-constitutive, in the media +path); directly serves the compliance wedge. + +### F7. A/B traffic splits at the routing layer (defer, keep the seam) + +**Source:** Parloa's Bayesian A/B testing of agents. + +**Engine translation:** percentage split between two brain configs at the routing layer, +variant recorded in CDR; the integrator (or a small service) does the statistics. Defer the +feature; design the routing seam so it's possible. + +--- + +## Part III — Natural adjacencies (what fits the niche) + +Mapped in rings, from "falls out of primitives already owned" outward. + +### Ring 1 — falls out of the substrate + +**★ A1. Graceful degradation when the brain is down.** The claim only self-hosted can make: +every cloud voice-AI product *is* the dependency — when the model API 503s, their customers get +dead air. rutster terminates media locally, so it can degrade: brain unreachable → deterministic +local IVR / structured voicemail / straight-to-queue. *"The phone still answers when the AI +doesn't."* FOB (hot-path, unenforceable from outside the media). **Candidate for explicit +capability-ladder placement.** + +**★ A2. Local keyword reflexes — the "operator!" reflex.** The second instance of the local- +reflex doctrine after barge-in: caller says "agent" / "human" / "representative" or mashes 0 → +local detection fires the escalation policy regardless of the brain's behavior. Outbound +flavor: "stop calling" → TCPA opt-out enforced locally, recorded in the audit surface. Small +keyword-spotting models make this feasible without a brain round-trip. Strategically, this is a +better demo of reflexes-as-moat than barge-in alone, because it's a **policy guarantee** +("callers can always reach a human / opt out, even if the AI misbehaves") — the auditable +boundary made concrete. + +**A3. The call archive as data gravity.** Media + CDR are already owned; a searchable archive +(the F3 bundle, indexed) is nearly free and is the substrate rungs 3–4 stand on. Years of a +business's calls in *their* object storage is the compounding moat. Natural extension: **QA on +human agents too** — the same LLM-review loop scores human calls (Observe.AI/Cresta's business, +sold as SaaS on calls the customer doesn't own). One loop, both populations, self-hosted. + +**A4. Bread-and-butter thin layers:** Voicemail 2.0 (AI answers → structured message → summary +to email/Slack); queue callbacks ("press 1 to hold your place"); transactional **SMS as a tool +call** via the CPaaS API ("I'll text you the link"). Scope note recorded deliberately: +SMS-from-a-call is a tool call (green zone, fine); an SMS *channel* is omnichannel creep +(refuse). + +### Ring 2 — the deployment-shape insight + +**★ A5. Multi-tenancy is the integrator's actual unit — decide its timing explicitly.** The +2006 pattern was not one Asterisk per SMB; it was one integrator box serving dozens of clients +(Vicidial hosting, multi-tenant FreePBX builds). The docs list hard multi-tenancy as a pillar, +but the spearhead and ladder are implicitly single-tenant. If the integrator is half the +persona, tenant-scoped numbers/brains/spend-caps/recordings/event-streams are the difference +between a DIY toy and a thing an integrator bets a client book on. **Retrofitting tenant IDs +into a CDR/config schema is miserable — the timing decision deserves an ADR or spec note before +the CDR/config schemas ossify.** + +**A6. Verticals arrive via the integrator, not via rutster.** Dental/medical intake (HIPAA — +needs the graduation path), trades dispatch and after-hours answering, law-firm intake, +restaurants, property management, municipal 311-style lines (public sector's sovereignty +preference — boost.ai's traction there validates it). The engine's job is to make each vertical +a template someone else ships (→ Ring 3). + +### Ring 3 — ecosystem artifacts (host the conventions, don't build the products) + +- **A7. Brain adapters** — OpenAI Realtime (shipped), Gemini Live, cascade reference + (Whisper + open LLM + local TTS), local s2s when it matures. The adapter registry is the + integration surface (Home Assistant model). +- **A8. Scenario/eval packs** — community-shared synthetic-caller suites for `rutster-sim` + ("dental-intake pack: 40 scenarios, expected outcomes"). Evals-as-shareable-artifacts turns + F1 into an ecosystem; vertical eval packs are how integrator knowledge gets encoded and + traded. +- **A9. Vertical starter kits** — routing config + prompts + eval pack + tool definitions per + vertical. The "thousand integrator builds" pattern, git-cloneable. +- **A10. A Terraform provider / declarative reconciler** — the Kubernetes model is already + ratified; `terraform-provider-rutster` (or the native reconciler) makes "Terraform for call + centers" literal, and it's the artifact the persona expects to exist. +- **A11. The homelab wedge — a Home Assistant integration.** A phone line into HA Assist: call + the house, AI answers, controls the home, takes messages. Strategically small but precisely + the persona's watering hole; demo fuel OpenAI-direct cannot replicate (local control plane); + the historical ignition path for self-hosted projects (r/selfhosted → blog posts → + integrators discover it). Cheap, viral, on-thesis. + +--- + +## Part IV — Explicit refusals (the Five9-parity fence, restated) + +Product-shaped features observed in the cohort that rutster must not incorporate: + +- Visual no-code flow builders (Vapi Flow Studio, boost.ai canvas) — GUI territory; the + reference GUI is a pure API client and the ecosystem's problem. +- Knowledge-base / RAG hosting — a **brain** concern; the integrator wires retrieval into their + brain; the tap doesn't care. +- Prebuilt intent libraries; managed dashboards. +- Omnichannel chat/messaging suites. One deliberate deferral recorded: **text frames in the tap + protocol** would be nearly free and opens a text-channel door later — decide consciously + (for or against) rather than by accident when someone PRs it. +- Workforce management / scheduling; CRM — deep CCaaS territory. +- Being a CPaaS (number resale, SMS routing); being an SBC; video; meetings/UCaaS. +- **Voice biometrics** — will be requested for regulated verticals; genuinely useful; must be a + green-zone integration point (an audiohook consumer), never FOB. + +--- + +## Part V — The through-line (a filter for future feature requests) + +Nearly everything that naturally fits is one of three shapes: + +1. **A reliability/policy guarantee only local media termination can make** — degradation + (A1), escape-hatch reflexes (A2), opt-out enforcement. +2. **A data-gravity loop on calls the operator owns** — archive, QA, evals, training signal + (A3, F1, F3). +3. **An ecosystem convention** — adapters, packs, templates, providers (A7–A11). + +If a proposed feature is none of these and is not already on the capability ladder, it is +probably someone else's product. + +**Promoted to planning (schema-touching, expensive to retrofit):** +- **A1 — brain-down degradation** → capability-ladder placement. +- **A5 — multi-tenancy timing** → ADR/spec note before CDR/config schemas ossify. + +--- + +## Sources + +- boost.ai: [upgraded voice offering (Express/Enterprise Voice)](https://boost.ai/announcements/introducing-upgraded-voice-offering/) · + [AI-powered CX Insights](https://boost.ai/announcements/boost-ai-introduces-ai-powered-cx-insights/) · + [conversational AI platform](https://boost.ai/product/conversational-ai-platform) · + [voice AI overview](https://boost.ai/learn/voice-ai/) +- Parloa: [Test (simulation)](https://www.parloa.com/platform/test/) · + [simulations & evaluations](https://www.parloa.com/resources/blog/simulations-and-evaluations-ensure-ai-agent-reliability/) · + [Bayesian A/B testing](https://www.parloa.com/blog/ai-agent-testing/) · + [Parloa × OpenAI](https://openai.com/index/parloa/) +- Cohort comparison: [Cognigy vs Parloa (incl. NICE acquisition)](https://www.webfuse.com/compare/cognigy-vs-parloa) +- Builder tier: [Vapi review (Retell)](https://www.retellai.com/blog/vapi-ai-review) · + [Retell vs Vapi (Cekura)](https://www.cekura.ai/blogs/retell-vs-vapi) +- Handoff: [warm transfer without losing context](https://www.sigmamind.ai/blog/warm-transfer) · + [AI-to-human handoff guide (Telnyx)](https://telnyx.com/resources/ai-to-human-handoff-voice-ai)