Does your provider break your tool calls?

Make your endpoint the one agents can trust.

You serve the same weights as everyone else. What sets your endpoint apart is whether its tool calls parse.

.lambda defines each model's own call format once, and uses it both to constrain generation and to parse the result. Every tool call your endpoint returns is valid.

The .txt mascot, a little beige computer with its eyes closed in a smile, standing beside a server whose lights are all green.

Reliability is visible, even when requests return 200.

Every tool call looks fine to your endpoint: the request returned 200. The customer sees the failure: the model answered in text where a call was due, wrote malformed JSON, named a tool it wasn't offered, or passed arguments the schema rejects.

Tool calling is hard to get right. Providers serving the same weights end up with very different error rates.

Tool-call error rates of the providers serving four models on OpenRouter, 3 to 9 November 2026, from the lowest to the highest: up to 16.0% for MiniMax M3.1 Flash across 12 providers, 12.0% for DeepSeek V4.1 Flash 1017, 5.9% for GLM 5.3 Flash and 4.0% for GLM 5.3.
Same weights. Different reliability. Customers can see the difference. For each model, the bar runs from the provider with the lowest tool-call error rate to the one with the highest, over the seven days to 9 November 2026. Look up your endpoints in the Tool-call index

OpenRouter's published tool-call error rate per provider, 3 to 9 November 2026, for providers with at least 1,000 tool calls a day, from the .txt Tool-call index (providers.dottxt.ai).

  • 1.4M

    Tool calls a day come back broken on OpenRouter’s open-weight models: 1 in 108.

  • 30×

    The worst provider's error rate against the best's, median across 48 models.

    Same weights, different endpoints.

  • 0.2% → 5%

    A typical model's best and worst provider.

    For these, the provider matters more than the model.

From the .txt Tool-call index, on OpenRouter's published data, 3 to 9 November 2026. Broken calls: the 474 provider-model pairs with 1,000 or more tool calls a day. Gaps: medians over the 48 models served by at least two providers with 1,000 or more tool calls a day.

Better where it steps in. Unchanged everywhere else.

We tested .lambda on Reflection's Beam 1.0, a 501B open-weight model, across the BFCL v3 benchmark.

On about a third of the attempts, .lambda had to step in and correct the model's output. Those attempts got better: the share of tasks solved went from 66.5% to 69.7%. On the other two thirds, the model had already written a valid call and .lambda left it alone. The score there was 75.2% with and without it.

  • 151 → 0

    Schema violations when the model completed, without and with .lambda.

  • +3.2

    Points of success where .lambda corrected the output: 66.5% to 69.7%.

    2,809 attempts.

  • 75.2% → 75.2%

    Tasks solved where the model already wrote a valid call, without and with .lambda.

    6,069 attempts. Nothing changed.

BFCL v3 with Reflection's Beam 1.0, run on the model's release day.

No slowdown, even at 228 tokens a second.

Constrained generation has to decide which tokens are allowed before each one is generated. .lambda does that while the GPU is still busy with the forward pass, so the answer is ready before it's needed.

We timed .lambda and the library most engines use by default for this, on the same public benchmark data, with GLM 5.3 at batch 32. At the slowest provider's speed, the default library adds 3.4%. At the fastest, it adds 50.6%. .lambda adds nothing at any of them.

The default library’s cost also depends on the model. Per token, at p90, it takes 268 µs on GLM-5.3 and 160 µs on Kimi-K2.6, so every new model needs benchmarking again. .lambda takes 25 and 29 µs.

Bars of how much slower generation gets with constrained decoding, at the slowest (27 tokens/s), median (81) and fastest (228) provider speeds. The library engines use by default: +3.4%, +14.6% and +50.6%. .lambda: +0% at all three.

GLM 5.3, batch 32, public benchmark data. We timed each library on its own: how long it takes to work out the allowed tokens, with anything beyond the GPU's time per token counted as slowdown.

Per tokenDefault library.lambda
GLM-5.3, p5041 µs15 µs
GLM-5.3, p90268 µs25 µs
GLM-5.3, p99430 µs45 µs
Kimi-K2.6, p5042 µs16 µs
Kimi-K2.6, p90160 µs29 µs
Kimi-K2.6, p99235 µs51 µs

Time per token to compute the next mask and accept the token, on the positions both libraries accepted: 787,107 on GLM-5.3 and 771,199 on Kimi-K2.6.

Supported on launch day, not a month later.

Developers judge a model, and the providers serving it, in its first week. A new open-weight model with tool calling ships about eight times a month, and engines can have tool-calling bugs open for months after launch.

We write the model's format definition before launch, from its documentation, chat template and raw generations, and qualify it on your engine before traffic.

Open upstream tool-calling bugs for the median model over its first six months on OpenRouter: 1 at launch, 2.5 after launch week, rising to 7 at six months.

Median open tool-calling bugs in vLLM, SGLang and TensorRT-LLM for the 10 open-weight models with tool calling that had the most tool calls on OpenRouter from 3 to 9 November 2026, among those listed at least 180 days by 9 November.

It runs in your stack, and you stay in control.

.lambda runs inside your cluster, alongside vLLM, SGLang, TensorRT-LLM or ONNX Runtime GenAI. Customer requests never leave it, and we collect no telemetry.

.lambda takes the default library's place behind the same interface. We maintain the format definitions, fix the bugs and add new models as they ship.

Prove it on your worst endpoint.

Pick the model and engine where your tool calls fail most. With the scope agreed, an engineer assigned and the workload ready, the evaluation takes under a week.

Integrating the library has taken clients under two hours.

What the pilot includes

  • 01You bring

    An agreed scope and ready workload

    One model and serving configuration, representative requests including known failures, required customer features and an assigned engineer.

  • 02We run

    The same requests on both engines

    One engineer on each side integrates the library, reproduces the failures and compares correctness, task quality, performance under load and operational coverage.

  • 03You receive

    A decision-ready qualification report

    How each engine did on your requests, what we don't support yet, and what a rollout would take.

What your engineering leads will ask.

Your current setup keeps working, and it stays as your fallback. The real question is who fixes it when a new model's format breaks the parser, and how fast. With open source, that's your team waiting on upstream. With .lambda, it's us.

No. Outlines is our open-source library, and it stays open source. .lambda is a commercial product built on a separate engine. It knows each model's tool-call format, parses calls as they stream, supports new models on launch day, and its time per token doesn't depend on the model. We maintain and support it in production.

Check how you're counting. Most monitoring catches bad JSON but misses the model answering in plain text when it should have called a tool. And a low rate today may not survive a new format or tokenizer.

Not necessarily. .lambda makes sure the call is well-formed. It doesn't make the model smarter. It also never rules out an answer the model could validly have given, so it doesn't make good answers worse: on BFCL with Beam 1.0, attempts where the model already wrote a valid call scored 75.2% with .lambda and 75.2% without. We measure task success separately so you can see both.

Not in our tests: timed on GLM 5.3 at 228 tokens a second, .lambda works out the allowed tokens before the GPU needs them. We timed the library on its own, so test it under your own batching during the pilot, because averages hide slow tails.

Usually just sample outputs from the model. We don't need the weights. Before release, we test it on your engine with your engineers.

A platform fee, tiered by traffic or by dedicated deployment. It includes bug and performance fixes, new model support and standard support.

Run a pilot. 

Tell us which model and engine you serve and where its tool calls fail.

Talk to an engineer E