Lightyear is Postman’s inference execution runtime for agents. It runs inside Fabric Gateway, between agents and model providers, handling deterministic orchestration so fewer steps require expensive inference calls. Lightyear, like Fabric, is centrally managed across all of your organization’s agent traffic; users keep their existing tools and workflows without the need for endpoint installation, configuration, or a workflow-by-workflow rollout.

We measured the effect in industry-standard agent benchmarks: traffic routed through Lightyear reached task solutions 40% cheaper and 31% faster, with a ~5% improvement in task success rate compared with the same harnesses running directly against the provider.

Centralized deployment for your existing agents

Because Lightyear runs inside Fabric Gateway between the agents and model providers, deployment and savings become a simple routing decision. This gives organizations a way to improve the economics of agent work without moving users to a different tool, standardizing on one agent, or choosing cheaper models.

Agents continue to execute tools under their existing permissions. Models continue to make the decisions that require reasoning. Lightyear handles deterministic orchestration between them, reducing unnecessary inference work.

IT configures routing once through Fabric Gateway and Lightyear, while agents keep their tools and permissions and models stay with existing providers.

IT configures routing through Fabric Gateway and manages Lightyear across the organization’s agent traffic, rather than requiring each user or team to set it up separately. Users keep their existing tools and workflows. That’s it – developers don’t need to choose a particular model, change their setup, or take any action whatsoever.

That makes cost optimization an infrastructure decision. Instead of relying on every user to change their behavior, IT can apply it centrally to the traffic the organization already manages.

Why agent work gets expensive

Agents do more than generate answers. They search documents, query systems, retrieve records, call APIs, and act on the results. A long task can repeat that cycle dozens of times, whether the agent is writing code, investigating a customer issue, or running a business process.

Three pieces make this possible:

  • The client executes tools, manages permissions, and allows for the model to interact with an environment.
  • The model reasons about the task and decides what to do.
  • The API carries requests and results between them.

The APIs get the least attention, yet they shape the economics dramatically.

OpenAI's Responses API, for example, holds a stateful conversation on the server: a client names the previous response and sends only the new turn, where a stateless API makes the client resend the full history on every call. Fewer bytes move on every turn, and the server keeps the history as a cached checkpoint it manages directly. From March 2025 through November 2026, the Responses API put a massively-underappreciated rift between OpenAI and competitors who were stateless; much more than the API contract and model ergonomics, it afforded a much faster time-to-first-token, much better uptime, and a much more economically viable edge serving their customers.

Where history is cached determines what can be done with it. A cache at the provider's API layer stores the raw wire payload verbatim - but in a stateless protocol, a gateway in front of the API can intercept each turn from the client, compact and restructure the exchange, and keep the provider's prefix cache warm in a shape built for the model rather than an internet-facing protocol.

That deterministic compute between client and model is where we built Lightyear, running inline inside Postman Fabric gateway. The client still executes every tool, but the orchestration happens at wire speed, the model only wakes up when judgment is required, and the bytes that reach the cache are the ones that are most useful to achieve success on the task at hand.

Where the cost of an agent loop goes

In a conventional agent loop, every tool call is an inference pass. The model emits a call, the client executes it, and the result returns in a new request that carries the full conversation. Prompt caching discounts that history but doesn't remove it: each pass still reads every prior token, and each intermediate result remains in context for the rest of the session.

Cost therefore scales with the number of passes, and many passes carry no reasoning. Much of a long-horizon task is orchestration: reading the next file, re-running a test suite, applying a change the model has already decided on, or any of dozens of potential actions.

Lightyear moves deterministic orchestration into Fabric Gateway, reducing model inference calls while agents continue to execute tools.

Lightyear moves that orchestration out of inference and into a deterministic runtime where they belong. Tools continue to execute on the client under the client's existing permission model, and the model continues to reason and determine what happens next where it cannot be predetermined. From both the perspective of the client and the model, nothing changes; neither has to change the way they operate to benefit.

Consider one DeepSWE task: adding support for Go's embed directives to yaegi, an open-source Go interpreter, with Claude Opus 5.5 at xhigh reasoning effort in Claude Code.

DirectThrough LightyearChange
Inference passes7612−84%
Input tokens, including cached11.9M1.0M−92%
Output tokens111K59K−46%
Wall-clock time26 min13 min−50%
Cost$6.48$1.94−70%

Across our panel of industry-standard, long-horizon benchmarks – DeepSWE, TerminalBench 4.0, and others – Lightyear reached passing solutions 31% faster, 40% cheaper, and with a +4pp higher task success rate than running the same harnesses directly against the provider.

The results for Claude Opus 5.5 in Claude Code 2.1.319, across all reasoning levels:

Reasoning effortCost to successTime to success
Low−20%−30%
Medium−33%−36%
High−38%−31%
Xhigh−53%−41%
Max−47%−27%

And for GPT-6.1-Sol in Codex v0.168.0:

Reasoning effortCost to SuccessTime to success
Low−12.0%−15.9%
Medium−19.2%−23.2%
High−31.4%−32.8%
Xhigh−24.0%−17.9%
Max−34.7%−29.3%

These numbers come from a first version aimed at one pathology: the deterministic work that agents were routing through the most expensive component in the system. That pathology was the loudest.

It is not the only one. Every piece of our ever-expanding world of agent-everywhereness still carries waste that nobody owns, because nobody sits where it can be seen: inefficiencies in storage that grow without being pruned, bytes being sent and discarded on both ends – or worse, bytes that every participant pays to re-process. Each of those is an opportunity of the same shape as this one, and each is reachable from the same position.

Postman has lived in this space since its first day. The space of the API, between a client and the compute that serves it, deeply understanding what crosses it, makes it legible, efficient. This has been the whole of our work. While agents did not create this space, they’ve tied its mechanisms much more tangibly to expense, and made it one of the largest gaps in agentic systems to leave unattended.

Try Lightyear

Lightyear is available today inside Postman Fabric Gateway.

Deploy Lightyear in Fabric Gateway or read the Lightyear documentation to route Claude Code, Codex, and other agents through it.

Bring every AI interaction under control

Connect your first model, MCP server or internal API and apply consistent governance from one gateway.