Future AGI vs Bluejay: 2026 Voice Agent Evaluation Comparison

If you have to pick today: pick Future AGI if you want one project that closes the loop across native voice observability, 70+ built-in eval templates, inline guardrails, six prompt optimizers, and simulation with 18 personas plus unlimited custom, on Apache 2.0 building blocks. Pick Bluejay if you want a focused testing, monitoring, and improvement layer for voice, chat, and text agents with simulations, custom metrics on production calls, real-time alerts, A/B prompt testing, and workflows in one SaaS product, and you’re willing to run guardrails, prompt-optimizer depth, and OSS instrumentation as separate surfaces.

Future AGI ranks first when the workload is a continuous voice or chat agent that needs eval, guardrails, optimization, and observability sharing one project. Bluejay is a credible second when testing-plus-monitoring is the primary shape and the rest of the stack stays decoupled.

One recent moment shapes the choice: Bluejay’s improvement surface (A/B prompt testing plus prompt optimization on real customer conversations) shipped alongside the simulations and observability core, while Future AGI’s agent-opt shipped six published optimizers in the Apache 2.0 SDK plus the same algorithms inside the Dataset UI.

Eight axes, honest scoring, pricing on both sides, three implementation notes per side, and how the loop adds up at the platform layer.

TL;DR: capability snapshot

One-line verdict: Future AGI ships the deeper product across native voice observability, eval rubric depth, simulation breadth, inline guardrails, prompt optimization, OSS posture, certifications, and deployment flexibility, with one project closing the loop. Bluejay ships a credible standalone testing-plus-monitoring layer with simulations, custom metrics, alerts, A/B testing, and prompt optimization across voice, chat, and text. The two products diverge most on inline guardrails and the optimizer library on Apache 2.0 source, which Future AGI publishes and Bluejay doesn’t.

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. Bluejay, Cekura, Coval, and Hamming 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. Bluejay ships testing, monitoring, simulations, custom metrics, alerts, A/B prompt testing, and prompt optimization across voice/chat/text, but doesn’t publish a 70+ rubric Apache 2.0 catalog, an inline guardrail model, or a six-optimizer prompt-tuning library. Cekura covers pre-launch persona testing. Coval owns the Three-Layer Testing brand. Hamming polishes post-call analytics and SIP/DTMF. 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 full-stack voice and chat platform with a closed trace-to-eval-to-optimize loop. The hosted Agent Command Center is the control plane. Underneath sit three Apache 2.0 libraries:

• traceAI (github.com/future-agi/traceAI) is the OpenInference-compatible tracing SDK across Python and TypeScript with 30+ documented framework integrations including dedicated traceAI-pipecat and traceai-livekit packages. Spans join to eval scores via gen_ai.evaluation.* and read as Apache 2.0 source.
• ai-evaluation (github.com/future-agi/ai-evaluation) is the evaluation engine. 70+ built-in templates cover voice rubrics (audio_transcription, audio_quality, conversation_coherence, conversation_resolution, task_completion), RAG (groundedness, context_relevance, chunk_attribution), multilingual (translation_accuracy, cultural_sensitivity), tool-and-agent (evaluate_function_calling), quality (is_polite, is_helpful, is_concise), and safety (pii, data_privacy_compliance, prompt_injection). Unlimited custom evaluators get authored by an in-product agent that reads your code and traces; in-house classifier models tuned for the LLM-as-judge cost-latency tradeoff run continuous scoring at low cost-per-token. BYOK on judge models.
• agent-opt (github.com/future-agi/agent-opt) is the optimizer library. Six named algorithms: Bayesian Search, Meta-Prompt (arXiv 2505.09666), ProTeGi, GEPA (arXiv 2507.19457), Random Search (arXiv 2311.09569), and PromptWizard. They run from the Dataset UI or the Python library; the dashboard surfaces iterations and candidate scores; deploys gate behind explicit human approval.

Add Error Feed, the zero-config error monitor: HDBSCAN clustering plus a Sonnet 4.5 Judge writing immediate_fix per cluster across five failure categories (factual grounding, tool crashes, broken workflows, safety, reasoning) with rising / steady / falling trends. Add native voice observability with no SDK for Vapi, Retell AI, and LiveKit: provider API key plus Assistant ID triggers auto call capture, separate assistant and customer audio, stereo audio, auto transcript, and the full 70+-template eval engine on every captured call. Voice spans land under the documented gen_ai.voice.* namespace; Enable Others mode covers the rest via mobile-number simulation.

Add Future AGI Protect for inline guardrails. Protect is FAGI’s own fine-tuned model family on Google’s Gemma 3n with category-specific adapters trained via LoRA per arXiv 2510.13351. Sub-100ms inline. Multi-modal across text, image, and audio. Four documented safety dimensions: content_moderation, bias_detection, security, and data_privacy_compliance. ProtectFlash is the single-call binary classifier for the tightest budgets. The same dimensions double as offline eval rubrics so production policy and offline scoring stay in lockstep.

Bluejay is the testing, monitoring, and improvement layer for conversational AI agents across voice, chat, and text. Per the public site and docs, the product surface is:

• Simulations. Lifelike Digital Humans across voice, chat, and text to validate workflows, replay production calls, stress-test the agent, and catch regressions before launch. Load testing scales the simulations.
• Observability. Production call evaluation with custom metrics. OTel traces with tool visibility. Real-time alerts when agents fail metrics.
• Improvement. A/B test prompts and flows using simulations plus real customer conversations, plus a prompt optimization surface over the same workload.
• Workflows. Workflow definition for the simulation and improvement loop.
• Integrations. Bland, ElevenLabs, LiveKit, Pipecat, Retell, Vapi, SIP, Telephony, WebSockets, and Slack.
• Industries. Customer services, healthcare, financial services, and logistics.

The product is closed-source commercial SaaS. Both products operate over the same modern voice runtimes; Future AGI’s surface adds inline guardrails, named optimizer algorithms, an Apache 2.0 instrumentation posture, and the Agent Command Center on top.

Head-to-head on the eight axes

1. Voice and chat agent simulation surface

Bluejay’s simulation surface ships Digital Humans across voice, chat, and text. Teams validate workflows before launch, replay production calls, stress-test the agent, and run regression suites. Load testing scales the simulations across high call volumes. The simulation surface is the most-prominent feature on the public site.

Future AGI’s simulation surface is built on the same intent and ships deeper authoring. 18 pre-built personas cover the common voice-agent and chat-agent test cases. Custom personas are unlimited and authored with controls for name, description, gender, age range (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 toggle across many popular languages, plus custom properties and free-form behavioral instructions.

The visual Workflow Builder uses drag-and-drop graph nodes (Conversation, End Call, Transfer Call). Auto-generate scenarios at 20, 50, or 100 rows with branch visibility so QA can audit the graph before running. Dataset scenarios accept CSV / JSON / Excel upload or synthetic generation. The 4-step Run Tests wizard walks you through test config, scenario select, eval config, and review-and-execute. Error Localization pinpoints the exact failing turn. Tool Calling eval scores function invocations against expected schemas. Custom voices ship from ElevenLabs and Cartesia inside Run Prompt. Indian phone number simulation handles the regional edge case. A Show Reasoning column in Simulate displays evaluator reasoning for fast debug. For the long-form walkthrough see the voice agent simulation 2026 guide.

Verdict. Both products ship voice and chat simulation deeply. Future AGI’s surface adds a visual Workflow Builder with branch visibility, deeper persona authoring, Error Localization, Show Reasoning, and Tool Calling eval inside the same project as the trace store and the optimizer.

2. Native voice observability

Bluejay’s observability surface ships custom metrics on production calls plus OTel traces with tool visibility and real-time alerts. Production call evaluation is API-driven. The path to “production call evaluation with custom metrics” runs through the Bluejay product and the documented integrations.

Future AGI ships native voice observability with no SDK for Vapi, Retell AI, and LiveKit, the three runtimes that dominate modern voice agent deployments. Add a provider API key and Assistant ID to a Future AGI Agent Definition, and the dashboard captures every call automatically. Each call lands with separate assistant audio, customer audio, stereo audio, an auto transcript, and the full 70+-template eval engine over the call. Voice spans land in the trace store under Future AGI’s documented gen_ai.voice.* namespace.

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

Evaluations score every captured call automatically and join back into the same span graph:

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

Enable Others mode supports any provider that’s not on the native list via mobile-number simulation. For full workflows see voice AI observability for Vapi, Retell, and LiveKit.

Verdict. Future AGI ships the zero-SDK native voice obs path for the three dominant runtimes. Provider API key plus Assistant ID is the lowest-friction integration path in the category, and the eval engine runs on every captured call by default.

3. SDK instrumentation via traceAI

Bluejay’s documented integrations span Bland, ElevenLabs, LiveKit, Pipecat, Retell, Vapi, plus SIP, Telephony, WebSockets, and Slack. The integration surface is broad on the public site; the underlying instrumentation is closed-source.

Future AGI’s traceAI (Apache 2.0) ships across Python and TypeScript with 30+ documented framework integrations and OpenInference-compatible spans. Dedicated voice packages include traceAI-pipecat and traceai-livekit. Spans cover the agent framework’s tool calls, model calls, and audio events, and every span attaches input, output, model, and eval score as attributes.

LiveKit registration:

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 registration:

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()

LiveKit registration runs in-process so it avoids worker pickling issues. Pipecat does not require the pipecat-ai[tracing] extra; the traceAI-pipecat package handles attribute mapping directly.

Verdict. Future AGI’s SDK instrumentation is Apache 2.0 and readable. Security teams can fork the integrations, security reviews can audit the span attribute writers, and the OpenInference contract keeps the trace shape stable across the 30+ framework integrations.

4. Eval rubric catalog and authoring

Bluejay’s eval surface is the custom-metric framework: teams define metrics, the platform scores production calls and simulation runs against those metrics, and alerts fire when an agent fails. The framework is well-suited to teams that already know which behaviors they want to track. The public docs describe the custom-metric path; the size of any built-in template catalog isn’t published, so teams that want a large 70+-rubric out of the box should validate it with the vendor.

Future AGI’s ai-evaluation ships 70+ built-in eval templates in the Apache 2.0 SDK across voice (audio_transcription, audio_quality, conversation_coherence, conversation_resolution, task_completion), RAG (groundedness, context_relevance, chunk_attribution), multilingual (translation_accuracy, cultural_sensitivity), tool-and-agent (evaluate_function_calling), quality (is_polite, is_helpful, is_concise), and safety (pii, data_privacy_compliance, prompt_injection). Custom evaluators get authored by an in-product agent that reads your code and traces, and the evaluators calibrate from your feedback data so the judge gets better-calibrated with use.

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 am angry.\n"
            "Assistant: I understand. Let me look into that."
        )
    },
)

print(result.eval_results[0].output)

In-house classifier models tuned for the LLM-as-judge cost-latency tradeoff run continuous evaluation at low cost-per-token, and BYOK on judge models avoids platform markup. Audio rubrics work on the documented MLLMAudio constructor (url="path/to/audio.wav", local=True for local files; url="https://..." for remote).

Verdict. Future AGI ships the deeper rubric catalog plus Apache 2.0 source readability, custom evaluator authoring inside the product, and the in-house classifier path that holds the continuous-evaluation cost down at production volumes.

5. Inline guardrails

Bluejay’s safety surface runs through the custom-metric framework and downstream alerts: define a safety metric, score production calls against it, alert when an agent fails the metric. The product doesn’t publish a dedicated sub-100ms inline guardrail layer.

Future AGI Protect runs on Gemma 3n with category-specific fine-tuned LoRA adapters per arXiv 2510.13351. Sub-100ms inline. Multi-modal across text, image, and audio with no preprocessing pipeline. Two surfaces ship: the rule-based Protect product across the four documented safety dimensions (content_moderation, bias_detection, security, data_privacy_compliance) and ProtectFlash, the single-call binary classifier for the tightest sub-100ms budgets.

from fi.evals import Protect

p = Protect()
out = p.protect(
    inputs="Customer turn text under evaluation",
    protect_rules=[
        {"metric": "content_moderation"},
        {"metric": "bias_detection"},
        {"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 evaluator handles binary harmful/not-harmful classification on the same input surface. The same dimensions double as offline eval rubrics so production policy and offline scoring stay in lockstep, and every captured voice call from native voice obs runs the same policy without a second SDK install.

Verdict. Future AGI ships an inline guardrail layer Bluejay doesn’t publish. For teams that need policy enforced at the request boundary on the same input surface as eval, Protect is the documented option.

6. Prompt optimization

Bluejay ships A/B prompt testing inside the workflow surface plus a prompt optimization capability that runs over simulations and real customer conversations. The improvement loop is one of the three documented pillars. The specific optimizer algorithms aren’t named publicly.

Future AGI’s agent-opt ships six published optimizers, available both inside the Dataset UI and via the Python library:

• Bayesian Search: smart few-shot optimization
• Meta-Prompt: deep reasoning refinement via bilevel optimization (arXiv 2505.09666)
• ProTeGi: Prompt optimization with Textual Gradients via beam search plus critique
• GEPA: Genetic-Pareto reflective prompt evolution (arXiv 2507.19457)
• Random Search: baseline (arXiv 2311.09569)
• PromptWizard: production-grade prompt optimization

Inside the Dataset UI, point an optimization run at a dataset, select an evaluator, pick one of the six optimizers, and run. The dashboard surfaces iterations, candidate prompts, and final scores. The Python library exposes the same optimizers for programmatic control. Low-scoring sessions cluster into named failure modes via Error Feed; the optimizer proposes a candidate rewrite; the eval engine scores it; a human gates the deploy.

Verdict. Future AGI publishes six named optimizer algorithms (three with cited arXiv papers) across the UI and the Python SDK, with explicit human-gated deploys. Bluejay documents A/B testing and prompt optimization, but public docs don’t expose optimizer names, so algorithm-level parity should be validated with the vendor.

7. Pricing and deployment

Bluejay does not publish a transparent pricing page at the time of writing. Pricing is quote-driven through enterprise procurement, and deployment posture beyond SaaS is less publicly visible.

Future AGI is free to start with the full platform; pay-as-you-go scales with usage. Compliance and enterprise add-ons layer on as the team needs them. Verified 2026-05-19 on futureagi.com/pricing:

• Free + Pay-as-you-go base: full FAGI platform; usage-based billing kicks in at scale
• Boost add-on: SOC 2 Type II, OAuth SSO, 90-day retention
• Scale add-on: HIPAA BAA, SAML SSO + SCIM, 1-year retention
• Enterprise add-on: custom retention, ABAC, dedicated CSM

See pricing for current rate-card numbers.

Deployment ships on three on-ramps: SaaS (multi-region hosted), BYOC self-host (federal-style air-gapped boundary in the customer VPC), and Apache 2.0 OSS libraries that deploy without the hosted control plane at all. AWS Marketplace listing for procurement teams that need the marketplace contract path. RBAC ships across the Agent Command Center; 15-25+ LLM providers route on the gateway surface; 100+ models.

Verdict. Future AGI ships transparent published pricing across five tiers plus three deployment on-ramps. Bluejay buyers should validate pricing with the vendor; Future AGI buyers can model spend from the published rates and choose between SaaS, BYOC, and OSS.

8. Compliance and certifications

Bluejay’s compliance posture is documented around the testing-and-monitoring surface and partner-network SLAs. Public attestation depth on the full enterprise cert stack is less visible than Future AGI’s trust page.

Future AGI carries five certifications on the trust page (verified 2026-05-19): SOC 2 Type II, HIPAA, GDPR, CCPA, and ISO 27001, all certified. ISO 42001 (the AI management standard) is in progress. FedRAMP isn’t on the trust page; federal procurement runs via BYOC self-host in the customer VPC. SOC 2 Type II ships from Boost; HIPAA BAA ships from Scale.

Verdict. Future AGI ships the deeper certification stack on one page. For regulated voice workloads in healthcare or financial services, that’s the cleaner procurement story.

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. Bluejay’s pricing is quote-driven without a public rate card. Pulled from each vendor’s pricing page on May 17, 2026.

The two shapes don’t line up. Bluejay’s pricing is quote-driven across the testing-plus-monitoring product. Future AGI is free to start with the whole platform in one bill (trace + eval + simulation + optimizer + inline guardrails + Agent Command Center); pay-as-you-go scales with usage, and compliance + enterprise add-ons layer on per tier when procurement asks. The Apache 2.0 libraries self-host without a contract; teams can validate the eval engine, the trace store schema, and the optimizer locally before signing. Confirm current rates on each vendor’s live pricing page before committing.

Where each one falls short

Future AGI: three deliberate tradeoffs

• Native voice obs ships for Vapi, Retell, and LiveKit out of the box. Native coverage targets the three runtimes most production voice teams pick. Anything outside that list runs through Enable Others via mobile-number simulation or the traceAI SDK path. If your runtime is exotic, validate the integration shape during implementation rather than at standardization.
• The optimization loop is explicit. agent-opt requires an explicit run plus a human approval gate before any candidate prompt ships. Future AGI never auto-rewrites prompts in production. The six optimizers run from the Dataset UI or the Python library; the dashboard surfaces every candidate score; the deploy decision stays with the human. That’s intentional design, not a missing feature.
• Federal procurement runs through BYOC. FedRAMP isn’t on the trust page yet. Federal teams deploy in their VPC via air-gapped BYOC. Same software, customer-owned audit boundary.

Three deliberate tradeoffs in pursuit of the closed loop. Every one has a clear path or workaround for buyers who need it today.

Bluejay: four honest limitations

• Inline guardrails aren’t documented. Safety enforces through the custom-metric framework and alerts; teams that need a sub-100ms inline classifier on the same input surface as eval should validate with the vendor.
• Pricing is quote-driven. No public rate card at time of writing. Future AGI publishes five tiers.
• Source isn’t readable. Closed-source SaaS across instrumentation, eval framework, and improvement loop. Security teams that want to read integration source before procurement should plan around that posture. Future AGI’s three libraries are Apache 2.0.
• Optimizer algorithms aren’t named publicly. A/B prompt testing plus prompt optimization ship as a documented surface, but the algorithms aren’t exposed in public docs. agent-opt ships six named algorithms (three with cited arXiv papers) inside the Dataset UI and the Python SDK with human-gated deploys.

Choose Future AGI if

• Your voice or chat workload needs trace + eval + simulation + optimizer + inline guardrails sharing one project on top of the same voice stack everyone else covers.
• You want native voice observability for Vapi, Retell, or LiveKit with no SDK and auto call log capture, separate audio, stereo recording, and auto transcripts on every call.
• Inline guardrails at sub-100ms with Gemma 3n + LoRA across content moderation, bias detection, security, and data privacy compliance are a hard requirement for your call path.
• Apache 2.0 OSS libraries your security team can read before procurement matter for the contract path.
• Five certifications on one trust page plus AWS Marketplace procurement plus BYOC for federal workloads matter for the buyer.

Choose Bluejay if

• Your team wants a focused testing, monitoring, and improvement layer across voice, chat, and text in one SaaS product, and the simulations-plus-custom-metrics-plus-alerts shape is the primary daily surface.
• A/B prompt testing inside the workflow surface plus a prompt optimization loop across simulations and real customer conversations is the daily workflow.
• The documented integrations (Bland, ElevenLabs, LiveKit, Pipecat, Retell, Vapi, SIP, Telephony, WebSockets, Slack) line up cleanly with your existing voice stack.
• You’re willing to operate inline guardrails, prompt-optimizer algorithm depth, and Apache 2.0 instrumentation as separate surfaces downstream of the testing-and-monitoring layer.

Verdict matrix: when to pick which

How the loop changes the math

Bluejay’s improvement surface runs through A/B prompt testing on production calls plus a prompt optimization loop over simulations and real customer conversations. Real workload, real prompts, real metrics, and the testing-monitoring-improvement triangle covers the daily QA shape.

Future AGI extends the loop across the rest of the voice platform. traceAI emits OpenInference-compatible spans across the documented gen_ai.voice.* namespace, ai-evaluation scores each turn against rubrics from the 70+-template catalog plus custom evaluators authored by an in-product agent (joining back via gen_ai.evaluation.*), low-scoring sessions cluster via Error Feed into named failure modes with auto-written root-cause analysis and immediate_fix per cluster. agent-opt proposes candidate prompts via one of six optimizers, the eval engine scores each candidate, and a human approves the deploy before it ships. Protect rule-based scans run inline across the four documented safety dimensions; ProtectFlash is the sub-100ms binary classifier surface. The same dimensions double as eval rubrics so policy and offline scoring stay in lockstep.

Two things make the eval surface distinctive. Evaluators calibrate from your feedback data so the judge gets better-calibrated with use. In-house classifier models tuned for the LLM-as-judge cost-latency tradeoff run continuous evaluation at low cost-per-token. The loop closes inside one project with one Agent Command Center.

Net effect for continuous voice and chat workloads: Agent Command Center routes the cheaper model for easy turns, the optimizer rewrites over-prompted prompts, the eval data shows the loop where to focus, and inline Protect enforces policy on every call.

For teams already on Bluejay, the platforms compose. Layer Future AGI on top without ripping out the testing-and-monitoring surface: traceAI into the agent framework code, ai-evaluation on captured traces, native voice obs for Vapi or Retell, Protect inline, and agent-opt for closed-loop optimization. The libraries are voice-runtime-agnostic by design.

For the wider voice landscape, the best voice agent monitoring platforms in 2026 listicle covers the cohort.

Related reading

• How to Optimize Voice Agent Latency in 2026
• Sub-500ms Voice AI Guide
• Voice AI Observability for LiveKit
• Voice Agent Simulation 2026 Guide
• Best Voice Agent Monitoring Platforms in 2026

Sources

• Future AGI Agent Command Center, docs.futureagi.com/docs/command-center
• Future AGI Protect, arXiv 2510.13351
• agent-opt GEPA, arXiv 2507.19457
• Meta-Prompt bilevel optimization, arXiv 2505.09666
• 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)
• Bluejay product positioning, getbluejay.ai (snapshot 2026-05-17)
• Bluejay documentation overview, docs.getbluejay.ai (snapshot 2026-05-17)