Originally published on the Postman blog.
If you run Claude Code or Codex on long tasks, you've watched it happen. The agent reads a file, re-runs the test suite, then applies the edit it already decided on. Each of those steps is another full inference pass, and each pass re-reads the whole conversation. Much of that work involves no reasoning at all, yet you pay model prices for it. This post covers where that cost comes from and what we built to take it out of the loop.
Lightyear is Postman's inference execution runtime for agents. It runs inside Fabric Gateway, between agents and model providers. It handles deterministic orchestration, so fewer steps need expensive inference calls.
We measured the effect on industry-standard agent benchmarks. Traffic routed through Lightyear reached task solutions 40% cheaper and 31% faster than the same harnesses run directly against the provider. These are benchmark results, not a guarantee for every workload.
Centralized deployment for your existing agents
Lightyear runs inside Fabric Gateway, between the agents and the model providers. That makes deployment a routing decision. Organizations can improve the economics of agent work without:
- moving users to a different tool
- standardizing on one agent
- choosing cheaper models
Tools still run on the client under its existing permissions. The model still makes the decisions that need reasoning. Lightyear handles the deterministic orchestration between them.
IT configures routing through Fabric Gateway and manages Lightyear across the organization's agent traffic. Each team doesn't have to set it up separately. For developers, that's it: there's no model to choose, no setup to change and nothing else to do.
Cost optimization becomes an infrastructure decision, applied centrally to traffic the organization already manages, rather than something that depends on every user changing their habits.
Why agent work gets expensive
Agents do more than generate answers. They search, query, retrieve, call APIs and act on the results. A long task can repeat that cycle dozens of times.
Three pieces make this possible:
- The client runs tools, manages permissions and lets the model interact with an environment.
- The model reasons about the task and decides what to do.
- The API carries requests and results between them.
The API gets the least attention, yet it shapes the economics dramatically.
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 runs it, and the result comes back in a new request that carries the full conversation. Conceptually:
loop:
response = model(full_history) # inference pass
if response.is_tool_call:
result = client.run(response) # read file, run tests, apply edit...
full_history += [response, result]
else:
break
Prompt caching discounts that history but doesn't remove it: each pass still reads every prior token.
So cost 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, or applying a change the model has already decided on.
Lightyear moves that orchestration out of inference and into a deterministic runtime. Tools continue to run on the client under the client's existing permission model. Wherever the next step can't be predetermined, the model still reasons and decides it. Neither the client nor the model has to change how it works.
Across our panel of long-horizon benchmarks, that change is where the 40% cost reduction and 31% speedup came from.
Try Lightyear
Lightyear is available today inside Postman Fabric Gateway. You can deploy it in Fabric Gateway, or follow the Lightyear docs to route Claude Code, Codex and other agents through it.
👉 Read the full post on the Fabric Gateway blog
Running long agent sessions? Tell us in the comments which steps in your loop feel like pure orchestration. We'll answer questions about how Lightyear fits between your agents and your providers.
Top comments (0)