dari.dev

dari.dev

LLM routing that picks the cheapest model still hitting your quality bar, without stalling the agent loop.

73/100Safe BetFree · from $49/moFreemium

Dari targets the metric that actually shows up on invoices — cost per task, not cost per token — and speculative routing is the most credible answer we've seen to prompt-cache economics in an agent loop. The 65.2% cost reduction is vendor-run, so reproduce the evals on your own workload before you commit. Graft it onto Claude Code or Codex with `dari claude` and you'll know within a sprint whether the routing quality holds.

Verified 4d ago · liveness 73/100 · cite: rightaichoice.com/tools/dari-dev

Best for
  • Engineering teams optimising LLM cost per task, not cost per token
  • AI startups running multi-turn agent loops with stable prompt prefixes
  • Teams already standardised on Claude Code, Codex or Pi who want routing without a rewrite
  • Systems integrators routing across multiple OpenAI-compatible providers
Not ideal for
  • Teams that need a large, long-established routing ecosystem with third-party adapters today
  • Buyers needing contractual, guaranteed pricing locked in before they commit
  • Non-developers looking for a no-code agent builder
Visit Website

IntermediateFor a developer already running Claude Code, Codex or Pi: minutes to a routed run via the CLI install and a base-URL swap. For an OpenAI-compatible client, the change is the same one-endpoint swap. Reaching a trustworthy cost-per-task number takes longer, because you should benchmark against your own traces rather than the vendor's.Web · API · CLIAPI availableVerified 4d ago
Pricing
Free · from $49/mo
FreemiumFree tier3 plans3 hidden costs
Learning curve
Intermediate
For a developer already running Claude Code, Codex or Pi: minutes to a routed run via the CLI install and a base-URL swap. For an OpenAI-compatible client, the change is the same one-endpoint swap. Reaching a trustworthy cost-per-task number takes longer, because you should benchmark against your own traces rather than the vendor's.
Runs on
WebAPICLI
API available · 4 integrations
Who it's for
Backend engineer on a small AI startupPlatform lead at a systems integratorEngineer shipping an OpenAI-compatible agent
Live sentiment
Is dari.dev actually worth it?

We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.

  • Honest verdict, not marketing
  • Real pros & cons from real users
  • Attributed quotes with receipts
Run a free scan

3 free scans · no card needed

Skip it if

Skip dari.dev if you need a routing stack with years of production mileage and a large plugin ecosystem, or if your agent is single-turn and prefix-unstable where mid-loop switching rarely pays for itself.

The 30-second take
Biggest gripe

Switching models mid-loop can throw away a warm prompt cache — the router weighs this, but a badly timed switch still costs you the cache read you already paid for.

Price reality

Positioned as a spend-reduction layer rather than a per-seat tool, so its economics are judged against your model bill: a team routing between a $5.00/M model and a $1.40/M model (with cache reads at $0.50 and $0.14) can justify a routing layer on token savings alone. Compare against assembling LiteLLM plus an observability tool yourself.

In short

dari.dev — LLM routing that picks the cheapest model still hitting your quality bar, without stalling the agent loop. Best for Engineering teams optimising LLM cost per task, not cost per token, AI startups running multi-turn agent loops with stable prompt prefixes, Teams already standardised on Claude Code, Codex or Pi who want routing without a rewrite. Free to start; paid plans from $49/mo.

What people actually say about dari.dev — is it worth it?

We scanned public community sources for dari.dev on Aug 1, 2026 and could not establish that the discussion we found is about this tool rather than something else sharing its name. Our own analysis of that scan says the posts were off-subject. Rather than publish a sentiment score built on the wrong subject, we publish nothing here and re-run the scan.

Viability Score

73/100
Safe Bet

How well maintained and how widely used is dari.dev? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this

Recent activity
90
Traction
100
Site health
95
User sentiment
35
What the vendor publishes
40

Last calculated: October 2026

How we score →

Key Features

  • Automatic routing that picks a model, thinking level and turn count per task step
  • Speculative routing: router runs in parallel with the model and switches the next step
  • Cache-aware selection weighing cache warmth and upcoming turns, not just token price
  • Open-weight router model trained by the vendor
  • Drop-in with Claude Code, Codex, Pi, or any OpenAI-compatible client
  • CLI install and `dari claude` command to route existing tools
  • One endpoint as a base URL replacement for your current provider
  • Model selection persists across multiple turns
  • Task-context awareness using conversation and recent progress
  • Benchmark-evidence input using candidate eval results
  • Projected-cost input based on cache warmth and upcoming turns
  • Published self-benchmarks: Next.js Self-Bench (47 tasks), Snowflake Data-Eng-Bench (103 tasks), Terminal-Bench 2.1 via
  • Claimed 65.2% lower cost per task at the same accuracy
  • Python and TypeScript SDKs
  • Hosted runtime for agent execution

About dari.dev

FreemiumIntermediateAPI availableWeb · API · CLI

dari.dev is a routing layer for AI agents that picks the model for each step instead of making you hard-code one. Point your agent at a single endpoint and Dari's open-weight router chooses the model, thinking level and turn count using task context, benchmark evidence and projected cost. It's aimed at engineering teams, AI startups and systems integrators whose bill scales with agent loops rather than one-off prompts. The differentiator is speculative routing: the router runs in parallel with the model and switches the next step rather than blocking on a verdict, so selection isn't the bottleneck. Because switching mid-loop has a cost, the router is cache-aware. The homepage price table puts GPT-5.6-sol at $5.00 per million tokens with a $0.50 cache read against GLM 5.2 at $1.40 with a $0.14 cache read, and those numbers feed the projected-cost input alongside upcoming turns. Setup keeps the agent you already run. Install the CLI from a single curl command, run `dari claude`, and Claude Code, Codex, Pi or any OpenAI-compatible client routes through Dari. Python and TypeScript SDKs are available, and the hosted runtime can execute agents directly. A selection can persist across multiple turns rather than being re-decided every call. Dari publishes its own evals rather than hiding behind a leaderboard: Next.js Self-Bench across 47 tasks, Snowflake Data-Eng-Bench across 103 tasks and Terminal-Bench 2.1 with Mini-SWE across 89 tasks, claiming 65.2% lower cost per task at the same accuracy. It is in early access. Against LiteLLM you get selection plus runtime rather than a library to wire up; against Helicone you get routing rather than observability.

Behind the Verdict

Most routing libraries ask you to write the policy. Dari asks you to trust a router model it trained and publishes evals for. That's the real trade: less control, far less glue code. Pick it when your spend is dominated by multi-turn agent loops with stable prompt prefixes. That's where cache-aware selection matters — a cheaper model that blows the cache can cost more than the expensive one you were avoiding. The GPT-5.6-sol ($5.00 in, $0.50 cache read) versus GLM 5.2 ($1.40 in, $0.14 cache read) comparison on the homepage is exactly the math the router is doing for you. Pick it if you're already on Claude Code, Codex or Pi. The install is one curl and `dari claude`; there's no migration project. Any OpenAI-compatible base URL works too. Pass if you need contractual, guaranteed pricing today. Early access means terms and roadmap are in motion. Pass if your workload is a handful of long prompts where you've already tuned the model by hand — the router has little to work with. And pass if you want a routing ecosystem with years of third-party adapters; this is young. The closest comparison is LiteLLM. LiteLLM gives you a library and you define the rules; Dari gives you a router that decides, plus a hosted runtime. If your team enjoys owning the policy, LiteLLM is fine. If nobody wants to maintain a cost-routing heuristic, Dari earns its fee. Helicone sits in a different slot — observability, not selection — and the two are complementary. Where it bites: the accuracy figures come from Dari's own benchmarks. Vendor evals are a signal, not proof. Run the 47-task Next.js Self-Bench or the 103-task Snowflake bench against your own prompts, then watch cost per completed task for two weeks.

Researching dari.dev? Get your full AI stack in 60 seconds.

Free, no signup — tell us your goal and get tools matched to your budget & existing stack.

Real-world workflow fit

Concrete scenarios for the personas dari.dev actually fits — and what changes day-one when you adopt it.

Backend engineer on a small AI startup

Installs the dari CLI, runs `dari claude` so the existing Claude Code agent points at dari.dev as its base URL, and lets the router pick between a large and a small model step by step using benchmark evidence and cache warmth.

Outcome: The same agent keeps running with no code rewrite, while cost per task drops on the multi-turn loops that dominate their workload.

Platform lead at a systems integrator

Reproduces the vendor's published benchmarks (Next.js Self-Bench, Snowflake Data-Eng-Bench, Terminal-Bench 2.1 via Mini-SWE) on internal traces before moving production traffic onto the router.

Outcome: A defensible cost-per-task number for their own workloads instead of relying on the vendor's 65.2% claim.

Engineer shipping an OpenAI-compatible agent

Points an existing OpenAI-compatible client at the single dari.dev endpoint and uses distributed tracing and the dashboard to watch which model the router selects and what it spends.

Outcome: Visibility into routing decisions and spend without adopting a new agent framework.

Use Cases

Models Under the Hood

GPT-5.6-solGLM 5.2

as of 2026-09-01

Limitations

  • dari.dev is in early access, so you are betting on a young platform rather than a settled one.
  • Its headline cost claim — 65.2% lower cost per task at the same accuracy — comes from benchmarks the vendor runs itself across three suites (47, 103 and 89 tasks respectively); reproduce it on your own traces before you plan savings into a budget.
  • Cache-aware, speculative routing pays off most on long multi-turn loops with a stable prefix; on short single-turn calls the switching logic has less to work with.

as of 2026-10-03

Verification history

We have re-verified dari.dev 9 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.

  1. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  2. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  3. — re-checked, vendor evidence unchanged
  4. — re-checked, vendor evidence unchanged
  5. — re-checked, vendor evidence unchanged
  6. — re-checked, vendor evidence unchanged

Showing the 6 most recent of 9 verification passes.

Free to cite with attribution — this page re-verifies continuously.

12-month cost

Project the real annual outlay, including the implied monthly cost when only an annual tier is published.

Annual total
Free
Over 12 months
Effective monthly
Free
Billed monthly

Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.

Plans compared

For each published dari.dev tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.

Starter

$0/mo

Ideal for

A developer trialling cache-aware routing on a single agent before committing production traffic.

What this tier adds

Starting tier / free entry point: freemium access to the routing layer, the SDKs, the hosted runtime and the no-code playground.

Pro

$49/mo

Ideal for

An engineering team routing production agent loops and watching spend per task.

What this tier adds

Adds production routing plus distributed tracing, the real-time spend dashboard, automatic retries with fallback, persistent memory and agent version control.

Enterprise

Custom

Ideal for

An organisation routing multi-provider agent traffic at scale with onboarding and support needs.

What this tier adds

Custom pricing and terms with enterprise support, onboarding and production guardrails for agents.

Hidden costs & gotchas

What the public pricing page doesn't put in bold. Captured from pricing-page footnotes, contract terms, and recurring complaints.

  • Switching models mid-loop can throw away a warm prompt cache — the router weighs this, but a badly timed switch still costs you the cache read you already paid for.
  • Routing decisions consume turns: because the router can change model and thinking level per step, a run that switches repeatedly can use more steps than a fixed-model agent.
  • The vendor's 65.2% cost-per-task figure is measured on dari's own benchmark suites, so your savings depend on how closely your workload resembles Next.js, Snowflake data-engineering or terminal tasks.

Where the pricing makes sense

The company stage and team size where dari.dev's pricing actually pencils out — and where peers do it cheaper.

Positioned as a spend-reduction layer rather than a per-seat tool, so its economics are judged against your model bill: a team routing between a $5.00/M model and a $1.40/M model (with cache reads at $0.50 and $0.14) can justify a routing layer on token savings alone. Compare against assembling LiteLLM plus an observability tool yourself.

Setup time & first value

How long it actually takes to get something useful out of dari.dev — broken out by persona, not the marketing-page minute.

For a developer already running Claude Code, Codex or Pi: minutes to a routed run via the CLI install and a base-URL swap. For an OpenAI-compatible client, the change is the same one-endpoint swap. Reaching a trustworthy cost-per-task number takes longer, because you should benchmark against your own traces rather than the vendor's.

Switching to or from dari.dev

How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.

Migrating in
  • →From a direct provider SDK: point the client at the dari.dev endpoint instead of the provider base URL, no agent rewrite.
  • →From Claude Code / Codex / Pi with a fixed model: install the CLI and run `dari claude` to put routing in front of the same agent.
  • →From a hand-rolled model-selection function: replace the selection logic with router decisions that also weigh cache warmth and upcoming turns.
Migrating out
  • ↗To a direct provider: remove the base-URL swap and pin a model in your agent config.
  • ↗To an open-source routing library: reimplement selection in-library, accepting that cache-aware mid-loop switching was the piece you were buying.
  • ↗To an observability-only tool: keep tracing but lose automatic model selection for each step.

Integrations

Claude CodeCodexPiGitHub

Resources & Guides

Tutorials & Learning

YouTube returned 6 videos for “dari.dev”, and we withheld 6: 6 did not mention dari.dev. We are showing none, because we could not prove any of them are about dari.dev.

Official links

Tools that pair well with dari.dev

Common stack mates teams adopt alongside dari.dev, with the specific reason each pairing earns its keep.

Featured Head-to-Head Comparisons

Alternatives to dari.dev

View all
Shinkai Local Ai Agents

Shinkai Local Ai Agents

Open-source local-first AI agent platform with a no-code builder, multi-network model routing, and x402 crypto micropayments.

FreemiumTry
Agentic Flow

Agentic Flow

Agentic Flow swaps AI models inside Claude Code by config file, then deploys those agents to your own AWS, GCP or Azure account.

FreemiumTry
Coworker AI

Coworker AI

Coworker AI routes enterprise tasks across 13 open and closed models on top of OM2 organizational memory.

Contact SalesTry

Frequently Asked Questions

Used dari.dev? Help shape our editorial sentiment research.