LensOp sits on top of your routers, your coding tools and your own models, and runs a continuous loop on every call: forecast, route, compact, cache, govern. No human in the loop. Cost per ticket, developer and feature comes along for free.
No signup · The demo runs on a real backlog, not screenshots
Sample of a live call stream. Without LensOp each line shows only a date and an amount. With LensOp the same line resolves to the tool or model that made the call, the ticket it belongs to and the reason it cost what it did, for example a retry storm, a nightly CI agent with no cache reuse, duplicate context across sub-agents, an idle self-hosted GPU, or work re-run after rate limiting.
LensOp works with Claude Code, Cursor, GitHub Copilot, Codex and Windsurf, with your own agents, with open weight models self-hosted on local GPU, and with LLM routers including LiteLLM, Portkey, Amazon Bedrock and Google Vertex AI.
Cloud had the same moment. Unbounded usage, optimized by hand, once in a while, until autonomous rightsizing took over and nobody went back. LensOp is that autonomous layer for AI workloads.
↳ Teams typically find their top 3 waste sources in the first week.
of production LLM failures are rate limits. Flow breaks mid task and the work gets run again.
Datadog · 2026net slowdown on complex tasks with AI assistance, while developers believed they were 20% faster.
METRof FinOps practitioners now manage AI spend, up from 63% the year before.
FinOps Foundation · 2026Claude Code, Cursor and Copilot call the providers with their own keys. That traffic never reaches your router, so anything sitting only at the gateway is blind to it. It is not a missing feature, it is where the packets go. LensOp covers both paths, the traffic you route and the traffic you don't.
Running LiteLLM, Portkey or something homegrown? Keep it. LensOp is the decision layer above it.
Any AI workload in, any execution path out. LensOp observes every call, measures it, forecasts the next one, attributes it to a work item and governs it, then acts: route, compact, cache. Continuously, without anyone opening a dashboard.
Autonomous · always on, self-improving, adaptive · governed at the gate
Every change the loop proposes is scored against a baseline built from your own workloads. Cheaper only wins if it clears the bar. If it doesn't, the call falls back and the change never ships. That gate is why this can run on autopilot instead of sitting in someone's backlog.
The loop does the work. The reporting below is what falls out of it, and it is all in the demo you can open right now.
The loop never stops. Understand intent, forecast the call, route to the cheapest path that clears the quality bar, compact context, reuse cache, and log every decision.
Quotas, priority lanes and rules act on their own. Alert, throttle or block before overspend, while hotfixes and critical agents keep headroom.
Context window blowups, retry storms, tool loops, oversized retrieval. Detected with the cause, then handled by the loop instead of written up in a postmortem.
Every prompt is joined to a ticket, a PR and a story point estimate. See the true cost of a hotfix, a feature or a docs pass, planned against actual.
Each engineer gets a daily allowance, an efficiency score per story point, and their own view of what they burned and on what.
Watch calls land in real time as the team works, then click any tick to replay the full prompt trace and the decision behind it.
Same team, same models. What changes is what you can see, cap and improve.
| Dimension | Before | After |
|---|---|---|
| Optimization cadence | ●A manual cleanup once a quarter | ✓Autonomous, 24x7, every single call |
| Routing | ●Model chosen once, hardcoded, never revisited | ✓Intent and stakes routed to the cheapest path that clears quality |
| Quality | ●Nobody knows if a change made output worse | ✓Every change scored against a baseline before it ships |
| Attribution | ●One provider invoice, no owner | ✓Every call mapped to a ticket, developer and feature |
| Unit economics | ●Nobody knows what a shipped feature cost | ✓Cost per work item and per story point, planned against actual |
| Coverage | ●Managed tools and self-hosted models measured separately, or not at all | ✓One loop across routed traffic, coding tools and your own GPUs |
| Budget control | ●Overspend discovered at month end | ✓Team and category quotas with alert, throttle or block rules |
Point your router at the LensOp proxy. It continuously syncs tickets, new code, PRs and CI/CD signals into a live context graph, so attribution happens without a single tag in your code.
# 30 second setup docker run -p 8787:8787 lensop/proxy export OPENAI_BASE_URL=http://localhost:8787/v1 # connect Jira and GitHub in the console, done
Prefer full control over attribution? Wrap your calls and pass intent, ticket and stakes yourself.
import { lensop } from "@lensop/sdk"; const res = await lensop.chat({ intent: "code-generation", ticket: "OC-1421", stakes: "high", messages, });
Claude Code, Cursor and Copilot don't need either. They never touch a proxy, so they connect read only from the admin side. Nothing to install on a developer's machine, nothing to change in a workflow. Self-hosted models connect through your existing metrics endpoint.
Open the demo to watch the loop work a real backlog, or book a short call and we will map it to your own stack. Design partners get the first Workload Audit free, and the report is yours either way.
Good fit: 25+ developers on AI tools, two or more tools, or your own models in production