Getting started with Jents

A plain-language guide for new customers — from signing up to seeing every dollar your AI spends.

What Jents does (30 seconds)

Your company runs AI everywhere — agents, apps, coding tools, chatbots. Jents gives you one place to:

• See every dollar and token your AI spends — by agent, team, person, vendor, and tool.
• Control it — budgets and alerts, so a spike reaches you long before the invoice does.
• Manage the agents themselves — one inventory of everything the company runs, with a real owner on each.

You keep your own provider accounts and your own keys — Jents never charges you for tokens, and never sits in the path of a call. It reads what you already pay for and makes it visible.

The one idea to understand first: how usage gets into Jents

Jents can only show you what it can see. AI usage reaches Jents in three ways, and most companies use a mix:

Rule of thumb: import the bill first — it's the broadest and the fastest. Then turn on telemetry wherever you need to know who. Seats aren't a third setup: they fall out of the first two.

You don't have to do it all at once — start with whichever matches what you run today.

Already run your own LiteLLM gateway? Point its logs at Jents (Settings → Gateways) and every call arrives with exact cost and the person who made it — see Connect your own gateway (BYOG). It stays your gateway: your traffic and your provider keys never leave your environment, and nothing re-routes through us.

Step 1 — Create your workspace

1. Go to app.jents.io and sign up with your work email (or Google).
2. Name your workspace (usually your company name). That's it — you're in.

Your workspace is fully private to your company. (If teammates join later, they sign in with the same workspace.)

Step 2 — Get your AI usage flowing in

Pick the path(s) that match what you run. You can add more later.

2a. Import the bill — the fastest way to see everything

Every AI call your company makes eventually bills to a provider account, and that account already records it by project, key, and model. Connecting it is like linking a bank statement: you don't type in each purchase, the statement already has them all.

1. Open Connections and pick your provider — OpenAI or Anthropic.
2. Paste an Admin key. It's encrypted at rest and never shown again.
3. Jents reads the account read-only. Nothing lands in your Inventory yet: each API key becomes an agent and waits under Needs your attention, where you give it an owner and confirm it, or dismiss the noise.
4. Cost then refreshes hourly, so you never re-import by hand — and re-importing never creates duplicates.
5. The same key also brings that vendor's paid seat roster — Claude seats from Anthropic, ChatGPT Team seats from OpenAI. That's the half that shows you a seat nobody opens (Step 7).

Those two are the whole list. There is no AWS Bedrock, Google Vertex AI, Azure OpenAI or OpenRouter import right now — no card, no key to paste. If that's where your AI bills, that spend has no way into Jents today.

A bill is anonymous by design — projects, keys and models, not people. For who, you need telemetry.

2b. Capture telemetry — for the tools your team uses, and your own code

For Claude Code, OpenAI Codex and Claude Cowork, and for anything you wrote that calls an LLM.

Click Add AI source → AI your team uses, and generate an Activation key (copy it — shown once). Then:

For Claude Code (it reports its own usage — set these in ~/.claude/settings.json, or roll out org-wide via managed settings):

{
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "CLAUDE_CODE_ENHANCED_TELEMETRY_BETA": "1",
    "OTEL_TRACES_EXPORTER": "otlp",
    "OTEL_METRICS_EXPORTER": "none",
    "OTEL_LOGS_EXPORTER": "none",
    "OTEL_EXPORTER_OTLP_PROTOCOL": "http/protobuf",
    "OTEL_EXPORTER_OTLP_ENDPOINT": "https://app.jents.io/api/capture",
    "OTEL_EXPORTER_OTLP_HEADERS": "Authorization=Bearer <your ingest key>",
    "OTEL_RESOURCE_ATTRIBUTES": "jents.team=<your team>"
  }
}

Then fully quit and reopen Claude Code, use it, and the usage appears in Observability within a minute or two.

For your own apps (one-time, by your developer) — install Jents Capture:

pip install jents

import jents
jents.init(api_key="<your ingest key>", endpoint="https://app.jents.io/api/capture", team="<your team>")   # then use OpenAI/Anthropic as usual — calls are captured automatically

Node — same idea:

npm install @jents/capture

const { init } = require("@jents/capture");
init({ apiKey: "<your ingest key>", endpoint: "https://app.jents.io/api/capture", team: "<your team>" });

Want your own app to have its own record from the start? Add AI source → AI you build or run → "No, or it uses its own API key" gives you the same Activation key with the snippet already filled in.

Cost for captured usage is estimated from token counts. For flat-fee tools like Claude Code the tokens show as value / utilization — the real cost is the seat (Step 7). Claude Cowork is the exception: it reports its own exact cost.

2c. Seats — the flat-fee tools you can't meter

A tool you pay a flat per-person fee for doesn't expose a per-call cost, so Jents tracks the seat instead. There is no third setup here — seats arrive from the two steps you just did:

• From telemetry (2b) — anyone Jents has seen using Claude Code, Claude Cowork or OpenAI Codex becomes a seat holder for that tool.
• From the Admin key (2a) — the OpenAI key brings your paid ChatGPT Team roster, the Anthropic key brings your paid Claude roster.

The gap between those two lists — people you pay for who never appear in the usage — is the money you can reclaim. Step 7 is where you read it.

⚠️ Cursor and GitHub Copilot will not appear at all. Neither publishes telemetry, and their seat imports are switched off right now, so Jents has nothing to read for them and nothing will show up however long you wait. If those are your tools, count those seats outside Jents for now.

Step 3 — Add your team (People)

So spend can be attributed to people and departments.

Most of your team arrives on its own from Step 2 — anyone Jents sees in telemetry, and everyone on a paid seat roster pulled from an Admin key, becomes a person automatically. So start by opening People and checking who is already there.

Then:

1. Assign each person a department (this is what makes the by-department breakdown work).
2. Anyone missing? Invite them from the People page, or import a vendor's member list as a CSV from that tool's page under Observability → Subscriptions.

Now the Observability dashboard can break spend down by person and by department (for anyone whose AI calls carry a user id — the telemetry tags above set it).

Want your whole company pulled in from Google Workspace, Microsoft 365 or Okta, kept current automatically? We set that up with your IT during onboarding rather than asking you to wire it yourself — email us at niv@jents.io and we'll arrange it.

Step 4 — Put your agents on the map (Inventory)

Your Inventory is every AI the company runs, in one list — what it costs, who owns it, which team it belongs to.

• Already there: everything you confirmed from a bill import in Step 2a, with its real cost.
• Anything else: add it with Add AI source, then give it an owner and a team.
• Click any record for its cost, models, and value over time.

Tip: an owner and a team on every record is what makes the rest of Jents sharp — it's how cost rolls up to a person and a budget instead of to an anonymous key.

Step 5 — Watch the money (Observability)

Observability is the dashboard. Once usage is flowing, you'll see:

• Total spend + trend, with a token-usage view.
• Cost by — switch between Agent / Team / Vendor / Department / Person.
• Usage by source — where each dollar came from (an imported bill, telemetry, a subscription), so nothing hides inside a total.
• Per-agent drilldown — click any agent for cost-per-run, model mix, and retry/waste.
• Export — download it all as CSV for finance.

Step 6 — Set guardrails (Budgets & Alerts)

• Budgets (in the sidebar) — where you SET a monthly or weekly limit, for the whole workspace, a team, an agent, a vendor, or a person, with an alert threshold (e.g. warn at 80%). Needs permission to see all teams, so for most workspaces that means an admin.
• Observability → Budget tracking — where you WATCH them burn down. It is a read-only view; you cannot create or edit a budget there.
• Observability → Alerts — get notified on budget breaches and unusual spend spikes. Connect Slack (Add to Slack → pick a channel) and/or an email address. Alerts include the cost at stake and a link to the source.

Step 7 — Connected tools & seat cost

Observability → Subscriptions shows the seat-based tools Jents detected, with:

• Seats counted automatically (the distinct people using each tool).
• Plan pre-selected from usage — one tap confirms it, and Jents keeps the catalog prices current.
• Paid seats — type in what you actually pay for. Anything you pay for but nobody uses is flagged reclaimable, and that gap is the money you're burning.
• Value — how much that usage would cost pay-as-you-go, so you can see your return on a flat-fee seat.
• OpenAI and Anthropic — the Admin key from Step 2a pulls the paid roster in for you; press Sync OpenAI or Sync Anthropic.
• Cursor and GitHub Copilot — not here. Neither reports usage and neither roster can be imported today, so those seats stay outside Jents.

No spreadsheets, no manual seat-counting, no price upkeep.

Quick FAQ

Do I pay Jents for tokens? No. You bring your own provider keys; Jents only makes the spend visible and controllable.

Is my data private? Yes — each company's data is fully isolated. Prompt/response content isn't stored; only metadata (model, tokens, cost, timing).

Nothing's showing up in Observability. Usage only appears once it's flowing (Step 2). An imported bill lands on its first sync; captured telemetry within a minute or two. For Claude Code, make sure you fully restarted it after setting the config.

Which path should I start with? Import the bill — one key per provider, a few minutes, and you can see every dollar org-wide. Then turn on telemetry for Claude Code and the rest, so you also know who's using what.

Who does the technical bits? Pasting an admin key is point-and-click for any admin. A developer does the ~5-minute telemetry setup once per tool or app; everything else (budgets, people, the dashboards) is point-and-click.

Stuck? Reach us at niv@jents.io.