Install Jentic One Beta

Connect the Agentic Control Plane — Gateway API to your agent

Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the Agentic Control Plane — Gateway API, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.

Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.

Step 1: Jentic One Host machine

# On the machine that will host your Jentic One instance:
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fagenticcontrolplane.com%2Fagenticcontrolplane" | sh

Step 2: Agent machine

# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fagenticcontrolplane.com%2Fagenticcontrolplane" | sh
jentic register       # connects your agent to your Jentic One instance

Jentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.

Capabilities

What an agent can do with Agentic Control Plane — Gateway API.

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

GET STARTED

Start building with Agentic Control Plane — Gateway API

Explore with Jentic One

View OpenAPI Document

Use Cases

Patterns agents use Agentic Control Plane — Gateway API for, with concrete tasks.

★ 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.

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.

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.

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

Key Endpoints

27 endpoints — the agentic control plane gateway api fronts large language model calls through a governed proxy and tracks how agents use them.

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

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

Why Jentic?

What agents get from Jentic-routed access to this vendor.

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 isolation

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.

Intent-based discovery

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.

FAQs

Specific to using Agentic Control Plane — Gateway API through Jentic.

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.

Agentic Control Plane — Gateway API

AI ReadinessAI-Aware (B+)68/100

See full scorecard

Official vendor OpenAPI document · agent-readyAI/MLLanguage Modelsbearer27 EndpointsREST

For 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.

Use for: I need to run an agent profile and read its steps, Send a chat completion through the governed proxy, List the models available to me, Check my model spend by model

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

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.

Jentic One on Github View OpenAPI Document

Show dimension breakdown

Foundational Compliance

Base layer of spec validity and structural soundness.

Grade: A+Signals: 4

97%

Lint Results

Aggregated quality score from linter diagnostics, weighted by severity.

100%

Resolution Completeness

Percentage of `$ref` references that resolve successfully.

100%

Specification Validity

Checks whether the API description parses successfully and conforms to its declared specification (e.g., OpenAPI).

100%

Structural Integrity

Structural correctness score based on schema issues using logarithmic dampening.

Developer Experience & Jentic Compatibility

Clarity, completeness, and ingestion readiness for developers and tooling.

Grade: BSignals: 4

Example Density

How richly the API is illustrated with examples.

100%

Example Validity

Percentage of examples that conform to their schemas.

68%

Response Coverage

Percentage of operations with complete response definitions (success, client error, server error).

100%

Tooling Readiness

Health of API ingestion, bundling, and resolution within Jentic pipelines.

AI-Readiness & Agent Experience

Semantic breadth, depth, and agent comprehension for AI systems.

Grade: D+Signals: 4

53%

Description Coverage

Coverage of descriptions across API elements.

Error Standardization

Coverage of RFC 9457 Problem Details for error responses.

93%

OperationId Quality

Coverage, uniqueness, and casing consistency of operationIds for AI inference.

53%

Summary Coverage

Coverage of summaries across operations/tags/info.

Agent Usability

Functional utility, complexity comfort, and AI orchestration readiness.

Grade: A+Signals: 1

94%

Complexity Comfort

Agent comfort level based on API operational and structural complexity.

Security

Trust, risk posture, and security compliance.

Grade: B-Signals: 1

60%

Authentication Strength

Average quality of security schemes based on authentication method strength (weakest link for OAuth2).

AI Discoverability

Findability, semantic richness, and reasoning readiness.

Grade: A-Signals: 1

74%

Descriptive Richness

Clarity and depth of descriptions across API elements.

Connect the Agentic Control Plane — Gateway API to your agent

Capabilities

Start building with Agentic Control Plane — Gateway API

Use Cases

Key Endpoints

Why Jentic?

Related APIs

FAQs

Agentic Control Plane — Gateway API

Jentic AI Readiness Score

Agentic Control Plane — Gateway API

Foundational Compliance

Lint Results

Resolution Completeness

Specification Validity

Structural Integrity

Developer Experience & Jentic Compatibility

Example Density

Example Validity

Response Coverage

Tooling Readiness

AI-Readiness & Agent Experience

Description Coverage

Error Standardization

OperationId Quality

Summary Coverage

Agent Usability

Complexity Comfort

Security

Authentication Strength

AI Discoverability

Descriptive Richness