Future AGI vs Coval in 2026: Closed-Loop Voice Platform vs Focused Simulation

If you have to pick today: Pick Future AGI if you want a closed loop where production traces, evaluations, guardrails, and prompt optimization sit in one project alongside simulation, with Apache 2.0 building blocks (traceAI, ai-evaluation, agent-opt) and the hosted Agent Command Center on top. Pick Coval if a focused voice testing and monitoring product with the Three-Layer narrative is the wedge, and the rest of the stack (inline guardrails, prompt optimization, multi-modal eval, code-readable instrumentation) is something you compose elsewhere.

Future AGI ranks first when the workload spans pre-launch simulation and production runtime, and the team wants the same project, the same trace store, and the same rubric across both. Coval is a credible focused option when simulation plus monitoring is the whole job and the rest of the platform lives in other tools.

One recent product framing shapes the choice: Coval ships Simulate, Observe, Review as the three surfaces, with the Three-Layer Testing framework as the core opinion. Future AGI’s agent-opt and the Future AGI Protect guardrail family extend the same surface into prompt optimization and inline runtime enforcement that Coval doesn’t cover.

Eight axes, honest scoring, pricing on both sides, three deliberate Future AGI deployment notes, four honest Coval limitations, and how the loop changes the math.

TL;DR: capability snapshot

One-line verdict: Future AGI wins on the loop (native voice observability, the 70+-template eval engine, inline Protect guardrails, the six-optimizer agent-opt) and on Apache 2.0 building blocks the security team can read. Coval ships a clean, focused simulation and monitoring surface with the Three-Layer brand. Both score deep on simulation. Only one of the two closes the loop into guardrails and optimization.

Two positioning facts to start with

Future AGI is the only Apache 2.0 OSS layer in the voice eval, observability, and simulation market in 2026. Coval, Cekura, Hamming, and Bluejay are closed-source SaaS. Future AGI publishes traceAI (instrumentation), ai-evaluation (70+ rubrics), and agent-opt (six optimizers) under Apache 2.0. The hosted Agent Command Center sits on top of that OSS trio. Run the stack inside your own VPC, fork the eval rubrics, audit the trace pipeline; no vendor lock-in.

Each competitor in this category partially solves the problem. Coval ships strong simulation with the Three-Layer Testing framing but doesn’t ship a 70+ rubric Apache 2.0 catalog, an inline guardrail model, or a six-optimizer prompt-tuning library. Cekura covers pre-launch persona testing. Hamming polishes post-call analytics and SIP/DTMF. Bluejay covers monitoring and A/B. Future AGI is the only product that closes the full loop (trace, eval, simulate, cluster, guard, optimize) in one project, with the source available.

What each product actually is

Future AGI is a closed-loop platform for voice agents. The hosted Agent Command Center is the control plane. Underneath sit three Apache 2.0 libraries.

• traceAI is the OpenInference-compatible tracing layer, with first-party SDKs in Python and TypeScript across 30+ documented integrations. Dedicated packages cover voice runtimes: traceAI-pipecat and traceAI-livekit. Spans follow the OpenInference contract and ride OpenTelemetry transport.
• ai-evaluation ships 70+ built-in eval templates. Voice-relevant slugs include audio_transcription, audio_quality, conversation_coherence, conversation_resolution, task_completion, groundedness, context_relevance, chunk_attribution, chunk_utilization, translation_accuracy, cultural_sensitivity, evaluate_function_calling, llm_function_calling, is_polite, is_helpful, is_concise. The library reads as code. Custom evaluators are authored by an in-product agent that reads your traces and rubric examples.
• agent-opt is the optimizer. Six algorithms ship: Bayesian Search, Meta-Prompt (arXiv 2505.09666), ProTeGi, GEPA (arXiv 2507.19457), Random Search (arXiv 2311.09569), and PromptWizard. The optimizer consumes a labelled dataset from ai-evaluation and proposes the next prompt or routing-policy revision.

Native voice observability lights up for Vapi, Retell AI, and LiveKit without an SDK. Connect a provider API key and an Assistant ID inside an Agent Definition and every call lands in a Projects view: call log table, transcripts, separate assistant and customer audio plus a stereo mix, eval scores from any rubric in the 70+-template catalog, and per-call drill-down.

The Future AGI Protect family runs inline guardrails on Google’s Gemma 3n base with category-specific LoRA-trained adapters per arXiv 2510.13351. Four documented safety dimensions ship: content_moderation, bias_detection, security (prompt injection, system-prompt extraction), and data_privacy_compliance (PII detection plus GDPR / HIPAA violations). Native multi-modal across text, image, and audio. A ProtectFlash binary classifier handles the sub-100ms latency budget when single-call enforcement is what the request boundary can afford. The same four dimensions double as eval metrics for offline batch scoring, so production policy and offline rubric stay in lockstep.

Coval is a focused voice agent testing and monitoring product. The marketing site frames three surfaces:

• Simulate. Test thousands of simulated conversation flows. Load and permutation testing with voice realism. Stress-test agents across edge cases before production.
• Observe. Production monitoring on live calls with built-in and custom metrics, threshold alerts, anomaly detection.
• Review. Failure-driven queues and smart sampling so teams focus on critical issues, with human review integrated.

The brand anchors on the Three-Layer Testing framework: regression scenarios for golden dialogs, adversarial scenarios for red-team personas, and production-derived scenarios sampled from real calls. The company raised $3.3M in 2024 to focus on voice-AI simulation and publishes flagship content on the framework, the build-vs-buy decision, and HIPAA architecture patterns for healthcare voice workloads. Closed-source commercial SaaS.

Both products serve voice simulation deeply. The structural difference is the platform around the simulation surface.

Head-to-head on the eight axes

1. Voice simulation depth

Both Future AGI and Coval ship deep voice simulation. The shape of the depth is different.

Future AGI’s simulation surface spans the full authoring stack. 18 pre-built personas ship out of the box. Unlimited custom personas are authored with controls for name, gender, age range across six bands (18-25, 25-32, 32-40, 40-50, 50-60, 60+), location (US, Canada, UK, Australia, India), personality traits, communication style, accent, conversation speed, background noise, multilingual mode across popular languages, custom properties, and free-form behavioral instructions. A team builds its own library and the library grows as new edge cases land in production.

A visual Workflow Builder authors the dialog graph. Three node types ship today. Conversation Node (purple) starts conversations. End Call Node (red) terminates or branches based on a condition. Transfer Call Node (orange) routes to a downstream agent or department. Branch visibility makes the resulting graph reviewable for QA audit.

Auto-generated branching scenarios generate paths, personas, situations, and outcomes against the agent definition. Pick 20, 50, or 100 rows. Dataset scenarios accept CSV, JSON, or Excel uploads, plus synthetic generation with parameter controls. The 4-step Run Tests wizard walks the path: test configuration, scenario selection, evaluation configuration, review and execute. Multi-select scenarios, search and pagination, sticky filters. Error Localization pinpoints the exact failing turn inside a multi-turn dialog so engineers fix the right span. Tool Calling evaluation scores tool invocations inside simulated conversations. Custom voices via ElevenLabs and Cartesia in Run Prompt match the simulated user voice to the deployment target. Indian phone number simulation handles region-specific telephony QA. Show Reasoning column exposes the eval reasoning trace per turn for debug.

Coval ships its own simulation library with persona authoring and the Three-Layer framework as the dominant shape. Voice realism, load testing, and permutation testing are the headline capabilities. Production-derived replay is a real feature of the product. Pricing is metered in simulation minutes (100 on Starter, 1,000 on Growth, custom on Enterprise).

Verdict. Both ship deep simulation. Future AGI matches the simulation feature surface and adds Error Localization, branch visibility, Show Reasoning, Tool Calling eval, ElevenLabs and Cartesia custom voices, and Indian phone number simulation in the same project as observability and evaluation.

2. Three-Layer Testing framework

The Three-Layer Testing pattern (regression + adversarial + production-derived) is well-known in voice-AI QA. Coval publishes the framework prominently and anchors product narrative on it.

Future AGI ships the same pattern as the default flow inside the Workflow Builder, with one structural property: all three layers share data inside a single project.

• Regression layer. Auto-generated branching scenarios populate the golden set. Scenarios live in the project, versioned and re-runnable.
• Adversarial layer. Red-team personas plug into the same Run Tests wizard. The persona library includes hostile, confused, off-topic, and edge-case archetypes; teams add their own.
• Production-derived layer. Native voice observability for Vapi, Retell, and LiveKit captures every production call. Failing clusters surface in the Error Feed. The cluster transcripts seed new Workflow Builder scenarios in two clicks.

A failure spotted in production-derived testing reuses the rubric that already scored production traffic. Same rubric, same project, same trace store. See the three-layer voice testing guide for the full walkthrough.

Verdict. Coval popularized the framework. Future AGI ships the pattern as a single data flow across one project rather than three separate surfaces wired together.

3. Native voice observability

Coval ships Observe as a production monitoring surface. The product runs metrics on live calls, raises threshold alerts, and surfaces anomalies. Tier limits scale monitored call volume from 1K on Starter to 10K on Growth to custom on Enterprise. Trace retention ranges from 30 to 90 days to custom.

Future AGI’s native voice observability covers two distinct integration paths, both shipping out of the box.

Path A. Provider-native runtimes (Vapi, Retell, LiveKit dashboard). No SDK required. Inside the Agent Command Center, create an Agent Definition, paste the provider API key and the Assistant ID, and check Enable Observability. Every call lands in a Projects view auto-created with the agent’s name. The call log table shows transcripts, durations, eval scores, and per-call drill-down. Each call drawer exposes separate assistant audio, customer audio, and a stereo mix download. Run any of the 70+ built-in eval templates on every call: audio_transcription for STT quality, audio_quality for TTS output, conversation_coherence and conversation_resolution for dialog quality, task_completion for goal achievement.

Path B. Code-able runtimes (LiveKit-native, Pipecat-native). When the team owns the orchestration code, the traceAI SDK path drops in via dedicated packages. LiveKit registers in-process to avoid worker pickling issues:

from fi_instrumentation import register
from fi_instrumentation.fi_types import ProjectType
from traceai_livekit import enable_http_attribute_mapping

register(
    project_name="livekit-voice-agent",
    project_type=ProjectType.OBSERVE,
    set_global_tracer_provider=True,
)
enable_http_attribute_mapping()

Pipecat ships the same surface and does not require any extra tracing flag:

from fi_instrumentation import register
from fi_instrumentation.fi_types import ProjectType
from traceai_pipecat import enable_http_attribute_mapping

register(
    project_type=ProjectType.OBSERVE,
    project_name="pipecat-voice-app",
    set_global_tracer_provider=True,
)
enable_http_attribute_mapping()

Either path emits OpenInference-compatible spans. The voice-specific attribute keys are namespaced under gen_ai.voice.*:

gen_ai.voice.stt.provider
gen_ai.voice.stt.language
gen_ai.voice.tts.provider
gen_ai.voice.tts.voice_id
gen_ai.voice.latency.transcriber_avg_ms
gen_ai.voice.latency.voice_avg_ms
gen_ai.voice.latency.turn_avg_ms
gen_ai.voice.latency.ttfb_ms
gen_ai.voice.interruptions.user_count
gen_ai.voice.interruptions.assistant_count
gen_ai.voice.recording.assistant_url
gen_ai.voice.recording.customer_url
gen_ai.voice.recording.stereo_url

Evaluation results join back to the spans they scored via the gen_ai.evaluation.* namespace:

gen_ai.evaluation.name
gen_ai.evaluation.score.value
gen_ai.evaluation.score.label
gen_ai.evaluation.explanation
gen_ai.evaluation.target_span_id

For voice providers outside Vapi, Retell, and LiveKit, the Enable Others mode supports webhook ingestion and SDK-based capture. The three explicit modes (provider-native dashboard, code-native SDK, custom webhook) cover the production voice stacks teams actually ship. See the voice AI observability for Vapi guide and the Retell version for full setup walkthroughs.

Verdict. Both products ship voice observability. Future AGI’s surface joins call audio, eval scoring, and the same trace store the simulation library uses, with explicit dashboard and SDK paths plus the documented attribute namespace. Coval’s Observe surface monitors and alerts on the production stream.

4. SDK-level instrumentation

Coval’s documented surface is hosted product. Public OSS instrumentation libraries are not part of the offering.

Future AGI’s traceAI is OpenInference-compatible and Apache 2.0. 30+ documented integrations cover Python and TypeScript framework runtimes plus the dedicated voice packages. The library reads as code. Security teams fork it before procurement. Real registration looks the same across runtimes:

from fi_instrumentation import register
from fi_instrumentation.fi_types import ProjectType

register(
    project_name="voice-agent-staging",
    project_type=ProjectType.OBSERVE,
    set_global_tracer_provider=True,
)

Multi-modal test cases drop in alongside. MLLMAudio accepts seven audio formats (.mp3, .wav, .ogg, .m4a, .aac, .flac, .wma) with local-file input and auto base64 encoding:

from fi.testcases import MLLMTestCase, MLLMAudio

audio = MLLMAudio(url="path/to/call_recording.wav", local=True)
test_case = MLLMTestCase(input_audio=audio, query="Score this support call")

For document-aware IVR or vision-enabled voice agents (screen-share + voice), the unified test case keeps the input modalities together so a single rubric scores them jointly. ConversationalTestCase handles multi-turn dialog. MLLMImage handles vision. The Apache 2.0 license means the library deploys without the hosted Agent Command Center at all.

Verdict. Future AGI ships a code-readable instrumentation library Coval does not document.

5. Evaluation engine

Coval’s evaluation surface covers built-in and custom metrics scoped to simulation outcomes and production monitoring. Custom metric counts scale from 50 on Starter to 250 on Growth to unlimited on Enterprise. The product handles tool call validations and workflow checks.

ai-evaluation ships 70+ built-in eval templates in the Apache 2.0 SDK. Voice-relevant rubrics drop in by slug:

• audio_transcription for STT quality scoring against reference
• audio_quality for TTS output quality
• conversation_coherence for multi-turn dialog coherence
• conversation_resolution for whether the conversation reached resolution
• task_completion for goal achievement
• groundedness for grounded-in-context scoring
• context_relevance, chunk_attribution, chunk_utilization for RAG pipelines
• evaluate_function_calling and llm_function_calling for tool calls
• is_polite, is_helpful, is_concise for tone and style
• translation_accuracy, cultural_sensitivity for multilingual workloads
• pii, data_privacy_compliance, prompt_injection for safety overlap with Protect

Custom evaluators are authored by an in-product agent that reads your code and traces to generate, refine, and tune new rubrics for the workload. Real evaluation looks the same across runtimes:

from fi.evals import Evaluator

evaluator = Evaluator()

result = evaluator.evaluate(
    eval_templates="conversation_coherence",
    inputs={
        "conversation": (
            "User: Hello\n"
            "Assistant: Hi, how can I help?\n"
            "User: I'm angry about my bill.\n"
            "Assistant: I understand. Let me pull up your account..."
        )
    },
)

print(result.eval_results[0].output)

The Show Reasoning column in Simulate exposes the eval reasoning trace per turn so engineers can debug why a rubric scored the way it did.

Verdict. Future AGI ships a deeper template catalog (70+ named templates), multi-modal test cases, in-product custom evaluator authoring, and Apache 2.0 readability. Both products score their own simulations; Future AGI scores production traffic with the same engine.

6. Inline guardrails

Coval’s product scope stops at testing and monitoring. Production-time guardrail enforcement at the request boundary is out of scope.

The Future AGI Protect family runs on Google’s Gemma 3n base with category-specific fine-tuned adapters per arXiv 2510.13351. Native multi-modal across text, image, and audio. Two enforcement surfaces ship.

Protect. Rule-based, runs the four documented safety dimensions in parallel: content_moderation, bias_detection, security, data_privacy_compliance. Returns per-dimension verdicts plus an aggregate. Configurable to block, redact, or annotate.

ProtectFlash. Single-call binary classifier when the latency budget cannot afford the full rule scan. One inference, pass or fail, sub-100ms.

The same four dimensions double as offline eval metrics so the rubric that scores production traffic is the same dimension the guardrail enforced inline:

from fi.evals import Protect

protector = Protect()  # reads FI_API_KEY / FI_SECRET_KEY from env
result = protector.protect(
    inputs="user turn text to check",
    protect_rules=[
        {"metric": "content_moderation"},
        {"metric": "security"},
        {"metric": "data_privacy_compliance"},
    ],
    action="I'm sorry, I can't help with that.",
    reason=True,
    timeout=25000,
)

For sub-100ms single-call enforcement, the ProtectFlash binary classifier runs a single inference and returns pass or fail when the latency budget cannot afford the full rule scan.

Verdict. Future AGI ships an inline guardrail layer Coval does not. If guardrails are a procurement line item, Coval pairs with a separate guardrail vendor; Future AGI ships the guardrail layer in the same platform with the same policy primitives that score the eval traces.

7. Prompt and routing optimizer

Coval is a simulation and monitoring product. Once a test or production alert surfaces a failure, the engineer reads the report, edits the prompt, and re-runs.

agent-opt is the optimization layer. Six prompt optimizers ship:

1. Bayesian Search for smart few-shot optimization
2. Meta-Prompt for bilevel optimization and deep reasoning refinement (arXiv 2505.09666)
3. ProTeGi for prompt optimization with textual gradients (beam search + critique)
4. GEPA for Genetic-Pareto reflective prompt evolution (arXiv 2507.19457)
5. Random Search as the baseline (arXiv 2311.09569)
6. PromptWizard for production-grade prompt optimization

Two operating modes ship.

• UI-driven from the Dataset view. Point an optimization run at a dataset, pick an evaluator, pick one of the six optimizers, and run. The dashboard surfaces optimizer iterations, candidate prompts, intermediate scores, and final winners.
• Programmatic via the agent-opt Python library. The same six optimizers as a code surface for nightly runs and CI integration.

The optimization loop is gated by design. Low-scoring sessions cluster via Error Feed into named issues. The selected optimizer proposes candidates against the dataset. The eval engine scores each candidate. A human approves the winner before it deploys. Future AGI never auto-rewrites a production prompt without an explicit run and an explicit approval. That gate is intentional.

See the agent-opt deep dive for the full pipeline.

Verdict. Future AGI ships an optimizer suite Coval does not. The optimizer is the structural difference between a product that reports failures and a platform that proposes candidate prompts grounded in live eval signal.

8. Compliance and certifications

Coval’s pricing page lists SOC 2 Type II, HIPAA, and GDPR on all three tiers. Enterprise adds the BAA and a custom DPA, plus SAML SSO, SCIM provisioning, custom SLAs up to 99.99%, private and VPC deployment, and data residency options. The healthcare voice workload positioning is reinforced by public HIPAA architecture content.

Future AGI’s trust page lists:

• SOC 2 Type II: Certified
• HIPAA: Certified
• GDPR: Certified
• CCPA: Certified
• ISO 27001: Certified
• ISO 42001 (AI management standard): In progress

RBAC, audit logs, and SSO ship with the Agent Command Center. Deployment surfaces include SaaS, BYOC self-host in the customer VPC, AWS Marketplace listing, and the Apache 2.0 OSS libraries that deploy without the hosted product entirely. FedRAMP authorization is not on the trust page today; federal procurement runs through BYOC self-host in the customer VPC.

Verdict. Both products clear the regulated healthcare procurement bar. Future AGI carries CCPA and ISO 27001 in addition to the SOC 2 Type II + HIPAA + GDPR set, plus AWS Marketplace and OSS-library deployment on the same trust page.

Pricing snapshot: May 2026

Future AGI starts free with the full platform and scales on usage. Compliance and enterprise add-ons layer on as the team needs them. Coval starts at $100/mo on Starter and ladders up through fixed monthly tiers. Future AGI pricing verified 2026-05-19 at futureagi.com/pricing; Coval pricing pulled from Coval’s published pricing page snapshot 2026-05-17.

The shapes do not line up cleanly. Coval prices in simulation minutes and monitored calls. Future AGI prices in storage, gateway requests, and voice simulation minutes on the Free tier, then layers Boost, Scale, and Enterprise add-ons that add SOC 2 paperwork, the BAA, SAML, SCIM, retention bumps, and SLA tiers without rebasing the per-call meter. Above the Starter band, Future AGI’s per-engagement cost trends lower because the optimizer + Protect + voice obs + traceAI come in the same bill. agent-opt is opt-in: turn it on once eval baselines stabilize and live trace data is flowing.

Where each one falls short

Future AGI: three deliberate deployment notes

• Federal procurement runs through BYOC. FedRAMP authorization is not on the trust page today. Federal SOC procurement runs via air-gapped BYOC self-host in the agency VPC. Same software, customer-owned audit boundary. ISO 27001 is certified today; ISO 42001 is in progress. Agencies on a calendar with FedRAMP as a hard requirement should plan around the BYOC path.
• Optimization is gated by a human approval step. agent-opt proposes candidate prompts from eval signal, scores each candidate, and presents the winners. A human approves before deploy. Future AGI does not auto-rewrite production prompts. The gate is intentional. Teams that want fully automated rewrite-on-failure should preview the workflow before standardizing.
• Capture mode is explicit by runtime class. Vapi, Retell, and LiveKit dashboard runtimes use API-key ingestion (no SDK). LiveKit-native and Pipecat-native runtimes use the traceAI SDK (traceAI-livekit, traceAI-pipecat). Custom or in-house voice stacks use webhook ingestion or the Observe API via Enable Others mode. Three explicit modes, one project, one trace store. Teams whose voice runtime is none of the above will spend the first integration day on the webhook contract.

Each note has a clear path. None imply Coval ships a deeper feature.

Coval: four honest limitations

• No inline guardrails. Production-time enforcement at the request boundary is not part of the product. Toxicity, PII, prompt injection, and bias detection are something the team layers via a separate vendor (Protect-class) downstream of Coval.
• No prompt optimizer. The product reports failures and routes them to review queues. It does not propose candidate prompts. Future AGI’s agent-opt is the optimizer layer Coval leaves open.
• No documented OSS instrumentation. The trace and metric capture happens inside the hosted product. Security teams that want to read the instrumentation before procurement, or self-host the trace path, do not get a code-readable library to work with. Future AGI’s traceAI is Apache 2.0.
• Multi-modal beyond audio is not documented. Vision-enabled voice agents (screen-share + voice) and document-aware IVR run through a separate test surface. Future AGI’s MLLMAudio, MLLMImage, and MLLMTestCase cover the joint multi-modal rubric in one library.

Choose Future AGI if

• Your voice workload spans pre-launch simulation, production observability, inline guardrails, and prompt optimization, and you want the same project, the same trace store, and the same rubric across all four.
• Native voice observability for Vapi, Retell, or LiveKit with no SDK matters, with auto call log capture, separate assistant and customer audio plus stereo mix, auto transcripts, and the 70+-template eval engine scoring every call as it lands.
• Inline AI guardrails sub-100ms at the request boundary across content moderation, bias detection, prompt injection, and PII / GDPR / HIPAA detection are a requirement, with the same four dimensions doubling as offline eval metrics.
• Six optimizers proposing prompt and routing candidates from live eval signal (with an explicit human gate) is the loop you want, run from the Dataset UI or as a Python library.
• Your security team reads code before procurement, and Apache 2.0 libraries (traceAI, ai-evaluation, agent-opt) on top of an OpenInference-compatible trace contract beats a closed-source SaaS contract.
• The compliance line items are SOC 2 Type II + HIPAA + GDPR + CCPA + ISO 27001 certified, with AWS Marketplace and BYOC on the same trust page.

Choose Coval if

• A focused voice testing and monitoring product with the Three-Layer Testing narrative is the wedge, and the rest of the platform layers (inline guardrails, prompt optimization, multi-modal evaluation beyond audio) live in other tools.
• The healthcare voice workload procurement team has been reading Coval’s HIPAA architecture content and the BAA + custom DPA in the Enterprise tier is the procurement path.
• Simulation minutes and monitored calls are the right meter for your usage shape, and the per-call cost on Starter or Growth matches your volume.
• You want a product whose three surfaces (Simulate, Observe, Review) match how your QA team thinks about pre-launch + production + triage, with the simulation minute pricing aligned to that mental model.

Verdict matrix: when to pick which

How the loop changes the math

The closed loop in practice. traceAI emits OpenInference-compatible spans for every voice request, with voice-specific keys under gen_ai.voice.* covering STT and TTS provider, language, voice ID, latency averages, interruption counts, and recording URLs. Native voice observability for Vapi, Retell, and LiveKit captures the same span shape without any SDK. ai-evaluation scores each turn against rubrics from the 70+-template catalog plus custom evaluators authored by an in-product agent that reads your traces. Evaluation results join back to the spans they scored via the gen_ai.evaluation.* namespace. Low-scoring sessions cluster via Error Feed into named issues with auto-written root cause and recommended fix.

agent-opt’s six optimizers (Bayesian Search, Meta-Prompt per arXiv 2505.09666, ProTeGi, GEPA Genetic-Pareto per arXiv 2507.19457, Random Search per arXiv 2311.09569, PromptWizard) propose prompt or routing candidates against the cluster. The eval engine scores each candidate. A human approves the winner before deploy. The Future AGI Protect family runs the four safety dimensions inline at the request boundary, with ProtectFlash available for sub-100ms single-call budgets per arXiv 2510.13351. The same four dimensions double as offline eval metrics so production policy and eval rubric stay in sync.

Two properties make the eval surface distinctive. Evaluators calibrate from human review feedback so the judge gets sharper as the team uses it. In-house classifier models tuned for the LLM-as-judge cost-latency tradeoff run continuous evaluation at low cost-per-token across any rubric, built-in or custom.

Net effect for continuous production voice workloads. Failures cluster automatically, candidate prompts arrive from agent-opt, the eval engine scores them against the same rubric that fires inline as a guardrail, and the team gates the deploy. The Three-Layer Testing framework is the right pre-launch discipline. Future AGI extends that discipline into production with the loop closed and the data flowing through one project.

For Coval customers, the practical pattern is: keep Coval as the simulation and monitoring surface you already use, and drop traceAI (Apache 2.0) into the application code alongside, layer ai-evaluation on the captured traces, light up native voice observability for Vapi, Retell, or LiveKit, and graduate to agent-opt for the closed loop on the production side. The Future AGI libraries are vendor-agnostic by design. For greenfield voice teams, picking Future AGI standalone gives the whole platform in one product.

For the wider voice landscape, the voice agent simulation guide covers the cohort.

Related reading

• Three-Layer Voice Testing in 2026
• Voice Agent Simulation 2026 Guide
• Voice AI Observability for Vapi
• Voice AI Observability for Retell
• Voice AI Healthcare Clinical Workflows in 2026
• Future AGI agent-opt Deep Dive

Sources

• Coval product positioning page (snapshot 2026-05-17)
• Coval pricing tiers page (snapshot 2026-05-17)
• Future AGI Agent Command Center, docs.futureagi.com/docs/command-center
• Future AGI Protect, arXiv 2510.13351
• agent-opt GEPA optimizer, arXiv 2507.19457
• agent-opt Meta-Prompt optimizer, arXiv 2505.09666
• agent-opt Random Search baseline, arXiv 2311.09569
• traceAI (Apache 2.0), github.com/future-agi/traceAI
• ai-evaluation (Apache 2.0), github.com/future-agi/ai-evaluation
• agent-opt (Apache 2.0), github.com/future-agi/agent-opt
• Future AGI Trust page, futureagi.com/trust (verified 2026-05-19)
• Future AGI Pricing page, futureagi.com/pricing (verified 2026-05-19)