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, real-time alerts, guardrails.
• Manage the agents themselves — an inventory, a reuse marketplace, duplicate detection.

You bring your own AI provider keys (OpenAI, Anthropic, Google) — Jents never charges you for tokens; it just makes the spend visible and controllable.

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: route what you can through the Gateway (most accurate), pull in the rest with Jents Capture, and track closed seat-based tools as Subscriptions.

Don't worry about doing all three at once — start with whichever matches what you run today.

Step 1 — Create your workspace

1. Go to app.jents.io and sign up (work email).
2. Verify your email and set a password.
3. 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. The Gateway — for agents & apps you control (most accurate)

This routes your AI calls through Jents so it captures the exact cost of every call.

1. In Control → Models, connect an AI vendor and paste your own API key (OpenAI, Anthropic, or Google). Your key is stored only on the secure gateway — never in the Jents app database.
2. Jents gives you a gateway address and lets you mint a key per agent.
3. Point your agent at the gateway instead of the vendor directly — it's a drop-in, OpenAI-compatible endpoint. Your developer changes two things in the agent's config:
   • the base URL → your Jents gateway address
   • the API key → the per-agent key Jents gave you
4. Run the agent. Its spend now appears in Observability within seconds — with exact cost, tokens, model, and latency.

Why per-agent keys? So you can see cost per agent automatically, and so one agent can never use another's models.

2b. Jents Capture — for your own code, and Claude Code

For things that don't go through the gateway (a production service, a background job, a local script) — or for Claude Code, which has telemetry built in.

Go to Jents Capture (Observability → Capture) and generate an ingest key (copy it — shown once). Then:

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

pip install jents

import jents
jents.init(api_key="<your ingest key>", 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>", team: "<your team>" });

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 Ingest page flips to "Receiving ✓."

Cost for Jents Capture usage is estimated from token counts (the gateway computes it exactly). For flat-fee tools like Claude Code, the token usage shows as value/utilization — the real cost is the seat subscription (next section).

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

Closed tools you pay a per-seat fee for (Cursor, ChatGPT Team, Copilot) don't expose usage. Track their cost instead:

• Automatic: if a tool reports telemetry (e.g. Claude Code), it shows up under Subscriptions → Connected tools — Jents counts the seats and prices it from a built-in catalog. You just confirm the plan in one tap.
• Manual: for everything else, Subscriptions → Add a subscription (name, cost, seats).

Step 3 — Add your team (People)

So spend can be attributed to people and departments:

1. Go to People → Sync from your directory (pulls your team in).
2. Assign each person a department.

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

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

The Hub is your inventory of every AI agent the company runs.

• Hub (home) — your inventory of every agent you run. Add new ones via Capture AI source; they're checked for duplicates as you go.
• Marketplace — browse agents other teams built, and reuse them instead of rebuilding.
• Duplicates — find overlapping agents and retire the weaker one.
• Connections — record which systems/APIs each agent touches (your "blast radius").
• Discovery — Jents flags AI traffic that isn't tied to a registered agent, so you can register it in one click.

Tip: if you set up the Gateway in Step 2, Discovery will surface your live agents automatically — a fast way to populate the Hub.

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 — gateway vs. self-reported (so subscription-tool usage stays visible).
• 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)

• Observability → Budgets — 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%).
• 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

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

• Seats counted automatically (the distinct people using each tool).
• Cost = seats × the catalog price for your plan — Jents keeps the prices current; you just confirm your plan tier once (it pre-selects its best guess).
• Value — how much that usage would cost pay-as-you-go, so you can see your return on a flat-fee seat.

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). Gateway calls appear in seconds; Jents Capture within a minute or two. For Claude Code, make sure you fully restarted it after setting the config — the Capture page shows "Receiving ✓" when data is arriving.

Which path should I start with? Route the agents you control through the Gateway (exact cost), pull in Claude Code + your own apps with Jents Capture, and add closed seat-tools as Subscriptions.

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

Stuck? Reach us at niv@jents.io.