Does your provider break your tool calls?

Tool calls that parse for every model, from day one.

Every model speaks its own tool-calling language. .lambda describes each one once, enforces it while the model writes, and reads the call back when it stops. No parser per model, no retries, no call that fails to parse.

For inference providers, model labs, and on-device teams.

A CD labelled NEW MODEL sliding out of its case, in front of a server, a desktop, a laptop and a phone, each showing the same tick.

Every model writes the same call differently.

Each writes the call in its own format, so a parser for one is useless for the next, and a new model breaks them all.

One request, step by step.

  1. 01DefineThe request declares the tool.The schema on the right. wind_speed takes two numbers: a latitude and a longitude.
  2. 02GenerateThe model writes the call..lambda holds the delimiters to the model’s native format and the argument values to the schema.
  3. 03ParseRead the call back..lambda extracts the tool name and the arguments. Your engine returns them in its usual response format.
wind_speed · tool schema
{
  "name": "wind_speed",
  "parameters": {
    "type": "object",
    "properties": {
      "latitude": { "type": "number" },
      "longitude": { "type": "number" }
    },
    "required": ["latitude", "longitude"],
    "additionalProperties": false
  }
}
GLM-5.3
<tool_call>wind_speed
  <arg_key>latitude</arg_key>
  <arg_value>52.52</arg_value>
  <arg_key>longitude</arg_key>
  <arg_value>13.405</arg_value>
</tool_call>
Kimi-K3.1 Pro
<|open|>tools<|sep|>
  <|open|>call tool="wind_speed" index="1"<|sep|>
    <|open|>argument key="latitude" type="number"<|sep|>
    52.52
    <|close|>argument<|sep|>
    <|open|>argument key="longitude" type="number"<|sep|>
    13.405
    <|close|>argument<|sep|>
  <|close|>call<|sep|>
<|close|>tools<|sep|>
DeepSeek-V4.1
<|DSML| calls>
  <|DSML| invoke name="wind_speed">
    <|DSML| parameter name="latitude" string="false">52.52</|DSML| parameter>
    <|DSML| parameter name="longitude" string="false">13.405</|DSML| parameter>
  </|DSML| invoke>
</|DSML| calls>
What .lambda returns
{
  "name": "wind_speed",
  "arguments": {
    "latitude": 52.52,
    "longitude": 13.405
  }
}
One call, three formats. The same call in the formats of GLM-5.3, Kimi-K3.1 Pro, and DeepSeek-V4.1. Indentation and line breaks are for display.

Enforced as the model writes.

.lambda knows the native format of every model it supports. Your engine hands it the request’s tools; the model writes the call its own way, and what comes out is valid, parsed, and the same whatever the model wrote it. When a new model ships, we add its format. Nothing changes in your engine.

Beam writing a tool call. Beam's chat template

Every model in its own format.

We add each model’s native format as it ships. All you have to do is update .lambda and your users get valid tool calls. Ask us which models are supported today.

Three sheets, each a model's tool call written with its own marks: square brackets, bars, angle brackets. An arrow to .lambda's jewel case, then an arrow to one sheet in one format: curly braces around keys and values, ticked.

Validity is guaranteed. Success is measured.

A valid call is guaranteed. Whether it is the right call is measured. On the Berkeley Function Calling Leaderboard, the same models pick the right tool and arguments more often with .lambda, even with the baseline allowed two retries.

  • BFCL live_multiple

    The baseline runs the same models unconstrained, with up to two retries when a call fails to decode or to match its schema. A wrong tool or a wrong value counts as a failure in both arms. The models are small open-weight Qwen3 models: the evaluation measures what constraining changes for one model, not which model is best.

ModelWithout .lambdaWith .lambdaGain
Qwen3-0.6B46.9%55.1%+8.2 pts
Qwen3-1.7B65.7%70.1%+4.4 pts
Qwen3-4B-Instruct-250777.2%79.2%+2.0 pts

.txt’s tool-calling evaluation, 30 April 2026. Baseline success is counted after its retries; schema corrections were applied to both arms.

  • At 501 billion parameters

    On Reflection’s Beam 1.0, run on the model’s release day across BFCL v3 with no retries for the baseline, schema violations went from 151 to 0. Where .lambda stepped in, success rose 3.2 points; overall, 1.0. See the full results.

Inside the generation loop. Behind your API.

Nothing changes for your users. .lambda sits in your engine’s decoding loop and hands back a parsed call. The integration is minimal: a few hours of work at most.

A request, its prompt and its tools, goes into your engine. The prompt goes to the model; the tools go to .lambda, a small box docked on the model. The response comes out of .lambda: wind_speed, with latitude 52.52 and longitude 13.405.
  • Inputs

    The model’s format definition, its tokenizer, the tools offered in the request, and their argument schemas.

  • During decoding

    The constraints decide which continuations are allowed. The model chooses among them.

  • Output

    The tool name and arguments, mapped into your engine’s response format.

  • Engines

    vLLM · SGLang · TensorRT-LLM · ONNX Runtime GenAI.

  • What we ship

    A Python wheel for vLLM, SGLang and TensorRT-LLM, and a binary library for ONNX Runtime GenAI and other native runtimes. Each comes with a patch for the engine.

What your engineers will ask.

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.

Everything our .json engine supports, which is more than anyone else’s. The .json product page lists the features.

Most likely we already support it. If not, we’re happy to add it as part of the initial deployment.

Yes. .lambda brings its own parser, so there is no engine parser to patch and nothing to keep in step across engines.

Yes. .lambda parses tool calls as the model generates them.

No. Open-source libraries slow down or speed up depending on the model’s tokenizer or tool call format. .lambda has the same speed guarantees whatever the model.

Yes, and that’s where .lambda’s speed shows most. Checking a run of draft tokens needs a mask for each of them in the same step, so a slow mask adds up fast.

Single and parallel tool calls, parallel where the model’s format allows it, and both the auto and required modes.

Yes. The model thinks freely, and constraints apply once the thinking block ends.

Yes. .lambda guarantees the structure and the schema. The model still chooses the tool and the values, and it can choose wrong. Nevertheless, constraining can only improve quality.

One product, three ways to use it.

Each page covers what you need in place, how .lambda runs there, and how we evaluate it with you.