canonical: https://jentic.com/apis/agenticcontrolplane.com/agenticcontrolplane

# Agentic Control Plane — Gateway API

The Agentic Control Plane Gateway API fronts large language model calls through a governed proxy and tracks how agents use them. It routes OpenAI-compatible chat completions, Anthropic-compatible messages, and the OpenAI Responses shape through one key, lists available models, and runs stored agent profiles while recording ordered run summaries. Agents introspect their own usage, model spend by model, recent governance decisions, and per-session traces, and can mint scope-narrowed child keys or issue short-lived scoped tokens for delegation. Access uses a gsk_-prefixed key, some surfaces are feature-flagged and return 404 when disabled, and rate-limited endpoints return IETF draft-7 RateLimit headers.

## For AI agents

Route governed OpenAI- and Anthropic-compatible model calls, run stored agent profiles, introspect usage and spend, and mint scope-narrowed child keys. Authenticates with a gsk_-prefixed bearer key.

## Scope

Does not handle model training, data labeling, or payment collection. Use for routing governed model calls, running agent profiles, and introspecting usage only.

## Capabilities

- Create and run agent profiles and read ordered run summaries with their steps
- Call a governed OpenAI-compatible chat completions proxy and list available models
- Send Anthropic-compatible messages and OpenAI Responses calls through the governed proxy
- Introspect your own usage, model spend by model, recent governance decisions, and session traces
- Mint scope-narrowed child keys and issue or revoke short-lived scoped tokens

## Use cases

### Governed Model Calls via Jentic

An AI agent can route its model calls through the gateway so spend and decisions are recorded centrally. Through Jentic the agent sends an OpenAI-compatible chat completion to the governed proxy, lists the models it may use, and later reads its own usage and spend, letting Jentic inject the key rather than embedding it in the call.

Example prompt: List the available models, send an OpenAI-compatible chat completion through the governed proxy, then read usage and model spend for the call

### Delegation with Scoped Keys

A supervising agent hands narrower authority to sub-agents without sharing its own key. The gateway mints scope-narrowed child keys and issues short-lived scoped tokens that can later be revoked, so each delegated task runs with only the authority it needs and the delegation chain stays auditable.

Example prompt: Mint a scope-narrowed child key for a sub-task, issue a short-lived scoped token from it, and revoke the token once the task finishes

### Usage and Governance Introspection

Teams need to see what agents cost and decide. The gateway reports a plan meter and the caller's share, model spend by model, recent risk-annotated governance decisions, and per-session run traces, so an agent or operator reviews cost and behaviour and acts on evidence-backed recommendations.

Example prompt: Read model spend by model and the recent governance decisions, then pull the trace for one flagged session to inspect its steps

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/api/v1/agents` | Create an agent profile |
| GET | `/api/v1/agents` | List agent profiles |
| POST | `/api/v1/agents/{id}/run` | Run an agent |
| GET | `/api/v1/runs` | List run summaries |
| POST | `/v1/chat/completions` | OpenAI-compatible chat completions (governed) |
| GET | `/v1/models` | List models (OpenAI-compatible) |
| POST | `/api/v1/keys/child` | Mint a scope-narrowed child API key |

## Key resources

- **Agents and runs** — Create, update, and run agent profiles and read run summaries with ordered steps.
- **Governed proxy** — Call OpenAI-compatible chat completions, Anthropic-compatible messages, OpenAI Responses, and list models.
- **Introspection** — Read usage, model spend, governance decisions, session traces, and cost insights.
- **Delegation and credentials** — Mint scope-narrowed child keys and issue or revoke short-lived scoped tokens.

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 68 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 99 / 100
  - Developer Experience & Jentic Compatibility: 67 / 100
  - AI-Readiness & Agent Experience: 50 / 100
  - Agent Usability: 94 / 100
  - Security: 60 / 100
  - AI Discoverability: 74 / 100
- **View full report:** https://jentic.com/apis/agenticcontrolplane.com/agenticcontrolplane/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring the Agentic Control Plane by hand means learning its gsk_-prefixed bearer key, choosing between the OpenAI-compatible, Anthropic-compatible, and Responses proxy shapes, and handling feature-flagged surfaces that return 404 when disabled. Through Jentic you install once, import it from the API Directory, store the key once, and your agent runs profiles and calls the proxy.
- **Permission scoping:** The gateway puts the agent id in the URL path (`/api/v1/agents/{id}`), so a rule can pin your agent to one agent profile and the operations you choose, such as running it and reading run summaries. You decide which operations it may call, so deleting profiles or minting child keys stays out unless you add it.
- **Credential handling:** Your gateway key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'send a governed chat completion' or 'run an agent profile', and Jentic returns the matching Agentic Control Plane operation with its input schema so the agent calls the right endpoint directly.

## Related APIs

- **OpenRouter** — OpenRouter routes requests across many model providers; the Agentic Control Plane adds governance, run profiles, and delegation.
- **Portkey** — Portkey is an AI gateway with observability and routing; the Agentic Control Plane pairs the governed proxy with agent profiles and scoped keys.
- **OpenAI** — OpenAI is a model provider the proxy can front; the Agentic Control Plane governs and meters the calls to it.

## FAQ

### What authentication does the Agentic Control Plane API use?

The Agentic Control Plane gateway authenticates with a gsk_-prefixed API key sent as a bearer token in the Authorization header, per its OpenAPI spec. The key is needed on most operations, while the status and OpenAPI document endpoints and the sandbox-tenant provisioning endpoint stay open with no credential. Through Jentic the key is stored encrypted on your own instance and injected at call time.

### Is there an Agentic Control Plane MCP server?

Yes, the gateway exposes an MCP endpoint over streamable HTTP. You can also connect it directly through Jentic: your agent gets the full 27-endpoint surface without loading another server's tool definitions into its context, your key is injected at call time by your self-hosted instance instead of living in a config file, and your rules decide which operations the agent may call.

### Can I limit what my agent is allowed to do with the Agentic Control Plane API?

Yes. Because the agent id travels in the URL path, you can write a rule that allows only running a profile and reading its run summaries, so the agent drives that profile and nothing else. Deleting profiles or minting child keys stays out of the rule unless you add it, which complements the gateway's own scope-narrowed child keys.

### Can I route model calls through the Agentic Control Plane API?

Yes. The gateway proxies OpenAI-compatible chat completions, Anthropic-compatible messages, and the OpenAI Responses shape through one key, and lists the models available to you. Each call is governed, so usage, model spend, and decisions are recorded and can be read back through the introspection endpoints.

### What are the rate limits for the Agentic Control Plane API?

The Agentic Control Plane OpenAPI spec does not publish fixed numeric rate limits. Rate-limited endpoints instead return IETF draft-7 RateLimit and RateLimit-Policy headers on every response and a 429 with the same headers when a limit is exceeded, so a client paces itself from the headers. Check the Agentic Control Plane documentation at https://agenticcontrolplane.com/agents/configure-as-code for current details.

### How do I route a model call with the Agentic Control Plane API through Jentic?

Search the Jentic API Directory for an intent like 'send a governed chat completion', import the Agentic Control Plane, and store your key once. Your agent then lists models and sends a chat completion through the governed proxy via Jentic. To run it on your own infrastructure, install Jentic One from its GitHub repo.