Top AI Agent Evaluation & Observability Harnesses for Production Teams in 2026

Production AI agents do not fail like demos fail.

A demo fails when the model gives a weak answer. A production agent fails when it calls the wrong tool, silently skips a step, loops for 14 minutes, burns budget, mishandles a handoff, retrieves stale context, or passes a workflow test once and regresses the next day. That is why production teams in 2026 need more than prompt logs. They need evaluation and observability harnesses: the systems that capture traces, score behavior, compare versions, surface regressions, and connect human review back into development.

This article ranks the leading AI agent evaluation and observability harnesses for production teams in 2026:

1. LangSmith
2. Braintrust
3. Langfuse
4. Arize Phoenix / Arize AX
5. Galileo
6. DeepEval / Confident AI
7. OpenAI Agent Evals
8. Helicone
9. Ragas

MCPlato is included separately, not as a direct observability vendor, but as a complementary local-first AI workspace harness around the eval harness.

What Counts as an AI Agent Eval / Observability Harness?

For this comparison, an AI agent eval and observability harness is a platform or framework that helps teams answer five production questions:

• What happened? Trace agent steps, tool calls, model calls, retrieval, handoffs, sessions, cost, latency, and errors.
• Was it good? Score outputs and trajectories with code evaluators, LLM-as-judge, human review, feedback, or domain-specific metrics.
• Did we regress? Run repeatable evals against datasets before deployment and monitor online behavior after deployment.
• Can we debug it? Inspect failed traces, compare prompt/model/tool versions, and convert production failures into test cases.
• Can it fit our stack? Integrate with SDKs, CI/CD, OpenTelemetry, existing observability, and governance requirements.

The best harnesses combine traces + eval datasets + experiments + production monitoring + human feedback. The weaker ones are valuable, but narrower: a proxy for logs, a test library, or a RAG metric toolkit rather than a full production control loop.

Methodology

This ranking prioritizes production teams building multi-step LLM and agent systems. The scoring is qualitative, based on public product pages, docs, pricing pages, integrations, open-source repositories, and public company/customer information available as of May 14, 2026.

Primary scoring axes:

We avoid fabricated metrics. If pricing, traction, revenue, customer counts, or benchmark numbers are not publicly disclosed, we say so.

1. LangSmith — Best Overall for Production Agent Teams

Best for: Teams building agents with LangChain, LangGraph, or adjacent Python/JavaScript stacks that need a mature all-in-one system for tracing, evaluation, datasets, monitoring, and deployment confidence.

LangSmith ranks first because it is one of the most complete production harnesses for agent builders. Its observability product emphasizes tracing, monitoring, debugging, and operational visibility for LLM apps and agents.¹ Its evaluation docs cover datasets, experiments, automated evaluators, and workflows for comparing system behavior over time.²

Key capabilities

• Agent and LLM tracing for multi-step workflows.
• Evaluation datasets and experiment runs.
• Automated evaluators and human review workflows.
• Production monitoring for latency, cost, errors, and quality signals.
• Strong fit with LangChain and LangGraph projects.
• Public pricing page with usage-based and team-oriented plans.³

Strengths

LangSmith's biggest advantage is completeness. Many teams start with LangChain or LangGraph, then need the operational layer around it. LangSmith gives those teams the shortest path from local debugging to trace inspection, eval datasets, and production monitoring.

It is especially strong for agent teams because agent failure is often trajectory-level rather than output-level. A final answer may look acceptable while the intermediate tool calls reveal wasted cost, unsafe actions, or brittle planning. LangSmith's tracing and eval workflows are designed for that kind of inspection.

Limitations

LangSmith is most compelling inside the LangChain/LangGraph ecosystem. Teams that want a fully vendor-neutral, open-source, or self-host-first control plane may prefer Langfuse or Phoenix. Pricing is public, but final cost depends on usage volume and plan details rather than a single flat number.

Pricing / public metrics

LangChain publishes LangSmith pricing publicly.³ Public customer count or revenue metrics for LangSmith specifically were not found in the required sources.

2. Braintrust — Best Evaluation-First Platform

Best for: Product and engineering teams that treat evals as a core development workflow: datasets, experiments, regressions, human review, and production trace feedback loops.

Braintrust is the most evaluation-centered platform in this ranking. Its homepage positions the product around evaluating, shipping, and improving AI products with experiments, datasets, logging, prompts, playgrounds, and human review.⁴ It also documents OpenTelemetry integration, which matters for teams standardizing on broader observability infrastructure.⁵

Key capabilities

• Datasets and experiments for repeatable evaluation.
• Online and offline scoring workflows.
• Human review and annotation loops.
• Prompt and model comparison.
• Production logging and trace feedback into evals.
• OpenTelemetry integration.⁵
• Public customer pages and case studies.⁶

Strengths

Braintrust is strongest when evals are not an afterthought. It encourages teams to convert examples, traces, feedback, and edge cases into durable datasets. That is the right mental model for production agents: every failure should become a future regression test.

It also has strong credibility signals. Braintrust publicly announced a Series A round and lists customer stories on its site.⁷⁶ Those are not product-performance metrics, but they show market adoption and investor confidence.

Limitations

Braintrust is less open-source-first than Langfuse, Phoenix, DeepEval, or Ragas. Teams that want to self-host the whole observability layer or inspect a full OSS server may find Langfuse or Phoenix more attractive. It is also evaluation-first: if your immediate pain is gateway-level request logging and cost analytics, Helicone may be faster to deploy.

Pricing / public metrics

Braintrust publishes pricing publicly.⁸ Its exact customer count, revenue, and usage volume are not publicly disclosed in the required sources.

3. Langfuse — Best Open-Source / Self-Hosted All-Around Harness

Best for: Teams that want an open-source, self-hostable platform for LLM observability, tracing, prompt management, evals, datasets, and experiments.

Langfuse is the strongest open-source all-around option. The Langfuse GitHub repository is public,⁹ the product has public pricing,¹⁰ and the self-hosting docs make deployment options explicit.¹¹ It also has a native OpenTelemetry integration, which is increasingly important as agent observability converges with standard telemetry.¹²

Key capabilities

• Open-source LLM observability platform.
• Traces, sessions, user tracking, and scores.
• Prompt management, datasets, and experiments.
• Automated evaluations and LLM-as-judge workflows.¹³
• Native OpenTelemetry integration.¹²
• Self-hosting support.¹¹

Strengths

Langfuse offers a rare combination: open-source transparency, self-hosting, modern eval workflows, and a broad observability surface. That makes it attractive for security-conscious teams, regulated industries, and engineering organizations that want to avoid immediate vendor lock-in.

It also fits heterogeneous stacks. If your agents are not built exclusively on one framework, Langfuse can still sit in the middle as a trace and eval layer.

Limitations

Self-hosting is powerful but not free operationally. Teams must run, secure, upgrade, and scale the deployment. Langfuse also may require more assembly than a fully managed enterprise platform for advanced governance, alerting, or cross-team adoption.

Pricing / public metrics

Langfuse publishes pricing and self-hosting information.¹⁰¹¹ Public revenue or customer-count metrics were not found in the required sources.

4. Arize Phoenix / Arize AX — Best OpenTelemetry and OpenInference-Oriented Stack

Best for: Teams that want open-source development observability through Phoenix and enterprise production AI observability through Arize AX, especially with OpenTelemetry and OpenInference-style instrumentation.

Arize is a serious production observability player, and Phoenix is one of the most important open-source projects in the LLM observability ecosystem. Phoenix is positioned for AI observability and evaluation,¹⁴ while Arize's agent observability material focuses on traces, tool calls, agent steps, and production monitoring.¹⁵ The Phoenix GitHub repo is public.¹⁶

Key capabilities

• Phoenix open-source observability and evaluation workflows.¹⁴¹⁶
• Arize AX enterprise AI observability.
• Agent observability for tool calls, traces, and multi-step behavior.¹⁵
• OpenTelemetry integrations.¹⁷
• OpenInference and OTel instrumentation narrative.¹⁸
• Enterprise credibility through Arize's public funding announcement.¹⁹

Strengths

Arize's advantage is observability depth. It comes from a machine-learning observability background and has moved aggressively into LLM and agent observability. Phoenix gives teams an open-source entry point, while AX provides a production enterprise path.

The OpenTelemetry story is also strong. As companies standardize traces and metrics across services, agent telemetry must not live in an isolated black box. Arize's OTel and OpenInference orientation fits that trend.

Limitations

The Phoenix/AX split can require clearer architectural decisions than a single SaaS-first product. Phoenix is attractive for development and open-source workflows; AX is the enterprise production layer. Teams must decide where each belongs in their lifecycle.

Pricing / public metrics

Phoenix is open source. Arize AX enterprise pricing is not publicly disclosed in the required sources. Arize publicly announced a $70 million Series C to build AI evaluation and observability infrastructure.¹⁹

5. Galileo — Best Enterprise Agentic Evaluation Platform

Best for: Enterprise teams that want managed agentic evaluations, workflow visibility, guardrails, dashboards, and monitoring without building their own evaluation platform from open-source components.

Galileo positions itself as an enterprise AI evaluation and observability platform.²⁰ It has public pricing information,²¹ public case studies,²² and a Google Cloud customer story.²³ Its agentic evaluations launch announcement specifically focuses on helping developers build reliable AI agents.²⁴

Key capabilities

• Agentic evaluations for multi-step agent workflows.²⁴
• Observability dashboards for AI systems.
• Quality, cost, latency, and error monitoring.
• Guardrails and evaluation workflows.
• Enterprise case studies and managed deployment orientation.²²²³

Strengths

Galileo's positioning is clear: enterprise-grade evaluation and observability for production AI. It is especially relevant for teams that want agent-specific evaluation workflows but do not want to assemble OSS tracing, custom metrics, and dashboards themselves.

The Google Cloud customer story is a useful credibility signal because enterprise buyers often care as much about operational maturity and partnerships as feature checklists.²³

Limitations

Galileo is less open-source-centered than Langfuse, Phoenix, DeepEval, Helicone, or Ragas. Teams that want local-first control, self-hosting transparency, or framework-level test code may prefer other options. Public technical detail varies by product area, and some enterprise terms require sales conversations.

Pricing / public metrics

Galileo publishes pricing information.²¹ Detailed customer counts, revenue, or platform usage metrics were not found in the required sources.

6. DeepEval / Confident AI — Best Code-First Agent Testing Framework

Best for: Developers who want pytest-style evals for LLM apps and agents, with an optional managed platform for dashboards, collaboration, and observability.

DeepEval is a code-first evaluation framework from Confident AI. Its homepage and GitHub repository make the open-source framework central,²⁵²⁶ while Confident AI provides the broader platform, docs, and pricing.²⁷²⁸²⁹

Key capabilities

• Open-source LLM evaluation framework.
• Unit-test-like evals for LLM applications.
• Metrics for answer correctness, hallucination, RAG, and agent behavior.
• CI-friendly developer workflow.
• Confident AI platform for dashboards and collaboration.²⁸

Strengths

DeepEval is one of the easiest recommendations for engineering teams that want evals in code. It maps naturally to the mental model developers already understand: write tests, run tests, fail builds, fix regressions.

That makes it strong for pre-production validation. If a team wants every prompt, agent workflow, or retrieval change to pass an eval suite before merge, DeepEval belongs on the shortlist.

Limitations

DeepEval alone is not the same as a complete production observability platform. For production trace ingestion, alerting, long-running session analytics, and organization-wide monitoring, teams may need Confident AI or another observability layer.

Pricing / public metrics

DeepEval is open source on GitHub.²⁶ Confident AI publishes pricing for its platform.²⁹ Public customer counts or usage metrics were not found in the required sources.

7. OpenAI Agent Evals — Best for OpenAI-Native Agent Builders

Best for: Teams building primarily with OpenAI's Agents stack who want evaluation, tracing, trace grading, and observability integrations close to the model and agent runtime.

OpenAI's Agent Evals guide focuses on evaluating agent workflows using traces, graders, datasets, and eval runs.³⁰ The Agents guide, observability integrations, and trace grading docs show a broader system for building and inspecting OpenAI-native agents.³¹³²³³

Key capabilities

• Agent eval workflows with traces, datasets, and graders.³⁰
• Agent-building docs and runtime guidance.³¹
• Observability integrations for agent traces.³²
• Trace grading for workflow-level assessment.³³
• Open-source openai/evals repository.³⁴

Strengths

The biggest advantage is proximity to the OpenAI agent stack. If your production agent is built around OpenAI APIs and Agents tooling, OpenAI Agent Evals can evaluate the native artifacts of that stack with less translation.

Trace grading is particularly relevant for agents because the process matters as much as the final text. A workflow can be wrong because of a tool choice, handoff, missing guardrail, or intermediate reasoning step.

Limitations

The trade-off is vendor neutrality. OpenAI Agent Evals is best when the rest of your stack is OpenAI-native. Teams comparing multiple model providers, frameworks, or hosting environments may prefer Braintrust, Langfuse, Phoenix, or LangSmith.

Pricing / public metrics

OpenAI publishes API pricing.³⁵ Pricing for the broader eval workflow depends on model usage and API calls. Public adoption metrics specifically for Agent Evals were not found in the required sources.

8. Helicone — Best Lightweight Gateway and Cost Observability Layer

Best for: Teams that need fast request-level observability, cost tracking, latency analytics, caching, routing, feedback, and scores without adopting a heavier eval platform on day one.

Helicone is a pragmatic gateway-style observability layer. Its pricing is public,³⁶ its scores feature is documented,³⁷ and its GitHub repository is public.³⁸ It also appears in the Vercel AI SDK observability provider docs.³⁹

Key capabilities

• LLM request logging and analytics.
• Cost, latency, and usage tracking.
• Scores and feedback workflows.³⁷
• Gateway features such as caching and routing.
• Open-source repository.³⁸
• AI SDK provider integration.³⁹

Strengths

Helicone's strength is speed. Many teams do not begin with a full eval discipline; they begin by asking, “How much are we spending, what requests are slow, and where are users unhappy?” Helicone answers those questions quickly.

It is also useful as a complement to deeper eval tools. A team can use Helicone for gateway analytics and another framework for offline evals or CI regression suites.

Limitations

Helicone is not the deepest agent trajectory evaluation platform in this ranking. Its own blog covers broader LLM observability and prompt evaluation frameworks,⁴⁰⁴¹ but teams needing complex multi-step agent scoring, dataset management, and CI gating may outgrow a gateway-first setup.

Pricing / public metrics

Helicone publishes pricing.³⁶ Public revenue, customer counts, or request-volume metrics were not found in the required sources.

9. Ragas — Best Specialized RAG Evaluation Framework

Best for: Teams focused on RAG quality, retrieval metrics, synthetic testset generation, and evaluation experiments rather than full production observability dashboards.

Ragas is one of the best-known open-source RAG evaluation frameworks. Its docs cover evaluation workflows,⁴² the website explains the project,⁴³ integrations are documented,⁴⁴ and cost-related guidance exists for evaluation applications.⁴⁵

Key capabilities

• RAG evaluation metrics.
• Testset generation and experimentation.
• Integrations with broader LLM tooling.⁴⁴
• Cost-aware evaluation guidance.⁴⁵
• Useful for retrieval quality and answer-grounding analysis.

Strengths

Ragas is excellent when the core production risk is retrieval quality: incomplete context, poor grounding, weak answer faithfulness, or bad retrieval recall. It gives teams metrics and workflows that are more specialized than generic text scoring.

It also pairs well with observability platforms. For example, a team might capture traces in Langfuse or Phoenix and use Ragas-style metrics for RAG-specific evaluation.

Limitations

Ragas is not a standalone production observability dashboard. It does not replace trace ingestion, alerting, session analytics, cost monitoring, or enterprise review workflows. It belongs in the evaluation toolkit, not as the only harness for production agents.

Pricing / public metrics

Ragas documentation and website are public.⁴²⁴³ Public pricing or revenue metrics for a managed Ragas platform were not found in the required sources.

Comparison Matrix

Where MCPlato Fits: The Workspace Harness Around the Eval Harness

MCPlato should not be ranked as a direct eval or observability vendor in this category. It is not a dedicated eval dashboard, not an OpenTelemetry pipeline, not a production trace warehouse, and not a replacement for LangSmith, Braintrust, Langfuse, Phoenix/AX, Galileo, DeepEval, OpenAI Agent Evals, Helicone, or Ragas.

Its role is different: MCPlato is a local-first AI Partner and workspace harness.⁴⁶ It helps teams coordinate the human and AI work that happens before, around, and after formal production evaluation:

• researching agent failures and user pain points;
• prototyping agent workflows across files, browser sessions, and tools;
• preparing eval datasets from local documents, notes, logs, and research;
• running multi-session AI work with persistent local context;
• keeping humans in the loop during debugging and review;
• organizing workspace memory, artifacts, and connected materials around a project.

That makes MCPlato complementary to the eval stack. A practical workflow might look like this:

1. Use MCPlato to investigate failure reports, collect examples, inspect local files, coordinate research sessions, and draft eval cases.
2. Use LangSmith, Braintrust, Langfuse, Phoenix/AX, Galileo, DeepEval, OpenAI Agent Evals, Helicone, or Ragas to run telemetry, trace ingestion, dashboards, eval scoring, alerting, and CI/CD regression.
3. Bring failures and insights back into MCPlato for human review, documentation, prototype iteration, and workspace-level collaboration.

MCPlato's changelog shows an evolving desktop AI workspace product,⁴⁷ but teams should treat it as the collaboration and orchestration environment around their eval harness, not as the eval harness itself.

Choosing Guide by Team Type

If you are a LangChain or LangGraph-heavy team

Start with LangSmith. It gives the most direct path from framework-native traces to production monitoring and evals.

If your organization is building an eval discipline

Choose Braintrust if datasets, experiments, human review, and regression workflows are the center of your AI quality process.

If you need open source or self-hosting

Shortlist Langfuse, Arize Phoenix, DeepEval, Helicone, and Ragas. Langfuse is the strongest all-around self-hosted observability option; Phoenix is strong for open observability and OpenInference; DeepEval and Ragas are more framework-like.

If OpenTelemetry alignment is a priority

Look closely at Arize Phoenix / AX, Langfuse, and Braintrust. OpenTelemetry matters because agent traces should eventually coexist with service traces, infrastructure metrics, and incident workflows.

If you need enterprise managed evaluation

Evaluate Galileo, Arize AX, Braintrust, and LangSmith. The right choice will depend on governance, support, deployment, integrations, and how much evaluation logic you want to own.

If you are OpenAI-native

Use OpenAI Agent Evals early, especially if you are building with OpenAI Agents and want native trace grading. Consider a vendor-neutral layer if you expect multi-model or multi-framework expansion.

If you need quick request/cost visibility

Start with Helicone. It is one of the fastest ways to understand spend, latency, and request behavior.

If RAG quality is the main risk

Use Ragas alongside a broader observability tool. It is a metric framework, not a full production dashboard.

If your bottleneck is workspace orchestration

Use MCPlato when the team needs a local-first AI workspace for research, prototyping, debugging, dataset preparation, and human collaboration. Then connect the resulting eval cases and operational learnings to a dedicated eval/observability platform.

The Bigger Picture: Evals + Traces + OTel + Human Review + Workspace Orchestration

The direction of the market is clear. Production agent quality is becoming a closed loop:

1. Instrument everything. Capture model calls, tool calls, retrieval, handoffs, user feedback, cost, latency, and errors.
2. Convert traces into evals. Every serious failure should become a dataset row, regression test, or human-review item.
3. Run evals before deployment. CI/CD gates should catch prompt, model, tool, and workflow regressions.
4. Monitor after deployment. Online scores, alerts, and dashboards should surface drift and silent failure.
5. Keep humans in the loop. Reviewers still matter for ambiguous tasks, policy decisions, edge cases, and trust calibration.
6. Use workspace orchestration. Tools like MCPlato help teams organize the surrounding work: research, context, files, memory, collaboration, and debugging artifacts.

No single tool owns the whole loop perfectly. LangSmith, Braintrust, Langfuse, Phoenix/AX, Galileo, DeepEval, OpenAI Agent Evals, Helicone, and Ragas each cover different slices. MCPlato covers a different but increasingly important layer: the local workspace where humans and AI agents prepare, inspect, and iterate before production quality systems enforce the rules.

For most production teams in 2026, the winning stack will not be one dashboard. It will be a combination of agent traces, repeatable evals, OpenTelemetry-compatible observability, human review, and a workspace harness that keeps the work coherent.

References

Footnotes

1. LangSmith Observability — https://www.langchain.com/langsmith/observability ↩

2. LangSmith Evaluation Docs — https://docs.langchain.com/langsmith/evaluation ↩

3. LangChain Pricing — https://www.langchain.com/pricing ↩ ↩²

4. Braintrust Homepage — https://www.braintrust.dev/ ↩

5. Braintrust OpenTelemetry Integration — https://www.braintrust.dev/docs/integrations/sdk-integrations/opentelemetry ↩ ↩²

6. Braintrust Customers — https://www.braintrust.dev/customers ↩ ↩²

7. Braintrust Series A Announcement — https://www.braintrust.dev/blog/announcing-series-a ↩

8. Braintrust Pricing — https://www.braintrust.dev/pricing ↩

9. Langfuse GitHub — https://github.com/langfuse/langfuse ↩

10. Langfuse Pricing — https://langfuse.com/pricing ↩ ↩²

11. Langfuse Self-hosting — https://langfuse.com/self-hosting ↩ ↩² ↩³

12. Langfuse OpenTelemetry Integration — https://langfuse.com/integrations/native/opentelemetry ↩ ↩²

13. Langfuse Automated Evaluations — https://langfuse.com/blog/2025-09-05-automated-evaluations ↩

14. Arize Phoenix — https://arize.com/phoenix/ ↩ ↩²

15. Arize Agent Observability — https://arize.com/ai-agents/agent-observability/ ↩ ↩²

16. Arize Phoenix GitHub — https://github.com/arize-ai/phoenix ↩ ↩²

17. Arize AX OpenTelemetry Integration — https://arize.com/docs/ax/integrations/opentelemetry/opentelemetry-arize-otel ↩

18. Arize OTel / OpenInference Blog — https://arize.com/blog/zero-to-a-million-instrumenting-llms-with-otel/ ↩

19. Arize Series C Announcement — https://arize.com/blog/arize-ai-raises-70m-series-c-to-build-the-gold-standard-for-ai-evaluation-observability/ ↩ ↩²

20. Galileo Homepage — https://galileo.ai/ ↩

21. Galileo Pricing — https://galileo.ai/pricing ↩ ↩²

22. Galileo Case Studies — https://galileo.ai/case-studies ↩ ↩²

23. Google Cloud Customer Story: Galileo — https://cloud.google.com/customers/galileo ↩ ↩² ↩³

24. Galileo Agentic Evaluations Announcement — https://www.prnewswire.com/news-releases/galileo-launches-agentic-evaluations-to-empower-developers-to-build-reliable-ai-agents-302358451.html ↩ ↩²

25. DeepEval Homepage — https://deepeval.com/ ↩

26. DeepEval GitHub — https://github.com/confident-ai/deepeval ↩ ↩²

27. Confident AI DeepEval Framework — https://www.confident-ai.com/frameworks/deepeval ↩

28. Confident AI Docs — https://www.confident-ai.com/docs ↩ ↩²

29. Confident AI Pricing — https://www.confident-ai.com/pricing ↩ ↩²

30. OpenAI Agent Evals Guide — https://developers.openai.com/api/docs/guides/agent-evals ↩ ↩²

31. OpenAI Agents Guide — https://developers.openai.com/api/docs/guides/agents ↩ ↩²

32. OpenAI Agents Observability Integrations — https://developers.openai.com/api/docs/guides/agents/integrations-observability ↩ ↩²

33. OpenAI Trace Grading — https://developers.openai.com/api/docs/guides/trace-grading ↩ ↩²

34. OpenAI Evals GitHub — https://github.com/openai/evals ↩

35. OpenAI Pricing — https://developers.openai.com/api/docs/pricing ↩

36. Helicone Pricing — https://www.helicone.ai/pricing ↩ ↩²

37. Helicone Scores Docs — https://docs.helicone.ai/features/advanced-usage/scores ↩ ↩²

38. Helicone GitHub — https://github.com/Helicone/helicone ↩ ↩²

39. AI SDK Helicone Observability Provider — https://ai-sdk.dev/providers/observability/helicone ↩ ↩²

40. Helicone LLM Observability Platforms Guide — https://www.helicone.ai/blog/the-complete-guide-to-LLM-observability-platforms ↩

41. Helicone Prompt Evaluation Frameworks Guide — https://www.helicone.ai/blog/prompt-evaluation-frameworks ↩

42. Ragas Docs — https://docs.ragas.io/en/stable/ ↩ ↩²

43. Ragas Website — https://www.ragas.io/ ↩ ↩²

44. Ragas Integrations — https://docs.ragas.io/en/stable/howtos/integrations/ ↩ ↩²

45. Ragas Cost Docs — https://docs.ragas.io/en/v0.2.5/howtos/applications/_cost/ ↩ ↩²

46. MCPlato Homepage — https://mcplato.com/en/ ↩

47. MCPlato Changelog — https://mcplato.com/en/changelog/ ↩