Multi-Model Consult — GPT Pro tier (latest: GPT-5.6 Sol, Pro intelligence)

• Site: chatgpt.com
• Target model requested: GPT Pro tier (latest: GPT-5.6 Sol, Pro intelligence)
• Exact visible model used: Pro
• Captured at: 2026-07-22T10:04:34-04:00
• Source: ~/dev/feral-analyses/2026-07-22-eac-phone-assistant/prompt.md (PANEL-PROMPT + REQUIREMENTS v1)
• Automation mode: agent-chrome
• Status: complete

EAC AI phone assistant: July 2026 panel recommendation Executive verdict

Build a hybrid system, with the cloud voice path primary at launch:

Existing EAC number -> after-hours forwarding to a Telnyx number -> isolated OpenClaw 2026.7.1 voice gateway -> OpenAI gpt-realtime-2.1-mini, with Zero Data Retention enabled -> narrow EAC Truth and Command service -> Momence public API -> versioned website knowledge -> Google Calendar availability and tentative holds -> EAC intake, email, apps shelf, and SMS -> human transfer or callback whenever policy or data requires it

Carrier-level failure route -> front desk during staffed hours -> conventional voicemail after hours

DGX Spark / GB10 -> Momence sync and cache -> post-call redaction, summaries, and evaluations -> shadow transcription -> local voice canary and eventual failover

Use OpenClaw as the business orchestration and agent bridge, but not as the sole telephony reliability boundary. Pin stable version 2026.7.1 rather than the current 2026.7.2 beta line. GitHub +1

The central safety mechanism should be architectural, not merely a prompt:

Schedule answers can be spoken only from a typed truth-service response containing a source and freshness timestamp.

There is no tool that lets the model assign a class placement. The only placement action is create_placement_request.

Private lessons can receive an EAC-side tentative hold, but the assistant must say that a human or Momence will confirm it.

Stale data, failed tools, ambiguous placement, or unsupported Momence writes produce a handoff, never improvisation.

At 600 call-minutes per month, cloud inference costs are small. The expensive variable is not tokens. It is whether the family wants to become an unpaid telecom operations team. The Spark is excellent insurance and an excellent laboratory, but day-one primary PSTN service would exchange perhaps $20 to $30 a month in savings for considerably more operational surface area.

1. Landscape

The planning estimates below assume:

200 calls per month

3 minutes each, or 600 connected minutes

approximately one follow-up SMS per call

an economical LLM and standard voice

no call recording, premium voice clone, international traffic, taxes, number porting, or A2P registration fees

They are planning numbers, not vendor quotations.

Lane A: managed voice-agent platforms Product Current public pricing EAC estimate Integration effort and my read Vapi $0.05/min platform fee, plus model, voice, and carrier costs; Build includes 10 concurrent calls. Vapi $48-$62/mo Medium. Flexible provider marketplace and good tool plumbing. You still assemble and debug several vendors, so it is managed orchestration rather than a completely managed receptionist. Retell AI Current component pricing starts around $0.055/min infrastructure, plus voice, LLM, and telephony. Public pricing spans roughly $0.07-$0.31/min and includes 20 concurrent calls on the entry tier. Retell AI +2 Retell AI +2 $59-$68/mo Low to medium. Best managed runner-up for EAC. Strong call simulation, analytics, transcripts, webhooks, transfer, and operational tooling. Bland AI Start is $0.14/min; Build is $299/mo plus $0.12/min; Scale is $499/mo plus $0.11/min. Transfers add another per-minute charge. Bland $84+/mo on Start Low. Turnkey, but it consumes nearly the whole budget before transfers, SMS, or optional services. No compelling EAC-specific advantage. Synthflow Current contracts start at $30,000/year. Synthflow $2,500+/mo Low technically, impossible economically. It has migrated into enterprise procurement country. ElevenLabs ElevenAgents Creator is regularly $22/mo for 275 minutes, then about $0.08/min overage; LLM and telephony may be passed through separately. Creator includes 10 concurrent calls. ElevenLabs +1 $55-$65/mo Low to medium. Excellent voice quality and pleasant managed UX. Less attractive than Retell for a workflow-heavy receptionist whose hard problem is Momence and human handoff, not dramatic vocal performance. OpenAI Realtime + SIP No voice-platform per-minute fee. gpt-realtime-2.1-mini is token-priced at $10/M audio input tokens, $0.30/M cached audio input, and $20/M audio output. Direct SIP inbound and SIP REFER transfer are supported. OpenAI Developers +2 OpenAI Developers +2 $20-$30/mo High. Lowest plausible variable cost and a very clean realtime model path, but EAC must build SMS, analytics, durable state, retries, transfer policy, observability, and workflow enforcement. Twilio ConversationRelay $0.07/min for ConversationRelay, plus ordinary Twilio voice, SMS, and the external LLM. U.S. inbound voice is currently listed around $0.0085/min and SMS around $0.0083/message before applicable fees. Twilio +1 $50-$65/mo Medium to high. Excellent carrier primitives and transfer behavior. ConversationRelay handles realtime STT/TTS transport over WebSocket while your application supplies the agent. Twilio publishes sub-second relay latency figures, though those are vendor measurements, not an end-to-end EAC benchmark. Twilio

Deepgram Voice Agent API Standard is $0.075/min; BYO TTS is $0.065, BYO LLM $0.059, and BYO both $0.050, before carrier costs. Deepgram $51-$58/mo standard Medium to high. Good speech infrastructure and interruption handling. More assembly than Retell and less integration leverage than OpenClaw for this particular fleet. Telnyx Voice AI Agents Base agent charge is $0.05/min, Call Control is $0.002/min, SMS starts around $0.004/message plus carrier fees, and LLM token charges vary by model. STT and numerous native TTS choices are included in the agent layer. Telnyx +3 Telnyx +3 Telnyx +3 $35-$45/mo Medium. The newer entrant that matters most here because carrier, media, SMS, call control, and agent hosting live in one ecosystem. A credible lower-complexity alternative to OpenClaw plus direct Realtime. Managed-lane conclusion

Retell is the safest buy rather than build option. It buys genuine operational tooling for approximately $60 per month.

Telnyx Voice AI is the value challenger. It is especially attractive when same-carrier voice, SMS, transfer, and failover matter more than a polished independent agent dashboard.

OpenAI direct is the cost and control winner, but only when paired with a real orchestration layer and an explicit reliability design. That is why it makes sense behind the existing OpenClaw fleet rather than as a naked webhook application.

Vapi remains flexible, but EAC already has an orchestration system. Paying Vapi to be a second orchestration system would create two steering wheels and no extra road.

Lane B: cloud-DIY frameworks LiveKit Agents 1.6.3

LiveKit Agents 1.6.3 is the strongest dedicated framework for a new production voice system. It provides a mature realtime media layer, SIP support, turn handling, observability, and model-provider integrations. Its current public estimator shows a representative stack at approximately $0.0672/min, or about $40 for 600 minutes, while the Ship cloud plan is $50/month. GitHub +2 LiveKit +2

Integration effort: medium-high. It would be my framework recommendation if EAC did not already have OpenClaw. It is also the best replacement if OpenClaw fails the concurrency or stability gate.

Pipecat 1.6.0

Pipecat 1.6.0 was released July 21, 2026. It remains the best open framework for rapidly composing custom STT, LLM, TTS, VAD, and transport pipelines, particularly for a local or hybrid system. Its basic telephony transport supports Twilio, Telnyx, Plivo, and Exotel, but the simple WebSocket path does not provide all the reconnect, transfer, and call-control behavior of a dedicated telephony layer. Pipecat Cloud adds managed PSTN/SIP, autoscaling, observability, and evaluation tooling, but has no public self-serve price at present. Daily +3 PyPI +3 Pipecat +3

Integration effort: high. Use Pipecat for media and turn-taking; keep transfer, voicemail fallback, and call routing at Telnyx or Twilio.

Vocode 0.1.113

The latest Vocode package release I found is 0.1.113 from June 2024. That is a weak maintenance signal for a greenfield production deployment in July 2026. GitHub

Integration effort: high, with unnecessary project risk. I would not select it.

Lane C: fully local

A fully local voice loop still needs a carrier for PSTN and SMS. “Local” means STT, LLM, TTS, orchestration, knowledge retrieval, and storage are local. It does not make the telephone network disappear into a puff of CUDA.

Three realistic forms exist:

NVIDIA-optimized local: Riva/Parakeet STT, vLLM or TensorRT-LLM, Kokoro TTS, and Pipecat. This is the best Spark-specific path.

Portable open-source local: faster-whisper or whisper.cpp, llama.cpp or vLLM, Kokoro or Piper, and Pipecat/LiveKit. More portable, but often leaves Spark-specific acceleration unused.

NVIDIA ACE/Riva-heavy deployment: more packaged speech infrastructure and potentially better vendor support, but production licensing, container availability, and ARM64 compatibility should be verified before committing.

With sunk hardware, the monthly variable bill can be roughly $6-$15 for carrier, number, and SMS, plus electricity. The invisible bill is deployment, monitoring, model upgrades, RTP/media debugging, and on-call ownership.

2. What actually runs well on one GB10 DGX Spark

NVIDIA specifies Spark with 128 GB of coherent unified memory and approximately 1 PFLOP of FP4 AI compute. It describes support for testing and inference with models up to roughly 200 billion parameters and fine-tuning models up to 70 billion parameters. That is a capacity statement, not a promise that a 200B model will answer the phone briskly while image generation is running in the next room. NVIDIA

NVIDIA’s own current Spark examples are more revealing:

A local voice demonstration uses gpt-oss-20b through TensorRT-LLM, Riva Parakeet CTC 1.1B, and Kokoro-82M. NVIDIA NIM APIs

Its current vLLM recipe for nvidia/Qwen3.6-35B-A3B-NVFP4 uses FP8 KV cache, 40 percent memory utilization, and up to four sequences. The NVFP4 model is approximately 22 GB, versus roughly 71 GB for BF16. NVIDIA NIM APIs +1

Recommended local stack Telnyx SIP / Call Control -> Pipecat 1.6.0 media worker -> 8 kHz μ-law decode and jitter handling -> streaming VAD and end-of-turn detection -> NVIDIA Riva Parakeet CTC 1.1B -> Qwen3.6-35B-A3B-NVFP4 through vLLM -> existing Kokoro-82M streaming service -> 8 kHz μ-law encode -> EAC Truth and Command service -> Momence cache/API -> Google Calendar -> intake and handoff

Specific operating choices:

Run Qwen in non-thinking mode for the telephone hot path.

Limit effective context to 8K or 16K, not the model’s enormous maximum.

Use continuous batching, prefix caching, FP8 KV cache, and four request slots.

Keep the system prompt compact. Store detailed policy and data behind tools.

Let Telnyx Call Control own transfer and failure routing.

Use Parakeet as the hot-path ASR. Run Whisper large-v3-turbo asynchronously as a shadow transcript or recovery pass when names and noisy audio are problematic.

Keep Kokoro. It is tiny, already present in the fleet, and is also used in NVIDIA’s Spark voice demonstration. CSM-class models are heavier and add operational uncertainty without solving an EAC problem.

Spell back unusual names and offer SMS confirmation. Do not expect any 8 kHz recognizer to divine every child’s name from background trampoline noise.

The conservative alternate LLM is NVIDIA’s demonstrated gpt-oss-20b TensorRT-LLM configuration. It is a safer fallback if the Qwen vLLM build or tool-calling behavior proves temperamental on ARM64.

Expected latency

I did not find a published end-to-end PSTN benchmark for this exact stack on one Spark. The following is an engineering estimate for a warmed system, not a vendor benchmark:

Stage Expected contribution End-of-turn decision 180-300 ms Final ASR stabilization after endpoint 40-100 ms Local LLM time to first token 100-250 ms Kokoro first audio chunk 50-120 ms Codec, queue, and carrier media overhead 60-120 ms

Some work overlaps because ASR and turn detection are streaming. A reasonable target is:

p50 first response audio: 520-790 ms

p95: approximately 0.9-1.4 seconds

Live Momence or Calendar calls can exceed that unless data is cached or the assistant starts with a brief acknowledgment while the lookup completes.

The median requirement is plausible. It is not earned until measured through actual 8 kHz PSTN calls with barge-in, background noise, and two concurrent callers. The VAD/end-of-turn setting will matter more than another quantization benchmark. A 500 ms endpoint timeout can turn a fast model into a sluggish receptionist before the model sees a token.

Concurrent-call headroom

I would provision and promise:

Two simultaneous calls: comfortable, assuming image/video jobs yield the GPU.

Four simultaneous calls: plausible soft ceiling with short contexts and continuous batching, but not a contractual number until load-tested.

More than four: use cloud overflow or a second media/model worker.

Reserve approximately 30 to 40 GB of unified memory for speech services, KV cache, CUDA/runtime overhead, and safety margin. Suspend or queue image and video generation while calls are active. Unified memory thrashing will not fail elegantly; it will turn latency into oatmeal.

What fits in memory but should not answer the phone

A dense 70B model at 4-bit can fit, but sustained low-latency generation for two callers is a poor bet.

A 120B to 200B model at aggressive quantization may load, but leaves little room for KV cache, speech models, runtime overhead, and other services.

A nominal 200B FP4 model consumes roughly 100 GB for weights alone. “Loads successfully” and “pleasantly handles two parents asking about silks classes” are different standards.

Qwen-class 235B models at 4-bit are at or beyond the sensible single-Spark boundary once runtime overhead is included.

405B and 671B classes do not fit sensibly.

Giant end-to-end speech-to-speech models, a large LLM, and active image/video workloads should not be co-resident on the production phone path.

The right local receptionist model is a fast 20B to 35B-class model with a narrow tool surface, not the largest model that can be coaxed into memory.

3. OpenClaw as orchestration Where it wins

OpenClaw’s current voice plugin already supports Twilio, Telnyx, and Plivo inbound routing, per-number configuration, per-call session scope, public webhooks, and Telnyx signature handling. Its realtime mode supports OpenAI Realtime and Gemini Live, with the openclaw_agent_consult bridge to the full agent/tool environment. OpenClaw +1

That provides three meaningful advantages for EAC.

First, workflow leverage. The full agent already knows the EAC triage flow, Workspace, apps shelf, and fleet conventions. A dedicated platform would require rebuilding those integrations or inserting another middleware service.

Second, cost and control. There is no second voice-platform markup. Configuration remains in the fleet repository, and the family controls prompts, tools, storage, routing, and model choice.

Third, clean separation between fast voice and slower tools. Realtime handles natural turn-taking while consult calls perform schedule lookup, intake creation, or calendar work. That is the right shape for a receptionist.

Use per-call session scope, not per-phone memory, so that no caller inherits another caller’s context. Use the consult bridge in safe-read-only mode for lookups. Writes should go through explicit, idempotent EAC command tools rather than general agent access.

Where I would not trust it yet

OpenClaw should be the receptionist’s brainstem and workflow bus, not the dial tone.

No published production SLA or meaningful concurrency benchmark. The current plugin documentation exposes a default outbound maxConcurrentCalls of one. That is not proof that inbound is limited to one, but it is reason to insist on an explicit two-call soak test. OpenClaw

Rapid release cadence. Pin 2026.7.1, retain a tested rollback image, and canary newer releases. Do not run the beta on the school line merely because the version number is shinier. GitHub +1

Provider-path asymmetry. OpenClaw’s classic streaming path currently requires Twilio, while Telnyx live audio uses the realtime path. Therefore, switching Telnyx from OpenAI Realtime to a local STT/LLM/TTS chain is not simply a one-line backend change. The local fallback should be a sibling Pipecat media worker behind Telnyx Call Control. OpenClaw

Consult latency and side effects. A broad agent consult can be slow or accidentally repeat an action after a retry. The voice model should call a narrow EAC service with idempotency keys, timeouts, and explicit read/write separation.

Failure containment. Run the voice gateway in its own container or VM, separate from general OpenClaw experiments. Give Telnyx a carrier-level fallback route that does not depend on OpenClaw being alive.

My decision: use OpenClaw, but wrap it in production discipline and retain LiveKit as the escape hatch if the two-call and outage tests fail.

4. Momence integration reality

The requirements document’s uncertainty is now partly resolved.

What officially exists

Momence has a documented public Host API using OAuth2. A host creates credentials under Apps & Integrations and Developer API. The documented surface includes members, sessions, session details, current session bookings, free session booking, waitlisting, appointment reservation reads, and checkout-related endpoints. Momence public API +2 Momence public API +2

For EAC this means:

Schedule and session reads: officially supported.

Customer/member lookup: officially supported.

Current class bookings: officially supported. Momence public API

Free class booking: there is a documented POST endpoint that adds a member to a session for free, subject to restrictions. Momence public API

Waitlisting: documented.

Existing appointment reservations: readable.

Momence also documents experimental webhooks with JSON delivery, an HMAC-SHA256 signature, a shared secret, and request identifiers suitable for deduplication. Because they are labelled experimental, use them to invalidate a cache, not as the sole source of truth. Momence public API +1

The important hole

The documented host API exposes appointment reservations as GET/read operations, but I found no documented host POST endpoint to create a new appointment or private-lesson reservation. Momence public API

The presence of a free class-booking endpoint also does not mean EAC should use it for ordinary paid classes, credit consumption, or private lessons. “Free booking” has specific semantics. Momence should confirm in writing what it does to rosters, credits, policies, and notifications before EAC enables it.

Zapier and Make

Momence’s current Zapier integration provides several triggers, including customer, membership, and event-booking events. Its generic API Request capability can call endpoints that the authenticated API already permits, but it does not conjure a missing private-appointment creation endpoint. There is no useful native “create private lesson appointment” action documented. help.momence.com +1

I found no current first-party Momence connector for Make. Make’s generic HTTP module could call the public API, but that is merely another HTTP client.

Pragmatic fallback for private lessons

Use a deliberately two-system workflow:

Read Momence’s existing reservations and the coach’s Google Calendar.

Generate valid candidate windows from known working hours and buffers.

Create an EAC-owned Google Calendar or database hold marked:

TENTATIVE, NOT CONFIRMED IN MOMENCE

Give the hold a TTL and an idempotency key.

Send the caller an SMS stating that staff will confirm.

Put the structured request into the existing triage flow.

A human finalizes it in Momence and closes or replaces the tentative hold.

Where Momence provides an official booking or checkout link, send that link rather than impersonating the admin UI.

Do not place browser automation or Momence’s undocumented internal API on the live caller path. A supervised admin helper may be acceptable as a temporary staff tool. An autonomous booking robot clicking undocumented pages is a small raccoon wearing an API badge.

5. Recommended architecture and rollout The EAC Truth and Command service

This is the component that makes the system safe. It should expose only typed operations such as:

search_schedule(filters) get_session(session_id) get_session_availability(session_id) get_private_lesson_windows(coach, discipline, date_range)

create_placement_request(...) create_lesson_request(...) create_tentative_lesson_hold(...)

send_followup_sms(template_id, variables) transfer_to_front_desk() schedule_callback(...)

Every factual read response should include:

JSON { "source": "momence", "as_of": "2026-07-22T18:42:00Z", "fresh": true, "data": {} }

The service should reject or downgrade stale results. For example:

Website policies and pricing: nightly sync with content hashes.

Momence schedule: live lookup or a 5 to 15 minute cache.

Experimental webhook: cache invalidation accelerator.

Nightly full reconciliation: backstop.

API failure: “I can’t verify that right now,” followed by intake and callback.

The voice model should never receive generic database credentials, a browser, or an unrestricted Momence client.

Handle versus handoff behavior Request Assistant may do Assistant must not do Schedule/general information Answer from a fresh truth-service result; send official links Invent, extrapolate, or rely on remembered schedule facts Placement Explain process, discuss a likely range, collect age/experience/goals, create Jacob intake Assign a class, promise acceptance, or book based on its own judgment Private lesson Read candidate windows, collect preferences, create a clearly tentative EAC hold, send SMS Claim a confirmed appointment unless an officially supported Momence write succeeds Uncertainty or stale data Capture name, number, reason, and callback preference; transfer during staffed hours Continue guessing “Front desk” at any point Interrupt current speech and transfer Debate with the caller about whether transfer is necessary Phase 0: truth, policy, and plumbing

Create a least-privilege Momence OAuth application.

Build the truth/command service and versioned website knowledge base.

Obtain or formalize Jacob’s placement matrix, but encode it only as guidance and intake structure.

Define transcript retention, access controls, deletion, and redaction.

Establish the OpenAI Zero Data Retention decision before any real child-related PII reaches Realtime.

Create scripted evaluations for schedule accuracy, placement non-commitment, unusual names, noisy callers, barge-in, Momence failure, and transfer.

Phase 1: after-hours answer and capture, no booking writes

Use conditional after-hours forwarding to a new Telnyx number. Do not port the main number yet.

Enable:

FAQ and schedule answers

placement guidance and intake

private-lesson request intake

real availability reads where reliable

SMS links

staffed-hours transfer

after-hours callback promises

transcript and structured JSON into the existing triage flow

carrier fallback to conventional voicemail

Keep recording off. Run two concurrent calls continuously in staging, then through the real PSTN path. Launch gates:

p50 turn start below 800 ms

p95 below roughly 1.5 seconds

two simultaneous calls without degraded behavior

at least 90 percent complete intake on test scenarios

zero unsupported placement commitments

zero schedule claims without a source

tested Momence-down and OpenClaw-down failure routes

Phase 2: restricted writes

Enable only writes whose semantics have been verified:

Momence free session booking, only for a clearly defined EAC use case

Momence waitlist, if the endpoint behavior and notifications are acceptable

Google Calendar or local tentative private-lesson holds

idempotency and reconciliation for every write

staff confirmation for every private lesson

Do not enable payment, ordinary paid class booking, or private-appointment creation through undocumented paths.

Phase 3: full-line adoption and outbound work

After several review cycles:

port or directly route the main number

add waitlist callbacks

add weather-closure announcements

add lesson reminders

consider bilingual support

promote the Spark path from shadow/canary to overflow or fallback only after it survives the same tests as the cloud path

Cost projection Recommended hybrid: OpenClaw + OpenAI Realtime mini + Telnyx

For a rough Realtime calculation, assume 40 percent caller speech, 40 percent assistant speech, and 20 percent silence across 600 minutes.

That gives approximately:

Caller audio: 14,400 seconds. At roughly one input audio token per 100 ms, about 144,000 tokens.

Assistant audio: 14,400 seconds. At roughly one output audio token per 50 ms, about 288,000 tokens.

Unique-audio cost: approximately $7.20.

Realtime sends conversation context on subsequent responses, but previous input can be billed at the much lower cached rate. Allowing for cached history, text instructions, tool calls, retries, and less tidy real calls, I would budget $10-$18/month for the model. OpenAI documents both the audio-token timing and the fact that later turns include prior conversation context. OpenAI Developers +1

Component Monthly planning amount OpenAI Realtime mini $10-$18 Telnyx voice, number, Call Control, and 200 SMS $6-$12 Storage, monitoring, and incidental API traffic $2-$5 OpenClaw software $0 incremental Expected total $18-$35 Recommended budget number $25-$35/month

This excludes sunk hardware and family engineering labor.

Closest runner-up: Retell

Using Retell’s current component table:

infrastructure: $0.055/min

platform voice: about $0.015/min

economical LLM example: about $0.006/min

U.S. telephony: about $0.015/min

That is approximately $0.091/min, or $54.60 for 600 minutes. Add about $2 for a number, $2 for 200 SMS, and optional knowledge-base or PII-removal charges. Retell AI +1

Component Monthly planning amount 600 call minutes $54.60 Number and SMS about $4 Optional KB / PII controls $0-$9 Expected total $59-$68/month

Retell costs roughly $30 to $40 more each month but buys a more mature call-operations surface. It is the right fallback decision if OpenClaw fails the production test.

Top three risks

1. The model invents a schedule fact or crosses the placement boundary

Mitigation: factual answers require a fresh tool result; no tool result means no answer. Placement is enforced through available actions, not prose instructions. The model can create an intake but cannot assign or book a placement. Review transcripts specifically for soft commitments such as “that class should be perfect,” not merely explicit bookings.

2. Momence writes cause duplicate, unpaid, or contradictory bookings

Mitigation: use documented endpoints only, test free-booking semantics with Momence, require idempotency keys, reconcile every write, and keep private lessons as tentative human-confirmed holds until an official appointment-creation path exists. Never let retries produce a second reservation.

3. Privacy, latency, or gateway failure damages trust

Mitigation: no audio recording in Phase 1, short transcript retention, minimal child PII, encrypted storage, stable OpenClaw pin, isolated voice process, two-call soak testing, cloud/local health probes, and carrier-level fallback that works when every AI component is dead.

Massachusetts law treats secret interception or recording as unlawful and is operationally handled as an all-party-consent jurisdiction. Counsel should approve the greeting and retention policy. Massachusetts Legislature

A suitable starting greeting is:

You’re speaking with EAC’s AI phone assistant. This call is processed live to answer questions and route requests. Audio is not recorded. A brief transcript may be retained for follow-up. Say “front desk” at any time.

If recording is added later, obtain affirmative consent before recording begins rather than merely playing a notice.

There is also a material OpenAI launch gate. The current Realtime endpoint normally has abuse-monitoring retention unless Zero Data Retention is enabled, and OpenAI’s guidance for organizations serving minors says not to process personal data of children under 13 without ZDR. EAC should therefore require ZDR for the Realtime project before launch. OpenAI Developers +1

If ZDR is not available to EAC’s account on acceptable terms, retain the same hybrid architecture but move live STT, LLM, and TTS to the Spark stack. That raises operational burden but avoids making child-related cloud retention a shrug-shaped policy decision.

Final recommendation: hybrid, cloud voice primary under ZDR, OpenClaw as the controlled workflow layer, Momence behind a narrow truth service, private lessons tentative until human confirmation, and the GB10 developed as a measured fallback rather than entrusted with the school line on its first night under the big top.

Multi-Model Consult — Gemini Deep Think

• Site: gemini.google.com
• Target model requested: Gemini Deep Think
• Exact visible model used: Pro Deep Think (verified at retry submission; fresh chat)
• Captured at: 2026-07-22T11:07:40-04:00
• Source: ~/dev/feral-analyses/2026-07-22-eac-phone-assistant/prompt.md (PANEL-PROMPT + REQUIREMENTS v1)
• Automation mode: agent-chrome (retry after first tab resumed a stale conversation)
• Status: complete

Gemini said

Here is the unvarnished engineering reality for the Eastern Acrobatics & Circus (EAC) build, grounded in the current July 2026 AI voice landscape and the specific constraints of your fleet.

1. The Landscape (July 2026)

Building a telephony agent today falls into three distinct lanes:

(A) Managed Voice-Agent Platforms (Cloud): The fastest path to production. OpenAI Realtime + SIP natively allows you to point a Twilio/Telnyx SIP trunk directly to sip.api.openai.com, bypassing orchestration middle-layers. Twilio ConversationRelay beautifully wraps this for Twilio-native setups. Developer platforms like Vapi and Retell AI dominate the BYOM (Bring Your Own Model) space, charging a ~$0.05/min platform tax. Bland AI and Synthflow offer flat rates (~$0.12–$0.14/min) but act as black boxes. Deepgram Voice Agent API is the newest value player at a flat $4.50/hr (~$0.075/min). Realistic all-in cost: $0.10–$0.25/min.

(B) Cloud-DIY Frameworks: You own the infrastructure but call cloud APIs for intelligence. Pipecat has decisively won the Python open-source pipeline war. LiveKit Agents is the gold standard for WebRTC and scales flawlessly, but charges for its LiveKit Cloud routing. Realistic all-in cost: $0.05–$0.10/min.

(C) Fully Local Stacks: Run entirely on your hardware. Fixed upfront hardware costs, with near-zero marginal cost (just the ~$0.005/min SIP trunk fee). Heavy operational burden to tune audio physics, but offers absolute data privacy.

2. The Local Lane on the DGX Spark (GB10)

Your NVIDIA GB10 (128GB unified memory, Grace Blackwell, ~1 PFLOP FP4) is a formidable edge machine. It gives you massive KV-cache headroom, but you must respect its core bottleneck: memory bandwidth (273 GB/s).

The Recommended Local Combo:

STT: Whisper-large-v3-turbo (via Faster-Whisper/vLLM). It executes a chunk in < 100ms and natively handles the background noise of distracted parents.

LLM: Qwen-2.5-14B or Llama-3.1-8B-Instruct (FP8).

TTS: Your existing Kokoro v1.0 fleet instance (:9223). It takes <1GB memory and has a near-zero Time-To-First-Audio (TTFA).

Latency & Headroom: VAD/STT (150ms) + LLM TTFT (150ms) + Kokoro (100ms) + SIP overhead = p50 turn start of ~500 ms, easily beating your 800ms target. Because a 14B model takes <15GB of memory, you have over 100GB of runway and can effortlessly sustain 15–20 concurrent calls.

What DOES NOT fit or stay responsive: Do not attempt to run a 70B+ parameter model (like Llama-3.3-70B) for the live voice loop. While it physically fits in 128GB at FP4 (~35GB footprint), the GB10's 273 GB/s memory bandwidth caps generation at roughly ~7.8 tokens per second. Real-time voice requires >20 tps; your callers will be left listening to awkward 2-second silences mid-sentence.

3. Orchestration Choice: OpenClaw vs. Platforms

Since the fleet already runs the OpenClaw voice-call plugin, you have a massive strategic advantage.

Where it wins (Integration & Control): The openclaw_agent_consult bridge is a structural superpower tailored precisely for FR2 (Placement). It allows the blazing-fast conversational model to handle the parent ("Let me check the syllabus for that age..."), pause, and silently query your heavier, highly-accurate OpenClaw text agent on feral-box-tycho to evaluate Jacob's placement matrix. It natively integrates with the EAC apps shelf, writing JSON payloads with zero vendor lock-in or extra per-minute platform fees.

Where I would NOT trust it (Telephony Edge Physics): Raw SIP packet management and Voice Activity Detection (VAD). Phone lines are chaotic (screaming toddlers, gym echoes, speakerphones). If OpenClaw relies on simple volume thresholds locally, the AI will constantly interrupt itself. Managed platforms (OpenAI, LiveKit, Vapi) have spent millions training machine-learning VADs that specifically filter out non-human telephony noise to prevent false barge-ins.

4. Momence Integration Reality

Momence is a powerful system of record, but it is notoriously hostile to automated writes.

Reads (Schedules & Availability): Excellent. The Momence Developer API (api.docs.momence.com/api/v2) and robust Make/Zapier modules make reading schedules and private lesson availability (GET /v2/host/sessions) rock solid.

Writes (Bookings): An engineering trap. Automating a paid booking requires traversing a strict "Checkout Pre-Flight Maze" involving Host vs. Member scoping, membership prerequisites, hidden waivers, and pricing overrides. An AI natively POSTing bookings will constantly hit 403 errors and corrupt calendar states.

Pragmatic Fallback (Phases 1 & 2): Treat Momence strictly as a read-only oracle. When a caller wants to book a private lesson (FR3), the AI uses the API to confirm the slot, pushes a "Tentative Hold" JSON to the EAC triage flow, and triggers an SMS containing a direct Momence checkout URL. The caller executes the payment and strict checkout flow securely on their own screen.

5. Verdict & Rollout Plan

Recommendation: Hybrid Architecture (Cloud Edge + Local GB10 Logic) Do not subject Austin and Sam to manually tuning WebRTC jitter buffers and local VAD silence thresholds. Let the cloud handle the messy telephony physics, and let your GB10 handle the logic and PII.

The Architecture: Point the EAC number via Twilio to OpenClaw's realtime mode utilizing OpenAI Realtime API (gpt-4o-mini-realtime). OpenAI natively handles the ML-gated barge-in and echo cancellation. OpenAI executes tool calls back to your OpenClaw agent_consult endpoint hosted securely on the GB10 to read Momence, apply the placement matrix, and log JSON transcripts.

Cost Projections (200 calls/mo × 3 mins = 600 mins):

Recommended Hybrid: Twilio SIP Inbound (~$0.005/min) + OpenAI Realtime Mini (~$0.02/min audio in, ~$0.06/min audio out. Blended average is ~$0.04/min). Total: ~$27/month. Fits beautifully under the $100 budget.

Runner-Up (100% Local GB10): Twilio SIP only = ~$3/month. Highly appealing, but you eat an immense ops burden tuning background noise rejection.

Top 3 Risks & Mitigations:

MA All-Party Consent Violation (M.G.L. c.272 §99). Mass state law makes secret recording a felony.

Mitigation: Do not let the LLM improvise the disclosure. Hardcode a Twilio TwiML block ("Hi, you've reached the EAC AI assistant on a recorded line...") before the SIP stream bridges to OpenClaw. Retain only the structured JSON transcripts, not the raw audio files.

Placement Commitments (FR2 Failure). The AI acts too helpful and formally promises a parent their 7-year-old can skip to Advanced Silks.

Mitigation: The local consult-agent's system prompt must strictly enforce the "Guide, Don't Decide" policy. The only allowable terminal state for a placement intent is executing a submit_placement_request tool that guarantees a callback from Jacob.

Momence API Latency & Rate Limits. Live polling Momence while the user is on the phone can spike latency past 2 seconds.

Mitigation: Do not rely on live queries for general FAQs. Have a cron job on the GB10 sync the standard class schedule to a local cache nightly. Reserve live tool calls exclusively for checking strict, point-in-time private lesson availability.

Multi-Model Consult — Grok Heavy

• Site: grok.com
• Target model requested: Grok Heavy
• Exact visible model used: Heavy
• Captured at: 2026-07-22T09:28:31-04:00
• Source: ~/dev/feral-analyses/2026-07-22-eac-phone-assistant/prompt.md (PANEL-PROMPT + REQUIREMENTS v1)
• Automation mode: agent-chrome
• Status: complete

Hybrid OpenClaw orchestration + selective cloud realtime (with local GB10 pieces ready) is the clear winner for EAC. It honors the handle-vs-handoff policy (placement always routes to Jacob), keeps Momence as system of record, stays inside the modest cost target, leverages the existing fleet, and hits the latency/concurrency bar without overbuilding.

Here is the concrete, current (July 2026) map.

1. Landscape — three lanes, July 2026 pricing & effort

(a) Managed voice-agent platforms

Platform Realistic all-in $/min (typical config) Concurrency baseline Integration effort Notes Vapi $0.13–0.31 (platform $0.05 + models at cost or BYOK) 10 free (+$10/line) Low–medium (dev API) Strong tool-calling, SIP, SMS. HIPAA add-on $2k/mo.⁠Vapi Retell AI $0.13–0.31 (infra ~$0.055 + LLM/TTS/tel) 20 free (+$8/extra) Low (templates + KB + warm transfer) Excellent for phone agents; simulation, analytics, PII options. Very popular for scheduling/reception.⁠Retellai Bland $0.11–0.14 (bundled, tiered) 10–100 by plan Low Platform fee $0–499; no token surprises. Synthflow ~$0.15–0.24 PAYG or plan-included mins 5+ Low–medium (workflow/booking focus) Good for calendar-style flows. ElevenLabs Agents ~$0.08+ (plan mins + overage; LLM separate) Plan-limited (4–40+) Low Best voice quality; concurrent gated by tier. OpenAI Realtime + SIP $0.06–0.25 (mini cheaper; flagship higher; + tel) Model-dependent Medium (native SIP emerging/beta; usually Twilio bridge) Full-duplex, strong tool use & reasoning. gpt-realtime-2.1 / mini.⁠Developers.openai Twilio ConversationRelay $0.07 + voice (~$0.0085–0.014 inbound) + STT/LLM High Low if already on Twilio Deepgram Flux support, Studio widget, easy TwiML.⁠Twilio Deepgram Voice Agent $0.05–0.08 (BYO LLM/TTS lower) Moderate Medium Bundled STT+TTS+orch; strong low-latency STT.

Newer/relevant: most of the above have matured barge-in, tool-calling, SMS follow-up, and transfer. No dramatic new entrant has displaced the top tier in 2026 for small-volume phone agents.

(b) Cloud-DIY frameworks (Pipecat, LiveKit Agents, Vocode, etc. + cloud models)

Pipecat (Daily.co): pipeline-first, excellent Twilio/Telnyx plugins, highly modular STT/LLM/TTS. Effort: medium-high for production (barge-in, state, error handling, observability). Lowest variable cost once built (~models + tel only). LiveKit Agents: WebRTC + first-class SIP, strong production maturity, multi-agent, job scheduling. Self-host free; Cloud option cheap. Highest real-time quality among open frameworks. Vocode: lighter, telephony-oriented (outbound bias).

Effort is weeks of solid engineering for phone-grade latency, interruption handling, and reliability vs. hours/days on managed platforms. Variable cost can undercut managed by 30–60% at 600 min/mo.

(c) Fully local stacks

Viable on the single GB10 (see Q2). Orchestration via Pipecat / LiveKit Agents / NVIDIA ACE-style / OpenClaw itself. PSTN still via SIP trunk (Twilio/Telnyx/Plivo). Fixed hardware + SIP cost only.

2. The local lane on one NVIDIA GB10 (DGX Spark)

Hardware reality: GB10 Grace Blackwell — 20-core aarch64 Arm + Blackwell GPU (~6k CUDA cores, ~1 PFLOP sparse FP4 / 1000 TOPS), 128 GB coherent unified LPDDR5x (~273 GB/s BW), ~140 W SOC TDP. Supports models up to ~200 B parameters. Confirmed to run Kokoro TTS with GPU acceleration and CUDA 12.1+ stacks.⁠Ai-infrastructure

Recommended concrete combo for phone-grade latency (target p50 turn-start < 800 ms):

STT: NVIDIA Parakeet (0.6B / 1.1B TDT or CTC variants). Streaming-native, telephony-friendly, low memory (~few GB), warm latency often 100–400 ms on similar hardware. Alternatives: whisper.cpp large-v3-turbo (Docker-tested on Spark). LLM: Qwen3-class or Nemotron/gpt-oss 14B–32B at Q4/Q5 (or efficient MoE). Short-context FAQ + structured capture keeps TTFT in the 100–300 ms range. Larger (70B+ quantized) fits in 128 GB but risks TTFT and BW contention under load. TTS: Kokoro (already running in the fleet on :9223). ~50–150 ms first-audio on GPU, tiny footprint (<1 GB), confirmed on GB10. Streaming-friendly. Orchestration: Pipecat (flexible telephony plugins) or LiveKit Agents. OpenClaw can also drive local models via its consult bridge / streaming mode.

Expected performance:

p50 turn-start: 400–700 ms achievable for 1 concurrent call with full streaming (STT partials → LLM first tokens → Kokoro streaming). Careful VAD + barge-in required. Concurrent headroom: solid for 1–2 simultaneous calls without degradation. 3+ starts contending on the unified memory bandwidth and can push latency over target or force smaller models. What does not stay responsive at 128 GB: high concurrent (4+) + long-context tool-heavy turns + dense 70B+ models simultaneously; unoptimized non-streaming pipelines; heavy image/video co-location on the same box during peak voice load.

Privacy win is absolute. Cost after SIP is essentially power + maintenance.

3. Orchestration choice — OpenClaw voice-call plugin

Wins hard:

Already in the fleet. Zero new platform fee. Exact feature match: Twilio / Telnyx / Plivo inbound, per-number routing (greeting, system prompt, agent, TTS voice), realtime full-duplex (Gemini Live or OpenAI Realtime), streaming STT options, and — critically — the openclaw_agent_consult bridge into the full OpenClaw agent that already has (or can easily gain) Momence / Google Calendar / triage tools. Config-as-code, latency stats, session scopes (per-phone or per-call), SMS follow-through path. Control and integration with existing EAC apps shelf and info@ flow.

Where I would not fully trust it yet:

Concurrency defaults and real-world multi-call behavior under load (tunable, but needs measurement). Ops maturity of the realtime path at production volume (webhook uptime, signature verification, fallback cleanliness). OpenClaw itself is extremely popular and actively maintained, but the voice plugin is newer relative to the core messaging agent surface. If the school ever needs pure managed analytics/transfer dashboards without self-hosting, a dedicated platform is simpler.

Verdict on orchestration: Use OpenClaw as the primary layer. It is the lowest-friction, highest-integration path for this specific fleet. Treat a managed platform (Retell or Vapi) only as a fast parallel prototype or pure fallback if realtime ops prove sticky.

4. Momence integration reality

Official public API exists (api.docs.momence.com / api.momence.com). OAuth2.0 (client credentials or auth-code flow; staff/host accounts for automation). Split into Host API (staff permissions) and Member API.

Confirmed surface (July 2026):

Strong reads: host/sessions list, member available host sessions, member bookings list, host memberships, etc. Writes present: cancel session booking, add member to session waitlist, member checkout (primarily membership-payment focused; notes on compatible memberships and price pre-fetch). Explicit “create arbitrary booking” is less prominently documented in the public reference than cancel/waitlist/checkout; host-side creation is plausible with proper staff credentials but should be verified in a test client before Phase 2 commitment. Zapier: yes for triggers; custom API Request actions work for leads and similar. Webhooks not heavily advertised.

Pragmatic path:

P1: Nightly (or live) read of schedules/availability into a grounded knowledge base + structured capture of placement/lesson requests. SMS the public Momence registration/checkout link. Human (or existing triage) completes the write. This is safe, truthful, and matches the “AI guides, human decides” policy. P2: Test Host API create/hold paths with a staff token. If insufficient, fall back to calendar holds (Google) + SMS confirmation, or Tycho’s prior internal-API experience as a controlled bridge. Never invent availability. 5. Verdict, architecture, cost, risks

Recommended architecture: Hybrid — OpenClaw voice-call plugin as orchestration + cloud realtime for primary voice path, with GB10 local stack as cost/privacy/offline option.

Telephony: existing number forward (after-hours first) or dedicated AI line via Twilio/Telnyx SIP into OpenClaw. Voice path P1: OpenClaw realtime mode (Gemini Live preferred for cost/latency balance, or OpenAI Realtime) with agent-consult bridge into the full EAC-context OpenClaw agent (Momence reads, calendar, triage). Streaming STT fallback available. Local on GB10: Parakeet + mid-size Qwen/Nemotron-class + Kokoro under Pipecat/LiveKit or OpenClaw local mode. Use for after-hours privacy, cost control, or as hot fallback. Knowledge: Momence API nightly sync (or live lookup) + website into grounded KB. Never invent. Handoff: live transfer during staffed hours; structured JSON + transcript + SMS into existing triage/apps shelf. Placement always human. SMS confirmation + relevant links post-call.

Phased rollout (matches requirements doc):

P1 (ship first): After-hours forward. FAQ/schedule answers from KB, placement + private-lesson request capture, SMS links, transcripts to triage, human transfer/callback. No writes. P2: Momence (or calendar) tentative holds once write surface is verified; SMS confirmation. P3: Outbound reminders, waitlist callbacks, analytics polish, possible bilingual.

Cost at 200 calls/mo × 3 min = 600 min:

Recommended hybrid (OpenClaw + cloud realtime + Twilio): ~$50–110/mo (telephony ~$5–10 + model ~$0.06–0.15/min effective after caching). Well inside the ≲ $100 target. Closest runner-up (pure Retell or Vapi managed): ~$80–180/mo all-in. Faster to first call, less control over tools/Momence, higher long-term variable cost. Pure local on GB10: ~$10–20 (SIP + power) once tuned — attractive for Phase 2+ if latency holds.

Top three risks & mitigations:

Momence write surface incomplete or permission-gated → Stay capture-first + SMS public link/human book in P1. Verify Host API create/hold in a sandboxed staff client before any automated write. Fallback to Google Calendar holds is already in the fleet. Latency or concurrency variance on realtime path → Instrument p50/p95 turn-start from day one (OpenClaw already has latency stats). Keep barge-in aggressive, short system prompts, streaming everywhere. Local GB10 stack as measured fallback. Cap concurrent at 2 until proven. MA all-party consent + child PII → Up-front AI disclosure in the greeting; if recording, explicit consent language (confirm exact wording with counsel). Minimal retention of transcripts; no payment data spoken to the AI; daily digest into existing human-visible triage only.

This is the lowest-risk, highest-leverage path that actually uses the hardware, software, and operational reality the school already has. Ship the after-hours capture loop first; everything else builds cleanly on top.

544 sources Verify Momence Host API create booking permissions Explore Google Calendar integration for tentative holds Specify exact MA all-party consent greeting wording

Heavy

Multi-Model Consult — Grok default mode (Auto)

• Site: grok.com
• Target model requested: Grok default mode (Auto)
• Exact visible model used: Auto
• Captured at: 2026-07-22T09:28:31-04:00
• Source: ~/dev/feral-analyses/2026-07-22-eac-phone-assistant/prompt.md (PANEL-PROMPT + REQUIREMENTS v1)
• Automation mode: agent-chrome
• Status: complete

Hybrid wins hard: OpenClaw voice-call plugin as the orchestration layer, cloud realtime (Gemini Live / OpenAI Realtime via the existing bridge) for the voice loop in Phase 1, with a clean path to local-on-GB10 for the heavy tools and future full-stack if volume or privacy demands it. This respects the handle-vs-handoff policy (placement is never AI-committed), Momence as system of record, latency targets, 24/7 availability, and the fleet’s existing OpenClaw + Spark hardware. Pure managed platforms add unnecessary cost and lock-in; pure local on one GB10 is feasible but operationally heavier for a small school at ~200 calls/month.

1. Landscape (July 2026 reality)

(a) Managed voice-agent platforms These are the “ship tomorrow” lane. Most are developer platforms with BYO models + telephony (Twilio/Telnyx/SIP), tool calling, barge-in, SMS, transfers, and analytics. All-in costs typically land $0.10–$0.30/min once STT/LLM/TTS/telephony are stacked; pure platform fees are lower.

Vapi: Build plan $0 + $0.05/min hosting (models pass-through or BYOK at cost). 10 concurrent included (+$10/line/mo). HIPAA add-on $2k/mo. Strong tool calling and concurrency. All-in often ~$0.13–0.31/min.⁠Vapi Retell AI: Pay-as-you-go from ~$0.07–0.31/min combined (infra ~$0.055 + TTS/LLM). SOC 2 on base; 20 free concurrent. Developer-friendly composition.⁠Magpieai Bland AI: All-in style. Start $0.14/min (no platform fee), Build $299/mo + $0.12/min, Scale $499/mo + $0.11/min. Bundles LLM/STT/TTS. Higher concurrency on paid tiers.⁠Bland Synthflow: Modular pay-as-you-go (~$0.09 voice engine + $0.02–0.05 LLM + telephony). Plans with included minutes (Starter ~$29 for 50 min, higher tiers $450+). No-code leanings + workflows. ElevenLabs Agents: Per-minute voice layer ~$0.08 (after May 2026 cuts) + LLM pass-through. Tiered plans with included minutes (Free 15, Starter $6/75 min, Pro $99/1.2k+, Scale $299/3.7k+). Excellent voice quality; concurrent limits scale with plan.⁠Help.elevenlabs OpenAI Realtime + SIP: Token-based (gpt-realtime-2.1 audio in ~$32/1M, out $64/1M; mini much cheaper). Practical all-in ~$0.06–0.24/min depending on model/talk ratio + telephony bridge. Native SIP still maturing; production usually Twilio/Telnyx bridge. Strong function calling.⁠Forasoft Twilio ConversationRelay: $0.07/min + your LLM + voice costs + standard Twilio voice rates. Mature SIP/media streams, Deepgram Flux support for better turn-taking. Excellent if you already live in Twilio.⁠Twilio Deepgram Voice Agent: Flat ~$0.05–0.08/min (Standard ~$0.075, BYO LLM/TTS lower). Bundled STT + orchestration + TTS; strong low-latency enterprise option.⁠Deepgram

Newer/relevant: LiveKit Agents (cloud or self) and various Pipecat Cloud offerings sit at the boundary of managed and DIY. Integration effort for any of these is moderate (prompt + tools + SIP trunk + knowledge base sync); pure no-code is thinner on complex Momence handoffs.

(b) Cloud-DIY frameworks Pipecat (Daily, Python frame pipeline, 100+ services including Twilio/Telnyx serializers, OpenAI Realtime/Gemini Live, local models), LiveKit Agents (WebRTC-first, strong production quality, SIP plugins), Vocode (telephony-oriented). These give full control, lower long-term cost, and easy hybrid (cloud models + local tools). Effort is higher than managed platforms but lower than pure local. Latency targets are routinely hit with streaming STT + realtime models.

(c) Fully local stacks Pipecat / LiveKit Agents + local STT/LLM/TTS on your own hardware (or NVIDIA ACE/Riva where available). PSTN still enters via SIP trunk. Highest control and lowest marginal cost; highest ops burden and concurrency limits on a single box.

2. The local lane on one NVIDIA GB10 (DGX Spark: 128 GB unified, Grace Blackwell, aarch64, ~1 PFLOP FP4)

It runs well for phone-grade work. Concrete combo that hits the spirit of p50 < 800 ms turn-start on telephony audio (8 kHz μ-law → resample):

STT: Whisper large-v3-turbo (or NVIDIA Parakeet TDT 0.6B / Canary variants). Whisper-turbo is proven on Spark; Parakeet is lighter and competitive on English. Both fit comfortably. LLM: Qwen3.6-35B-A3B (or gpt-oss-20B / similar MoE) quantized (MXFP4 / NVFP4 / Q4). Fits with room to spare; decode speeds in the 40–80+ t/s range on single GB10 depending on exact quant and context. Larger dense or 100B+ class models either slow TTFT unacceptably or leave too little headroom for concurrent audio pipelines. TTS: Kokoro-82M (already running on fleet Spark hardware). Extremely light, low RTF, multiple voices, GPU-accelerated on GB10. Alternatives (Qwen3-TTS, certain Magpie/NeMo paths) also viable. Orchestration: Pipecat (or LiveKit Agents) with SIP trunk (Twilio/Telnyx Media Streams or ConversationRelay-style bridge). Streaming end-to-end, barge-in via VAD + partial transcripts.

Expected latency: Well-tuned streaming pipelines on Spark have demonstrated ~700–800 ms time-to-first-audio in community recipes; p50 under 800 ms is realistic with careful VAD, partial STT, streaming LLM tokens into TTS, and local networking. Concurrent-call headroom on one 128 GB box is modest—comfortably 2 simultaneous full pipelines, maybe 3–4 if you keep models quantized and share weights carefully; beyond that you start swapping or degrading.

What does not fit cleanly or stay responsive: full unquantized 70B+ dense models under concurrent load, heavy multi-modal vision + long-context simultaneously with two live calls, or anything that forces model reloading mid-call. Telephony audio quality and background noise (kids, cars) still favor robust STT over pure speed.

3. Orchestration choice — OpenClaw voice-call plugin

Wins decisively for EAC:

Already in the fleet. Twilio/Telnyx/Plivo inbound, per-number routing (greeting, system prompt, agent, TTS voice), realtime full-duplex mode (Gemini Live / OpenAI Realtime) with the openclaw_agent_consult bridge into the full OpenClaw agent + tools (Momence, calendars, triage). Classic streaming STT + TTS path as fallback. Per-call or per-phone session scope, latency stats CLI, config-as-code. Zero extra platform fee; cost is just the underlying realtime/model + telephony minutes. Deep integration with existing EAC agent, knowledge base, and triage flow means placement capture, structured JSON intake, SMS follow-ups, and daily digests land exactly where humans already look. Control and auditability are high.

Where I would not fully trust it yet: raw maturity of the voice plugin under sustained production concurrency beyond a couple of simultaneous calls, edge-case recovery (carrier blips, model timeouts), and long-term ops load if the team is not already deep in OpenClaw. For a 200-call/month school this is fine; for a call-center scale it would need more hardening or a dedicated platform underneath. The bridge pattern (fast voice model for conversation + full agent for tools) is exactly the right architecture for FR1–FR5.

4. Momence integration reality

Momence has an official public API (api.momence.com / api.docs.momence.com). OAuth2 (password flow for staff/host automation; authorization-code for member contexts). Split into Host API (staff-level: list sessions, bookings, waitlist management, cancel, etc.) and Member API (customer-scoped).

You can read schedules/availability (sessions endpoints return starts/ends, capacity, teacher, location, etc.) and perform certain writes (waitlist booking, limited checkout flows, cancel). Zapier integration exists primarily for triggers from Momence outward; creating actions inside Momence via Zapier is limited (leads via direct API request are supported).

Pragmatic path for EAC:

Host API with a dedicated staff credential for live schedule/availability reads and tentative holds where the endpoints support it. Nightly or event-driven sync into the knowledge base for FAQ answers. For private-lesson writes that are incomplete or permission-gated: capture structured request (discipline, preferred coach/times, contact) → SMS confirmation link or triage ticket → human/Momence confirmation. Never invent availability. This matches the requirements document’s Phase 1/2 split and the “AI guides, human decides” rule. 5. Verdict and phased rollout

Recommended architecture: Hybrid centered on OpenClaw.

Voice loop and turn-taking: OpenClaw realtime mode (Gemini Live or OpenAI Realtime) via the existing plugin + SIP trunk on the school number (start with after-hours forward). Tools, knowledge, placement capture, SMS, triage, Momence/calendar lookups: full OpenClaw agent on the fleet (Tycho box or equivalent). Local GB10 path reserved for future: move STT/TTS or the entire pipeline local when you want fixed cost, higher privacy, or more concurrent headroom; keep the same OpenClaw orchestration. Knowledge base: nightly (or webhook) sync from Momence Host API + website. Placement matrix (if one exists) encoded as structured guidance only.

Phased rollout (matches the requirements doc):

P1 (ship fast): After-hours forward → OpenClaw realtime agent. Grounded FAQ/schedule answers, placement + private-lesson request capture (structured JSON), SMS with links, transcript + intake into existing triage, live transfer during staffed hours, clean voicemail fallback. No booking writes. P2: Momence Host API reads live + tentative holds / structured writes where supported; otherwise human confirmation loop. P3: Outbound (waitlist, reminders), analytics, optional bilingual, concurrency tuning.

Cost at 200 calls/month × 3 min average (= 600 min):

Recommended (OpenClaw + realtime + telephony): roughly $40–120/month all-in depending on model choice (mini-tier Realtime or Gemini Live is the cheap end; premium voices/models the high end) + existing Twilio/Telnyx rates. Well under the ≲ $100 target if you stay disciplined. Closest runner-up (pure managed, e.g. Vapi or Retell with similar models): $80–200+/month. Bland or Deepgram Voice Agent can land in a similar band if you accept their bundling. Pure local marginal cost approaches telephony-only after the fixed hardware is paid for.

Top three risks + mitigations:

Momence write surface incomplete or permission-gated → Stay in capture + human confirmation for P1/P2; treat any booking create as best-effort and always surface to staff. Verify endpoints with a staff token early. Latency or barge-in regressions under real parent noise / accents → Measure p50/p95 on actual calls from day one; keep classic streaming STT+TTS fallback path; tune VAD and system prompt for repair phrases. Compliance / recording in Massachusetts (all-party consent) → Explicit AI + recording disclosure in the greeting (counsel-reviewed wording); minimal PII retention; transcripts only into the existing controlled triage flow.

This is the pragmatic, low-regret path for a small circus school that already owns OpenClaw and Spark hardware. It delivers the three jobs, honors the human-in-the-loop placement rule, stays cheap, and keeps the door open to full local when it actually pays off. Ship the after-hours forward version first and measure real volume and failure modes before over-engineering.

115 sources Explore Pipecat local orchestration Investigate NVIDIA Riva STT TTS

Auto

Multi-Model Consult — Latest Claude on claude.ai

• Site: claude.ai
• Target model requested: Latest Claude on claude.ai
• Exact visible model used: Fable 5 Low 
• Captured at: 2026-07-22T09:28:31-04:00
• Source: ~/dev/feral-analyses/2026-07-22-eac-phone-assistant/prompt.md (PANEL-PROMPT + REQUIREMENTS v1)
• Automation mode: agent-chrome
• Status: complete

Claude responded: Panel response below. Marshaled comprehensive response with sourced citations  Marshaled comprehensive response with sourced citations

Panel response below. Sources cited where I'm relying on fetched facts; internal-fleet claims taken from the requirements doc as given.

1. Landscape (July 2026)

Lane A — Managed platforms. The market has consolidated into three shapes: orchestration-first platforms (Vapi, Retell, Synthflow) that give you a swappable STT/LLM/TTS/telephony pipeline; end-to-end voice models (ElevenLabs Conversational, Deepgram Voice Agent, OpenAI Realtime) that collapse the pipeline into one API; and outbound-opinionated verticals (Bland, Air.ai). NomadLab

Realistic all-in pricing, not the headline numbers:

Platform Headline Realistic all-in Notes Vapi $0.05/min platform $0.15–0.31/min once LLM, STT, TTS, and telephony are added Five Most modular; most invoices to manage Retell $0.07/min $0.11–0.15/min in practice with GPT-4o + Deepgram + ElevenLabs; 20 concurrent included, numbers $2/mo YESWorkflow Wins on latency, especially p95, and tool-call reliability; Tested Media ~620ms typical turn Bland $0.11/min advertised (recently raised from $0.09), plus monthly plan fees and per-call minimums that inflate the effective rate at low volume Klariqo ~$0.12–0.15 effective Outbound-first; inbound tooling is thinner than Retell's NomadLab

Synthflow $29–900/mo subscription tiers plus per-minute add-ons Stackswap ~$0.13–0.20/min No-code; sub-600ms latency requires a separate $0.04/min edge add-on Retell AI

ElevenLabs Agents — ~$0.08–0.12/min bundled; leads on voice quality and multilingual Stackswap Best voice, weaker deep-integration story OpenAI Realtime + SIP token-priced ~$0.06/min input audio + ~$0.24/min output at typical usage Stackswap → ~$0.15–0.25/min blended Pure API — you build the surrounding logic

At your volume (600 min/mo), the difference between platforms is $60 vs $120/mo — noise. Pick on inbound quality, tool-calling reliability, and transfer/SMS features, not price. That points at Retell as best-in-lane for this use case.

Lane B — Cloud-DIY (Pipecat / LiveKit Agents + cloud models). Pipecat (Daily) and LiveKit Agents are both mature in mid-2026, both have first-class SIP/Twilio ingestion, barge-in, and tool calling. Cost drops to raw provider rates — roughly Deepgram ($0.004–0.008/min) + a fast LLM ($0.01–0.03/min) + TTS ($0.02–0.05/min for ElevenLabs Flash, near-zero for Cartesia/Kokoro-hosted) + Twilio ($0.008/min + ~$1.15/number). Call it $0.04–0.09/min all-in, or $25–55/mo at your volume — but you own the ops: hosting the agent worker, deploys, monitoring, and every 3am edge case.

Lane C — Fully local. Covered in §2. Marginal cost approaches the SIP trunk fee (~$0.01/min); fixed cost is hardware you already own plus your time, which is the expensive part.

2. The local lane on one GB10

Be clear-eyed about the hardware: the Spark's constraint isn't FLOPs, it's memory bandwidth. The unified LPDDR5x tops out at 273 GB/s shared across CPU and GPU, and 4-bit quantization is what makes inference feasible against that bottleneck. The Spark excels at prefill but is decode-limited; MoE models with small active parameter counts (6–17B) run efficiently, and batched throughput scales near-linearly with concurrency until KV cache or scheduling becomes the bottleneck — good news for multi-call serving. LMSYS Org + 3

Recommended combo:

STT: NVIDIA Parakeet-TDT 0.6B (streaming, aarch64-friendly via NeMo/Riva) — faster and lighter than Whisper-large-v3-turbo on telephony 8kHz audio, ~100–200ms partials. Whisper-turbo as accuracy fallback for the offline transcript pass. LLM: an MoE with small active params, NVFP4 via vLLM/TRT-LLM. Qwen3-30B-A3B or gpt-oss-20B class. With ~3B active params against 273 GB/s you get comfortable 40–80+ tok/s decode and TTFT in the 150–350ms range for short voice turns. Do NOT run a dense 70B for the voice loop — decode performance on 70B-class dense models is where the bandwidth wall hits hard. And no reasoning models: thinking tokens murder turn latency. Apertus TTS: Kokoro (already running at :9223) — ~80ms to first audio for short sentences, trivial VRAM. CSM-class models if you want warmer prosody, at a latency cost. Orchestration: Pipecat or LiveKit Agents, SIP trunk in via Telnyx/Twilio.

Expected latency budget: VAD endpoint (~200ms) + STT final (~100ms) + LLM TTFT (~250ms) + TTS first chunk (~100ms) ≈ p50 ~650–750ms turn start. Achievable but with less margin than Retell's tuned pipeline; p95 will be worse than a managed platform until you've profiled it.

Concurrency headroom: 2–4 simultaneous calls is comfortable with an MoE LLM; the LLM batches fine, STT/TTS are cheap. The real constraint is that this box also runs Kokoro for other services plus image/video workloads — GPU contention from a diffusion job will blow your latency SLO. If the Spark does voice, voice needs priority or its own scheduling fence.

What doesn't fit / doesn't stay responsive: dense 70B+ for the live loop; any reasoning-mode model; premium neural TTS at ElevenLabs quality (local TTS is good, not great, on telephony audio it matters less); and true five-nines availability — one box, one power supply, one Comcast outage.

3. OpenClaw as orchestration

Where it wins: the agent-consult bridge is the genuinely differentiated piece. A fast realtime voice model handles turn-taking while the full OpenClaw agent — with Momence tools, calendar tools, the EAC knowledge base, and the existing triage flow — handles lookups and structured capture. No other option gets you "the AI that answers the phone is the same agent ecosystem that reads info@ and lives on Tycho's box." Per-number routing means the after-hours forward line can have its own greeting/prompt/policy from day one. Cost is raw provider rates (Gemini Live or Realtime tokens + trunk), config-as-code fits the fleet's operability requirement, and there's zero new-vendor surface.

Where I would not trust it (yet):

Turn-taking and barge-in quality under real-world conditions — distracted parent, kid screaming, speakerphone in a minivan. Retell has tuned this across tens of millions of calls; a plugin has not. This is the #1 caller-perceived quality axis. Ops maturity: call-drop recovery, SIP re-INVITE handling, carrier weirdness, graceful degradation when the consult bridge times out mid-call. The requirements doc's "never a dead line" bar means you need a tested voicemail failover path, and you should assume you'll build it yourself. Concurrency: ≥2 concurrent calls is a hard requirement. Verify the plugin's session handling under simultaneous inbound before trusting it — "works in demo" and "works when two parents call at 5:58pm on registration day" are different claims. Consult-bridge latency: if every schedule question round-trips into a full agent turn, you can blow the 800ms budget. The bridge should be reserved for lookups/writes; FAQ answers need to live in the voice model's context (nightly-synced KB in the system prompt).

Verdict on OpenClaw: right layer, wrong phase to bet the whole line on. Use it — but behind an after-hours forward first, where a dropped call costs a voicemail, not a live customer.

4. Momence integration reality

Better than the ⚠️ in the doc feared. Momence has a real, documented public API (v2, OAuth2, at api.docs.momence.com, with an OpenAPI schema and an llms.txt index explicitly published for AI agents). The surface, from the published reference: momence

Reads: list sessions, session detail, session bookings, member lookup with filters, appointment reservations, available memberships, member bookings. Everything FR1 needs. Writes that exist: add a member to a session for free (staff action), add to waitlist, cancel bookings (single and recurring), check-in/check-out, and a checkout endpoint — which currently only supports buying sessions with a membership payment method, with a mandatory prices→compatible-memberships→checkout call sequence. So: class booking writes are possible for existing members paying via membership; arbitrary card-payment bookings via API are not. Webhooks: outgoing webhooks with a documented events reference — use these to keep the KB fresh instead of only nightly polling. Zapier: an official Momence↔︎Zapier integration exists (Apps & Integrations > Integrations), but it's trigger-centric marketing plumbing — the direct API is strictly better for this build. Momence

The gap: private lessons are "appointments" in Momence, and the public API shows appointment reads but no appointment-creation endpoint. So FR3's pragmatic path is exactly what the requirements already sketch: read real availability (appointments + coach calendars via gog), place a tentative hold as a structured request routed to staff, SMS the caller a Momence checkout/booking link for payment. That also cleanly sidesteps "no payment capture by the AI" and the checkout API's membership-only limitation. CC Tycho's internal-API experience stays as break-glass, not architecture — don't build P2 on an unsupported surface when a supported read API + human-confirmed write covers the requirement.

5. Verdict

Recommendation: Hybrid, OpenClaw-orchestrated, cloud voice loop — with the Spark doing everything except the realtime audio path.

Concretely:

Voice loop (latency-critical): OpenClaw voice-call plugin, realtime mode (OpenAI Realtime or Gemini Live), Telnyx SIP trunk on a new number, EAC's line forwarded after-hours first (P1). Brains and integration (latency-tolerant): the consult bridge into an EAC-context agent on Tycho's box — Momence public API reads, structured placement/lesson capture, triage-flow delivery, nightly KB sync + webhook-driven freshness. This is where the fleet's advantage actually lives. Spark's role: KB embedding/sync, transcript post-processing, spot-check QA of "zero invented facts," and a shadow local voice loop (Parakeet + Qwen3-30B-A3B + Kokoro on Pipecat) you can promote later if cloud costs or privacy posture ever justify it. Don't put the live phone line on one bandwidth-constrained box that also renders images.

Why not pure Retell: it's the safest voice loop, but you'd rebuild the Momence tools, triage delivery, and per-line policy inside someone else's platform, duplicating what OpenClaw + the fleet already do — and the consult-bridge architecture is the strategic asset here. Why not pure local: turn-taking quality and single-box fragility are exactly the risks a phone line for paying parents shouldn't carry in v1.

Costs at 200 calls × 3 min = 600 min/mo:

Recommended (hybrid): Realtime audio tokens — roughly $0.06/min in + $0.24/min out; at a typical ~40% agent-talk ratio that's ~$0.13/min ≈ $80/mo, plus Telnyx trunk + number (~$8), SMS (~$3), consult-bridge LLM tokens (~$5–10). ≈ $95–100/mo — at the budget line. Swap to Gemini Live or realtime-mini + tool-routing and it drops to roughly $35–60/mo (consistent with the clesper matrix's $0.50–1.00 per 10-min realtime-mini figure). Start with mini. Stackswap Runner-up (Retell): ~$0.11–0.15/min all-in with the standard stack → $66–90/mo + number. Comparable money, less integration, more polish. YESWorkflow

Top three risks:

Voice-loop quality below caller tolerance (barge-in failures, awkward turn-taking with noisy parents). Mitigation: after-hours-only launch; "front desk"/zero-out escape at all times; weekly transcript review against the success criteria; pre-agreed trigger to swap the audio layer to Retell while keeping the OpenClaw agent behind it via API — the architecture keeps that swap cheap. Hallucinated schedule/placement facts. Mitigation: voice model answers FR1 only from the injected KB with an explicit "not sure → capture + callback" instruction; nightly Momence sync + webhooks; automated spot-check job on the Spark that diffs claimed schedule facts in transcripts against the Momence API. Ops fragility / dead-line scenario (plugin crash, trunk failure, box down). Mitigation: carrier-level failover on the Telnyx number to voicemail-with-transcription-to-info@ (configured at the carrier, so it works even when everything downstream is dark); health-check paging to the fleet; MA all-party-consent handled by defaulting recording OFF in P1 (transcribe-only still gets counsel review — Massachusetts hinges on interception of the audio, so confirm wording before enabling anything).

Phasing stays as drafted — P1 answer+capture on the forwarded after-hours line, P2 adds Momence-API availability reads and tentative holds with SMS checkout links (the appointment-write gap makes "hold + human confirm" the right P2 design, not a compromise), P3 outbound. One addition: before P1 ships, run a two-line concurrent-call test and a pull-the-ethernet-cable test. If both fail gracefully, you're ready for parents.