There are three ways data reaches Jents, and they're rungs on a ladder, not competing options. Import the bill (paste an admin key) gives you exact dollars, anonymously. Capture telemetry (an Activation key in the tool's settings) gives you who did what, but the money is the seat. Connect your own gateway (if you already run LiteLLM) gives you exact dollars and the person, on every call. This is the full reference: source by source, what each one pulls, what it creates in your Inventory, and what it honestly can't tell you.
The staircase
1. Import the bill. Paste one admin key from the account that pays for the AI. In minutes you see every project, every key, every model, and the exact dollars, across the whole org, with nothing to install. What a bill can't tell you is who: an API key isn't a person, and a statement is a daily total, not a call.
2. Capture telemetry. Paste an Activation key into the tool's own settings (Claude Code, OpenAI Codex, Claude Cowork), or drop Jents Capture into your own app. Now you have per-person usage and tokens, real names and real teams, arriving within a minute. What telemetry can't tell you is the dollar per call: these tools are flat-fee, so the money is the subscription, not the token.
3. Connect your own gateway. If you already run LiteLLM, point its logs at Jents. Every call then carries exact cost and the person who made it — your gateway priced it, Jents only reads it. What this can't cover is anything that doesn't already go through your gateway, and it's only a rung if you run one in the first place.
⚠️ Rung 3 is your gateway, not ours. Pointing your own code at a Jents-hosted gateway used to be the answer here, and it isn't on offer right now — nothing in the product today puts Jents in the live path between your code and your provider. Bring-your-own-gateway is the live version of the same idea, and it's the opposite arrangement: the traffic stays on your LiteLLM, your provider keys never leave your environment, and Jents reads the prices your gateway already computed.
Each rung adds what the one below it can't see. Most teams climb the first two: import the bill to map everything, then turn on telemetry to put names on it. The third is for teams that already run a gateway.
Every source, side by side
| Source (what you paste) | What it pulls | What it creates in Jents | What it can't give you |
|---|---|---|---|
| Anthropic · Admin key | Workspaces, API keys, org members, usage + cost per workspace / model / day | One agent per API key, named workspace · key (assign it an owner and it enters your Inventory) · People for each member · Claude seats · usage rows carrying exact cost | Per-person usage. Anthropic attributes to keys, not humans, and one key can be shared by a whole team |
| OpenAI · Admin key | Projects, API keys, org members, usage + cost per project / model / day | One agent per API key, named project · key · People · ChatGPT Team seats · exact cost | Per-person usage · per-call detail |
| Claude Code · OpenAI Codex · Claude Cowork · Activation key | Every call: the person, tokens, model, session | Per-person usage · a seat for anyone Jents has seen using the tool | Cost per call, it reads $0 on purpose (see below) |
| Your own app · Jents Capture (Python / Node) | Every LLM call your code makes: model, tokens, and the team you set at startup | Its own record · usage with estimated cost | The person — the snippet sets a team, not a user · and the exact price, which is derived from token counts rather than read off your bill |
| Your own gateway · LiteLLM's log webhook | Every call your gateway priced | Exact cost + the person, per call, landing straight in your spend | Anything that doesn't go through your gateway |
Not available today: Cursor and GitHub Copilot seat imports, the AWS Bedrock / Google Vertex AI / Azure OpenAI cloud imports, OpenRouter, and routing your traffic through Jents. There is no way to start any of them right now, so don't plan around them.
Which one do I need?
Pick by the question you're actually trying to answer:
- "What are we spending on AI?" → import the bill. One Admin key per provider, a few minutes, exact numbers, org-wide.
- "Who uses this, and who's paying for a seat they never open?" → import the roster and turn on telemetry. It takes both, and the same Admin key brings the roster. See the next section, this is where the money is.
- "Is this agent worth what it costs?" → give it a cost you can trust, then a value. The cost must come from something that priced the call: an API key of its own on a connected account (exact, daily), or your own gateway (exact, per call). The value comes from a data source you connect on the record. Jents can't price a call it never saw — so on a flat-fee tool the cost is the seat, and the fair comparison is that seat against what the usage would have cost pay-as-you-go.
- "All of it." → in that order. Bill first (broadest, fastest), telemetry second (it's what puts names on the money), your own gateway last and only if you already run one.
The gap between two lists is your wasted money
This is the most actionable thing on the page.
Seats reach Jents three ways, and your seat count is the union of all three, with each person counted exactly once:
- Auto-detected from telemetry — anyone Jents has seen using the tool.
- Imported from the vendor — the authoritative paid roster. Today that means the Anthropic Admin key (Claude seats) and the OpenAI Admin key (ChatGPT Team seats).
- Manually assigned to a CLI record.
Telemetry only ever shows the people who use the tool. The vendor roster shows everyone you pay for. The difference between those two lists is the money you're burning.
And here's the trap: an idle paid seat generates no telemetry. Silence is exactly what it looks like. So without the vendor roster, the wasted seats are precisely the ones you can't see, and Jents would show you a tidy list of active people with no hint that you're buying twice as many licences. That's why the Admin key is worth pasting even when telemetry is already flowing — it's the same two-minute paste that brings in your bill. The result shows up as reclaimable on Observability → Subscriptions.
⚠️ For Cursor and GitHub Copilot, neither list exists today: they report no telemetry, and their roster imports are switched off. Those seats simply can't be counted in Jents right now.
What happens after you connect it
After a bill import (Connections → Admin key). Jents reads the account read-only. Nothing lands in your Inventory straight away: each imported key waits under Needs your attention, where you assign an owner and confirm it, or dismiss the noise. Members become People in your directory, with no login invite sent, capped at 200 so a large org can't flood your team list — and the same key adds them to that vendor's seat roster. Cost then re-syncs hourly, so you never re-import by hand, and re-importing never creates duplicates.
After turning on telemetry (Add AI source → AI your team uses). Usage starts arriving within a minute or two, attributed to real people and teams, and anyone Jents sees is added to that tool's seat roster automatically.
After connecting your own gateway (Settings → Gateways). Nothing has to be registered first: every call your gateway prices arrives as spend and lands in your totals from the first batch. Naming a record later gives that money an owner and a team; it doesn't change the number.
Honest limits, so nothing surprises you
- $0 per call on a telemetry tool is correct, not a bug. Claude Code, Codex and Cowork are billed per seat. The money is the subscription, which Jents already counts once, so pricing the tokens on top would bill you twice. Jents keeps the token number as value (what that usage would have cost if it were metered) so you can still weigh it against the seat. Cowork even reports its own exact figure, and it's treated the same way.
- The bill is anonymous by design. Projects, keys and models, not people. If you need "who", it comes from telemetry or from your own gateway.
- Per-key dollars are apportioned; the org total is exact. OpenAI and Anthropic both report tokens per API key but dollars only per project / workspace — Anthropic's own FAQ says to use tokens as the per-key proxy. So Jents keeps each container's billed total exactly as invoiced and decides only how it splits inside, giving each key the share its own usage earned. The number finance reconciles is untouched; the attribution beneath it is ours.
- Anthropic runs two separate member lists. The API console org (console.anthropic.com) is what the Admin key reads. Claude Team / Enterprise seats (claude.ai) are a different list. At some companies the two match, at plenty of others they don't. Check the imported roster against who you know holds a Claude seat before you treat it as your paid list.
- Some sources have no way in today. Cursor and GitHub Copilot publish no telemetry and their roster imports are switched off, so Jents sees nothing at all for them. The same goes for AWS Bedrock, Google Vertex AI, Azure OpenAI and OpenRouter: there is no cloud or aggregator account import right now, so that spend has no route in either.
- Only LiteLLM works as your own gateway. Portkey, Cloudflare AI Gateway and Helicone aren't supported — we checked each against its own docs and couldn't write setup instructions that actually work. Talk to us if you're on one.
- A roster with no activity signal can't judge idleness. ChatGPT Team is the clearest case: it gives you the paid list and nothing else, so the reclaimable number stays blank until an activity source exists, rather than declaring your whole subscription wasted.
In one line: the bill tells you what you spend, telemetry tells you who's using it, and your own gateway tells you both, on the same call. Connect the bill first, turn on telemetry to put names on the money, then connect your gateway if you already run one.
Related: Connect an account · Track the AI tools your team uses · Connect your own gateway (BYOG).