Agenta

Editor’s note: This Agenta review is based on my hands-on test of Agenta Cloud and the self-hosted open-source edition (release v0.125, October 2026) with the Python SDK. I weighed pricing, setup, prompt management, evaluation, tracing, the 2.0 agent workspace, self-hosting, and rivals.

Quick verdict: I recommend Agenta for teams that want prompt versioning, evals and OpenTelemetry tracing in one MIT-licensed app with unlimited self-hosted users. The trade-off: since Agenta 2.0 (July 2026), product and pricing are built around agents and credits, and new development centers on agents rather than the prompt, eval and tracing stack.

Agenta comes from Agentatech UG in Berlin, founded by Mahmoud Mabrouk. Agenta 2.0 launched on July 22, 2026 as an open-source workspace for agents, and paid Cloud starts at $29/month for unlimited members.

In this review, I’ll take a closer look at Agenta’s pricing, features, and tracing tools, so you can see exactly whether it fits your team.

Key Takeaways

• Hobby costs $0: 500 signup credits plus 75 a day on up to 10 days a month; 1 project, 2 members.
• Starter costs $29/month: 2,900 credits, unlimited members. Business ($299/month) adds 32,000 credits, SSO, RBAC and a SOC 2 Type II report.
• One app for the LLMOps loop: a side-by-side prompt playground, 15+ built-in evaluators and OpenTelemetry tracing with 12 integrations.
• No trace or eval allowance: credits meter agent runtime and included models.
• Plan names out of sync: published retention and rate limits still use the retired Pro tier, so Starter’s limits are unclear.

Pros and Cons

How Much Does Agenta Cost?

Agenta sells four Cloud plans, from $0 to custom pricing, with no per-seat charge on any of them. The meter is credits, which pay for runtime and included models rather than a set number of traces.

• Hobby ($0): for trying Agenta, with 500 signup credits and 75 credits a day on up to 10 days a month. It allows 2 concurrent tasks, 1 project and 2 members, and you cannot buy extra credits.
• Starter ($29/month): for small teams, with 2,900 credits a month, 20 concurrent tasks, unlimited projects and members, shared credentials, unlimited schedules and event triggers, live chat support and credit packs.
• Business ($299/month): for teams with security reviews, with 32,000 credits a month, 50 concurrent tasks, SSO and role-based access control, the SOC 2 Type II report and private Slack support.
• Enterprise (custom): for negotiated terms, with custom credits, limits and data retention, plus audit logs, custom domains and a custom SLA.

Plan	Price	Monthly credits	Concurrent tasks	Members	Key extras
Hobby	$0	None; signup and daily credits	2	2	1 project
Starter	$29/month	2,900	20	Unlimited	Shared credentials, live chat
Business	$299/month	32,000	50	Unlimited	SSO, RBAC, SOC 2 report
Enterprise	Custom	Custom	Custom	Unlimited	Custom retention, audit logs, SLA
Self-hosted open source	Free	No credit meter	Not capped	Unlimited	RBAC, SSO login providers, evaluations, run logs

A short task costs about 3 credits, a research report about 18, and one hour of runtime about 50 before model costs. With your own API key or ChatGPT subscription, the model costs no credits, but runtime still does.

Starter and Business can top up with credit packs:

• 1,000 credits: $10.
• 2,500 credits: $25.
• 10,000 credits: $100.

There are no overage charges: when credits run out, running tasks finish and new ones wait. Unused daily and monthly credits do not roll over, and signup and purchased credits expire after 12 months.

Langfuse Core also costs $29/month but meters 100K units, with $8 per 100K overage. LangSmith Plus charges $39 per seat per month, so its bill grows with every person you add. Early-stage startups, students and researchers can email team@agenta.ai for discounted or free access.

Is Agenta Good Value for Money?

• Starter suits collaborative teams: a 10-person team pays $29/month before extra credits, against $390/month in LangSmith Plus seat fees.
• Own keys cut the model bill: with your own API keys the model costs no credits, so Starter’s 2,900 credits go to runtime alone.
• Retention needs confirmation: Agenta’s published retention still lists Hobby at 1 week, Pro at 1 month and Business at 3 months under retired plan names, and the current plans only name Enterprise’s custom retention. Confirm Starter’s retention before committing.
• Business buys compliance: at $299/month, it is the cheapest Cloud plan with SSO and the SOC 2 Type II report.

Reviewer’s Notes: I recommend Hobby for testing, then Starter ($29) for a team using its own model keys. Pay for Business only when SSO or the SOC 2 report is a procurement requirement; teams with ops capacity can self-host the MIT edition for free.

My Experience With Agenta

I started on Agenta Cloud’s free Hobby plan, which comes with 500 signup credits, and worked from a first prompt to a traced Python app.

Signing Up and Creating My First Prompt

I signed up with Hobby’s limits in place: 2 concurrent tasks, 1 project and 2 members. I created a prompt in the playground, writing inputs as {{variable}}. The editor also accepts Jinja2 templating for conditionals and filters.

I picked OpenAI for my app. The model menu also offered:

• Anthropic Claude.
• Google Gemini.
• Mistral.
• DeepSeek.
• OpenRouter.
• Custom providers.

Model settings covered temperature from 0 to 2, top-k, and presence and frequency penalties.

For repeatable comparisons, I could load test sets from CSV, the UI or the API, then run every row through each variant. Chat prompts also accept images and PDFs as attachments, which matters if your app reads invoices or screenshots.

Comparing Variants Side by Side

I clicked +Compare to duplicate the variant into a second column, then compared the two outputs with their response time and cost per request.

I used Commit to save the winner as a version and Deploy to push it to one of three environments: development, staging or production. My app code then pulled the deployed configuration for its environment through the SDK, so a prompt change no longer needed a code release.

Tracing My First App

I installed the packages with pip install -U agenta openai opentelemetry-instrumentation-openai; the agenta package needs Python 3.11 to 3.13. I set AGENTA_API_KEY; Cloud uses https://cloud.agenta.ai as the host, so AGENTA_HOST only mattered for my self-hosted instance.

I called ag.init(), enabled OpenAI instrumentation and decorated my function with @ag.instrument() before opening Observability:

import agenta as ag
from opentelemetry.instrumentation.openai import OpenAIInstrumentor
ag.init()
OpenAIInstrumentor().instrument()

@ag.instrument()
def generate():
    ...

The decorator wraps the function in a span, and the OpenAI instrumentor records each model call inside it. Agenta can turn those traces into a test set, which closes the loop back to the playground and its evaluators. JavaScript and TypeScript apps take a different route, through OpenTelemetry for Node.js.

Reviewer’s Notes: The v1.0 section of Agenta’s docs that covers this workflow is marked no longer actively maintained since 2.0. Users have also reported a Jinja2 bug: variables used only inside if/for blocks go missing from the inputs, so the prompt call returns HTTP 400. Test any template with conditional blocks before you deploy it.

This flow suits teams where subject-matter experts edit prompts in the playground while engineers ship the application code.

Prompt Management and the Playground

Every prompt change in Agenta is a committed version that you deploy to development, staging or production, and your code pulls the deployed configuration at runtime. That gives teams prompt changes without a code deploy.

Agenta prompt management covers:

• Provider selection: OpenAI GPT, Anthropic Claude, Google Gemini, Mistral, DeepSeek, OpenRouter and custom providers.
• Templating: {{variable}} inputs or Jinja2, with the conditional-input bug covered in My Experience With Agenta.
• Side-by-side comparison: variant outputs shown with response time and cost per request.
• Version history: Commit saves each prompt version instead of leaving an untracked playground edit.
• Environments: Deploy assigns a version to development, staging or production.
• Runtime retrieval: the SDK or API returns the configuration for the selected environment.

The link between versioning and evaluation matters more to me than provider breadth. A committed version can run against a test set before it reaches production, so prompt editing and regression checks live in one app.

PromptLayer and Langfuse also version prompts, and PromptLayer Pro costs $49/month. Agenta’s edge is that the same app runs evals against those versions.

Humanloop, once the closest rival here, shut down on September 8, 2025 after its team joined Anthropic, so its former users need a new home.

Best for: cross-functional teams that want prompt editing tied to evaluation and deployment.

Skip if: tracing is the main purchase and prompt editing is secondary; compare Langfuse first.

Evaluation: Built-In Checks, LLM-as-a-Judge and Online Evals

Agenta ships 15+ built-in evaluators, from exact string checks to model-graded RAG scoring, so format checks and RAG grading need no custom code.

• String and regex checks: Exact Match, Starts With, Ends With, Contains, Contains Any, Contains All, Regex Test and Levenshtein Distance.
• JSON checks: Contains JSON, JSON Multi-Field Match and JSON Diff Match.
• Similarity checks: Jaccard Similarity Match and Semantic Similarity.
• Model-graded checks: LLM-as-a-judge, RAG Faithfulness and RAG Context Relevancy.
• Custom evaluation: Python, JavaScript and TypeScript code evaluators with access to inputs, outputs and trace data, plus webhook evaluators.
• Human annotation: A/B testing and multiple metrics, with annotation queues for subject-matter review.

I recommend deterministic checks for hard requirements and LLM-as-a-judge only for criteria that need interpretation. A JSON-format rule belongs in JSON Multi-Field Match, not in a judge prompt that costs a model call per row.

Online evaluation scores production traffic:

1. Open Evaluations, select the Online Evaluation tab and choose Create.
2. Pick evaluators and filter traces by app, variant or metadata.
3. Set a sampling rate and create the evaluation.
4. Review aggregated metrics over time, then drill into individual traces.

Agenta also builds test sets from traces, which brings production failures back into the pre-deployment checks from Prompt Management and the Playground.

Agent trajectory scoring is still missing. Users have asked for an evaluator that scores tool-call sequences, not just final outputs.

Reviewer’s Notes: I recommend Agenta for prompt-output regression checks and sampled production evaluation. For agent-heavy evaluation, I shortlist Braintrust or LangSmith instead, because scoring a final answer says nothing about whether the agent called the right tools in the right order.

Observability: OpenTelemetry Tracing for LLM Apps

Agenta’s tracing is OpenTelemetry-based, so OTel instrumentation you already run can feed it. I prefer that to proxy logging when traces need to cover application functions as well as model calls.

The 12 documented integrations group like this:

• Model access: OpenAI, LiteLLM and Instructor.
• Frameworks: LangChain, LangGraph, LlamaIndex and DSPy.
• Agent SDKs: Agno, Google ADK, OpenAI Agents SDK and PydanticAI.
• JavaScript: Vercel AI SDK.
• Raw OpenTelemetry: collector config, distributed tracing, session tracking and cost tracking.

For Agenta 2.0 agents, every invocation returns an x-ag-trace-id header, and GET /api/traces/{id} returns the full trace. Spans separate the workflow, the agent harness loop, LLM calls and tool calls, so a slow tool and a slow model show up as different spans.

Usage events carry input, output and total tokens plus cost. Fields can be missing when a provider does not report them, so an absent cost field does not mean zero spend.

Cloud’s API rate limits (burst/per-window) still use the old plan names:

Endpoint group	Hobby	Pro	Business
Config retrieval and trace ingestion	1,200	3,600	36,000
Trace queries	120	180	1,800
General endpoints	480	1,440	3,600

Agenta still labels the middle tier Pro, so confirm which limits apply to Starter before you size ingestion. Exceeding a limit returns HTTP 429 with a Retry-After header, which your client should retry rather than log as a failed model call.

Langfuse and Arize Phoenix offer comparable OpenTelemetry tracing, while Helicone logs through a proxy. I favor Agenta when traces also need to become evaluation test sets, not just debugging records.

Cloud stores data in EU or US regions, and Enterprise adds dedicated instances. Confirm region and retention together before sending production prompts.

Agenta 2.0: The Agent Workspace

Agenta 2.0 launched on July 22, 2026 as an open-source workspace for agents. It moved the product from managing and evaluating prompts to building agents by chatting with them and running them on schedules or events.

Each agent has five parts:

• Instructions: an AGENTS.md file.
• Tools: built-in integrations or MCP servers.
• Skills: reusable skills, built on the same open standards as AGENTS.md and MCP.
• Permissions: which tools and actions the agent may use.
• Files: the files the agent works with.

Agents run on Claude Code, Pi or Codex harnesses, and you can switch models without rebuilding the agent. That helps teams already standardized on one of those harnesses.

The workspace also includes:

• Execution: each agent gets its own computer and browser, plus AI Drive.
• Connections: 1,000+ integrations and MCP servers.
• Automation: schedules and event triggers, unlimited from Starter.
• Controls: approvals and tool permissions.
• Messaging: publishing to Slack, WhatsApp and Telegram.

Agenta’s sample agents include one that tracks competitors every Monday and sends a Gmail digest, and another that finds new PostHog users and drafts outreach.

This is what the credit meter is built for: agent runtime and included model usage. For a team buying only observability, the workspace is extra surface, not a reason to choose Agenta.

Prompt management, the playground, tracing and evaluation still ship in both the open-source and commercial editions. I still assess Agenta as an agent workspace with LLMOps features, because that is where the 2.0 release put its focus.

Self-Hosting and Open Source Licensing

Everything outside Agenta’s ee/ folder is MIT-licensed; production use of ee/ requires a subscription or an enterprise license. Free self-hosting is Agenta’s strongest differentiator, provided your team can run it.

Docker Compose serves the app at http://localhost with one command:

docker compose -f hosting/docker-compose/oss/docker-compose.gh.yml --env-file hosting/docker-compose/oss/.env.oss.gh --profile with-web --profile with-traefik up -d

An official Helm chart covers Kubernetes. The open-source edition includes:

• Unlimited usage: users, projects, agents, runs and evaluations.
• Identity controls: RBAC with six built-in roles, plus login providers such as Google, GitHub and Okta set at deploy time.
• Application controls: run logs and versioned configurations.

Organization-managed SSO is commercial only, along with domain verification, custom roles and audit logs. Agents run in a local Docker runner or in Daytona cloud sandboxes, and your own Claude, ChatGPT or Codex subscription can power them.

Plan for these ops tasks:

• Docker memory: low memory can kill the web container.
• Runner access: the runner container needs /dev/fuse on the host.
• Release pinning: pin image tags to a release version.
• Migrations: run alembic upgrade head inside the API container after upgrades.
• Sign-ups: they are open by default, so lock them down on a reachable instance.

Agenta released v0.125.3 on October 27, 2026 and ships one to three tagged releases a day, so schedule upgrades rather than chasing every tag.

How Does Agenta Compare to Competitors?

Among Agenta alternatives, Agenta is the pick when you want prompt management, evals and tracing in one MIT-licensed app, with unlimited Cloud seats from $29/month.

• Langfuse: my pick for the deepest open-source tracing. Hobby includes 50K units free; Core costs $29/month and Pro $199/month. Hobby keeps 30 days of data for 2 users, and SSO on Pro needs the $300/month Teams add-on, so the entry price is not the full security budget.
• LangSmith: my pick for LangChain and LangGraph teams. Developer includes 5K base traces free; Plus costs $39 per seat/month, which makes Agenta cheaper once subject-matter experts need seats.
• Braintrust: my evals-first alternative. Starter is free and Pro costs $249/month with unlimited users, and I rank it ahead of Agenta when evaluation is the main purchase.
• Arize AX and Phoenix: my pick for local-first tracing with open-source Phoenix. AX Free includes 25K spans and AX Pro costs $50/month; self-hosting AX requires Enterprise.
• Helicone: my pick for proxy-based request logging without an SDK. Hobby includes 10K requests free and Pro costs $79/month, a better fit when request visibility matters more than prompt deployment.
• Opik by Comet: the cheapest hosted paid entry here. The free Cloud tier includes 25K spans, and Pro costs $19/month for 100K spans with 60-day retention, so compare it first if Starter’s $29 is over budget.

Tool	Free tier	Paid entry	Self-host	Best for
Agenta	Hobby signup and daily credits	$29/month, unlimited members	Yes, MIT core	Prompt, eval and trace workspace
Langfuse	50K units	$29/month	Yes, open source	Open-source tracing
LangSmith	5K base traces	$39/seat/month	Enterprise	LangChain and LangGraph
Braintrust	Starter, 1 GB processed data	$249/month	Ask vendor	Evals-first teams
Arize	AX: 25K spans	AX: $50/month	Phoenix open source; AX Enterprise	Local Phoenix or hosted AX
Helicone	10K requests	$79/month	Ask vendor	Proxy request logging
Opik	25K spans	$19/month	Yes, open source	Low-cost hosted entry

For Agenta vs Langfuse, the $29 entry price is the same, so the workflow decides: Agenta pairs prompt collaboration with evals and agent execution, while Langfuse gives a clearer unit-based observability meter.

How I Reviewed Agenta

I signed up for Agenta Cloud on the Hobby plan and self-hosted the open-source edition with Docker Compose. I built prompt variants, compared them side by side, then committed and deployed a version.

I ran built-in and LLM-as-a-judge evaluators and traced an OpenAI app with the Python SDK. I also weighed the ops work the self-hosted edition needs and checked credit costs and rate limits for each plan.

I compared Agenta with Langfuse, LangSmith, Braintrust, Arize, Helicone and Opik, weighing credit limits, retention gaps and security-plan gating alongside the monthly price.

User-reported issues, including the Jinja2 template bug and the missing trajectory evaluator, also shaped my recommendations.

Prices current as of October 2026.

Should You Use Agenta for LLM Observability?

Agenta bundles a prompt playground, versioned deployments, 15+ evaluators and OpenTelemetry tracing in one MIT-licensed app. Unlimited Cloud seats from $29/month mean every prompt editor gets access without a seat budget.

I recommend it for small-to-mid teams that can self-host or accept credit-based Cloud billing. Starter covers team access, and Business earns its $299/month only when SSO or the SOC 2 Type II report is required. Self-hosters should budget ops time for the runner container and post-upgrade migrations.

I do not recommend Agenta as the default if you need trace-volume pricing, published per-plan retention or agent trajectory evals. Pick Langfuse for a metered observability purchase, or Braintrust when evaluation depth drives the decision.

Since the July 2026 pivot put agents first, start with the free Hobby plan or the Docker Compose install and trace one app before paying.

FAQs

Is Agenta free?

Yes. Agenta has a $0 Hobby Cloud plan and a free MIT-licensed self-hosted edition. Hobby includes 500 signup credits plus 75 credits a day on up to 10 days a month, with 1 project and 2 members. Hobby cannot buy extra credits, so heavier use means Starter at $29/month. Self-hosting removes the user and run limits if your team can manage the infrastructure.

Is Agenta open source?

Yes. Agenta is MIT-licensed outside the ee/ folder, which needs a subscription or enterprise license for production use. The repository has about 4.9K GitHub stars. The free core does not include organization-managed SSO, custom roles or audit logs.

Is Agenta still an LLMOps platform after 2.0?

Yes. Prompt management, the playground, tracing and evaluation remain in both the open-source and commercial editions. Agenta 2.0 moved the positioning toward agents in July 2026, and the credit-based plans reflect that, so weigh the agent-focused billing before choosing it only for production observability.

Does Agenta support OpenTelemetry?

Yes. Agenta’s tracing is OpenTelemetry-based, with a Python SDK and a JavaScript/TypeScript quickstart. Integrations include OpenAI, LangChain, LlamaIndex, LiteLLM and Vercel AI SDK. Token and cost fields can be absent when a provider does not report them. See Observability: OpenTelemetry Tracing for LLM Apps above.

Does Agenta train on my data?

No. Agenta states that it does not use your prompts or data to train AI models. Cloud offers EU and US data regions, and Enterprise supports dedicated instances. Confirm your region and retention terms before sending sensitive production data, since current per-plan retention is not published.