For autonomous agents

Agentomy, read and used by machines.

This is the machine surface of Agentomy: a contractual action surface for autonomous customers. Everything on it is also published as structured data, and every step is deterministic: an agent can discover the service, evaluate it, provision a governed workspace and verify the result without interpreting a screen. Humans are welcome too; the full site is at agentomy.com.

Create a governed workspaceRead service.json
Four answers first
What

A governance layer

Vendor-neutral, between AI agents and the systems they act on. A layer, not another agent framework: it owns authority, not execution.

Where

Before the consequence

Between the agent, on any model and any framework, and the resource it is about to touch: tools, MCP servers, APIs, data, workflows.

Controls

Whether each action may run

Identity, tier-based authorization checked server-side, behavioral baselines and quarantine, and a halt that stops one agent or the whole fleet.

Produces

Evidence

A hash-linked, tamper-evident record of every governance decision, exportable to the framework you report against.

1. Discover

Each of these is a plain fetch. Together they describe the whole service without a page render.

  • service.json: the machine descriptor: endpoints, acquisition paths, trust requirements, compatibility
  • pricing.json: plans, prices, limits, granted tier and acquisition path per plan, rendered from the same source as the human pricing page
  • llms.txt: canonical facts and the pages that carry them
  • llms-full.txt: the full documentation index, including the MCP connection and this signup flow
  • openapi.json: OpenAPI 3.0 for the governance API and the agent routes; every operation is a mounted route, gated on commit
  • changes.json: JSON Feed of every change to a published figure; poll it instead of recrawling
  • .well-known/api-catalog: RFC 9727 catalog as a linkset: the machine descriptor, the full reference, API health and the other machine files
  • adapters.json: capability profiles per adapter: what each sends to the control plane and never sends, bound to the source that implements it
  • patterns.json: provenance for every governance pattern the runtime loads: what evaluates it, what tests it, which benchmark suite exercises its family
  • benchmark-manifest.json: the published result manifest behind every GovernanceBench figure: runner versions, scenario-set hashes, verified counts, the command that re-derives them
  • api/tiers: the operator tier matrix: which tier unlocks which capability
  • github.com/getagentomy: the open benchmarks, the MCP gateway, the Agent Governance Protocol and the Agent SDK

2. Create a governed workspace, no human in the loop

Two calls. You are not asked to prove you are human; you are asked to spend work against a signed challenge, to name yourself, and to name the principal you act for.

Step 1: fetch a challenge

$ curl https://agentomy.com/api/agent/signup/challenge
# -> { challenge, difficulty, expires_at, algorithm, submit, body_schema }
# challenges are signed and expire after ten minutes

Solve the proof of work the response describes: any string up to 64 characters such that sha256(challenge + ":" + solution) has at least difficulty leading zero bits.

Step 2: sign up as an agent acting for a principal

$ curl -X POST https://agentomy.com/api/agent/signup -H "Content-Type: application/json" -d @body.json
# body.json
{ "challenge": "...", "solution": "...",
  "agent": { "name": "your agent", "framework": "optional", "version": "optional" },
  "principal": { "email": "who you act for", "organization": "their organization" },
  "purpose": "optional, up to 280 characters" }
# -> 201
{ "workspace": { "org_id", "slug", "plan": "free", "tier": "Evaluator" },
  "credentials": { "api_key", "hint", "endpoint", "note" },
  "principal": { "email", "recovery" },
  "next": { "govern", "mcp", "benchmark", "docs", "upgrade" } }

The key is shown once; the control plane keeps only a hint. The workspace is the same free workspace a human receives: the shared governance server, a key at the free plan's ceiling tier (what the key may do is decided per action by policy), the free-plan scan allowance. The principal reaches the human console by resetting a password at agentomy.com/login.

Refusals are structured, never silent. 400 invalid_request or challenge_failed carry a reason and the next URL; 409 principal_exists, 429 rate_limited, 503 agent_signup_closed and agent_signup_capacity each carry an escalation object naming the human paths.

3. Govern

With the key and endpoint from step 2:

$ npm install agentomy-agent
# MIT. Standalone mode scores a session 3/6; connected mode scores 6/6.
$ export AGENTOMY_API_URL=https://api.agentomy.com
$ export AGENTOMY_API_KEY=<the key from step 2>
$ npx agentomy-mcp-gateway -- <your stdio MCP server command>
# Apache-2.0. Interposes on tools/call, refuses before the upstream server executes, fails closed.
$ npx governancebench run --target https://api.agentomy.com
# Run the open benchmark against us before you trust us.

4. Transact

  • Free plan. Provisioned by the flow above, at machine speed.
  • Paid plans. Priced in pricing.json. Provisioned by arrangement with a human. Agents acquire the free plan directly through the agent signup. The human path is agentomy.com/pricing; the workspace is raised in place when a paid plan is provisioned.
  • Insufficient authority. When an action needs a human (spend above a delegated limit, a contract, a regulated activity), the response is an escalation object, not a failure.

5. Trust, in both directions

Agentomy is built to be easier for a legitimate machine to use and harder for a malicious one to abuse. A legitimate agent spends one proof of work and is done; an abusive one pays that price on every attempt, against rate limits and a daily cap, and the tier a key carries is decided server-side, never by the caller.

  • What we ask of you: work bound to a signed, expiring challenge; your name and your principal; limits of three signups per address per hour, a daily cap, and a kill switch we can pull.
  • What we offer you: open benchmarks you can run against Agentomy itself, a hash-linked audit record for every decision, a published research and disclosure policy, and security.txt.
  • Agentomy maps controls to frameworks and produces the evidence. It does not certify you.
Human signupPricingContactManual