Product
Oxagen, the agent control plane
More
Access Record Budget and rules Equipment Field manual Research Docs Get a demo

Workforce management for autonomous agents

Your agents are a workforce now.
Manage them like one.

Oxagen governs the agents you run, autonomous and supervised alike. It does not run them. One mandate per agent, set by security, FinOps, and engineering, checked on the calls routed through Oxagen. One fleet, on one page, with what each agent asked for, spent, and did.

See your fleet → Get a demo

Bring your own model keys and your own graph. The first screen shows your own numbers. Read the docs

One mandate, four clauses

Every agent runs under one mandate

Every other layer covers one clause of an agent's mandate and stops. Identity says who the agent is. Gateways say which tools it can call. Billing says what it consumed. Prompt repos say what it was told. Oxagen binds all of it into one object, enforces it on every call, and keeps the record.

Access

Don't hand your agents the keys.

Security sets it. The agent holds an identity and a mandate, and nothing else. When a task needs a system, the agent asks, and a rule you wrote answers: allowed, denied, or routed to a person. No model takes part in the decision.

How a request is answered →

Record

Any answer, walked back to the frame.

The platform keeps it. Every run is recorded frame by frame, hash-chained, and kept for seven years. Any answer walks back to who started the task, what the agent was told, what it asked for, which rule answered, and what it cost.

Read a run →

Budget and rules

See which agent spent what, and on whose behalf.

FinOps sets it. Every model call routed through Oxagen is priced by token class, attributed to the person, the agent, the run, the turn, and the step, and reconciled to the cent against the provider's bill. Findings ranked by the money at stake name what to fix and who can fix it.

See the findings →

Equipment

Give agents the business context their work requires.

Engineering sets it. Every agent starts a job with a knowledge graph built from your own sources and steering that lives in your repo. Recorded once, and drawn on by every agent whose mandate covers it.

Watch a change land →

Access

Don't hand your agents the keys

An agent under Oxagen holds an identity and a mandate. It does not hold a token to GitHub, a password to the database, or a standing grant to anything. When a task needs one of those, the agent asks.

  • The request carries who started the task, which agent is asking, which tool it wants, and which data it would reach.
  • A rule the owning team wrote answers it: allowed, denied, or routed to a named person. Allowed and denied requests settle inside the same call. Routed requests wait for the person, and the run waits with them.
  • For a mediated connection, the credential stays in Oxagen. Oxagen uses it on the agent's behalf, and the agent does not receive it. The agent's own identity is separate.
  • A tool that is not in the agent's mandate cannot be seen or found. Rules are deterministic and versioned, and every answer leaves a signed row in the record.
  • Stopping an agent denies its next request and closes the connections behind it. Halting does not ask the agent to cooperate.

Record

Any answer, walked back to the frame

"Why did the agent do that?" deserves an answer, not a guess.

  • Each model request and response, tool call and result, request and the rule that answered it, and steer a person sent is a frame.
  • Every frame is hash-chained to the one before it, and the seal signs the whole run. Anyone with the export can recompute the result.
  • Step through a run like a recording, fork it from any frame to ask what a different rule would have done, and bisect two runs to find where they split.
  • Bodies stay in write-once storage for seven years by default, sealed with a signature your auditor can verify offline.

Budget and rules

Every dollar routed through Oxagen, reconciled to the cent

Your AI bill is a number with no story. Oxagen writes a cost record on every model call routed through it, by token class, and hangs it on the frame.

  • Spend rolls up from step to turn to run to agent to operator, so a team lead's number is the sum of their agents' runs.
  • The reconciler matches your records against provider statements and opens an exception for any variance over one cent.
  • The findings job reads the frames and names the waste: cache prefixes that never get read, tool lists wider than the agent uses, retry storms, runs on the wrong model tier.
  • Each finding carries the frames behind it and the estimated saving in dollars.
  • The budget an agent runs under and the rule that stops it sit beside the agent. The finance lead and the operator read the same rows.

Equipment

Give agents the business context their work requires

Most agents start every run knowing nothing about your company and end it having learned nothing you kept.

  • Every run draws on one knowledge graph built from your own sources, with provenance on every fact.
  • When an agent learns something, it proposes a context record. A person reviews it as a pull request on your repo, and only merged steering reaches the next run.
  • Nothing steers a run until a person merges it. The agent's own claim that it learned something is not enough.

Sixty seconds

Wrap the agents you already run

On the Agents page, Wrap Claude Code or Wrap Codex produces a signed installer with a one-time enrollment token. There is nothing to copy or paste, and the page flips to connected when the first frame arrives, with a rollback command beside it.

  • Claude Code
  • Codex
  • Anthropic Messages API
  • OpenAI Chat Completions
  • OpenAI Responses
  • Claude Agent SDK
  • OpenAI Agents SDK
  • TypeScript, Python, Go
Read the install guide → Everything Oxagen does →
Free ebook · read online, flip through it, or print it

A field manual for building and operating coding agents

Why does the same model work well for one team and poorly for another? The first thirteen parts answer with the system around the model, and cite the published evidence. The next seven cover what comes after the agents work: who each one is, what it may do, what it spent, and what it did.

  • How to hand a model the context a task needs, and nothing else
  • How to set an agent's identity, authority, budget, and tools in one mandate
  • What to do this week and what to measure, at the end of every part

Get a demo

Your bill, explained, in twenty minutes

Bring a repo. Wrap one machine, run one task, watch one request denied and one routed to a person, and read what it cost by person, agent, run, turn, and step. If it is not obvious in the first ten, the call ends.

  • Live, on your codebase, not a canned deck
  • Straight answers on rollout, pricing, and security review
  • You keep the run record