jentic-one

Self-hosted execution layer for AI agents: connect any agent to real APIs, scope exactly what it can touch, and keep credentials out of the agent's hands.

Automatically checked · GitHub checked 2026-11-12

jentic-one

Overview

Jentic One

A self-hosted execution layer for AI agents.
Connect an agent to any API you need, and enforce exactly what it is allowed to call.

Quickstart · Docs · Security · API Directory · Discussions

CI License: Apache 2.0 Listed on Open Source Alternatives

[!NOTE] Public beta. Schemas and CLI commands can change between 0.x releases — pin a version if you need stability.

What it is

An agent sends POST /v1/invoices to Jentic One, which checks the permission, injects the stored credential and forwards the call to the Stripe API; the API returns 201 and the call is logged. The agent then sends POST /v1/refunds; the permission check denies it by rule, the request never leaves Jentic One, the agent gets a 403, and the denial is logged. The agent never sees the API key.

Giving an agent API access normally means giving it an API key. Jentic One removes that step: you store each credential once, on your own infrastructure, and the agent calls APIs through the Broker. The Broker checks what the agent is allowed to do, attaches the credential, and records the call. The agent never sees your keys — and you can cut off one agent without rotating anything.

Agents connect through the jentic CLI, a generated skill, an MCP server, or plain HTTP.

Who it's for: developers giving a coding agent (Claude Code, Codex, Cursor, Cline, …) real API access; teams running agents inside a private network; anyone who has to pass a security review before an agent touches production credentials.

Quickstart

Sets up a self-hosted Jentic One instance on your machine with Docker. Run your agents in a separate environment from the stack (a different machine, VM or user), and connect them over HTTP or MCP. The key that encrypts your credentials lives in ~/.config/jentic-one/.env: back it up.

Start the instance

# Download the quickstart compose file
curl -fsSLO https://raw.githubusercontent.com/jentic/jentic-one/main/deploy/docker/quickstart/docker-compose.yaml

# Generate the credential-encryption key (once; a re-run keeps the existing key)
mkdir -p ~/.config/jentic-one
(umask 077; set -C; echo "JENTIC_ENCRYPTION_KEY=$(openssl rand -base64 32)" > ~/.config/jentic-one/.env)

# Start the stack. Open the webapp at http://127.0.0.1:8000 (or your configured url) once it returns
docker compose up -d --wait

Connect your agent

Run these on the machine where your agent runs. For MCP setup, see Setting up your MCP client.

Install the CLIs

brew install --cask jentic/tap/jentic    # macOS / Linux

scoop bucket add jentic https://github.com/jentic/scoop-bucket   # Windows
scoop install jentic

# Or install directly from GitHub
curl -fsSL https://raw.githubusercontent.com/jentic/jentic-one/main/tools/clis/install.sh | sh

Register your agent

JENTIC_ONE_URL=http://127.0.0.1:8000   # where your Jentic One web app is running
jentic setup --url "$JENTIC_ONE_URL"   # registers the agent and installs its skill; approve it in the UI

Next: make your first brokered call.

Manage the instance

Run these in the folder with docker-compose.yaml.

# Stop the stack
docker compose down

# Start it again
docker compose up -d

# Restart it
docker compose restart

Alternative deployments

If you want…Go to
Production on Docker (Postgres, pinned image, TLS)Docker · docker-compose · systemd
KubernetesHelm
Buy it on AWS Marketplace (runs on your EKS)AWS Marketplace
A trial without compose (plain docker run, SQLite)Trial setup
From source, to develop on itLocal setup
CLI without a package managerInstalling the CLIs

How it works

Two units over one database. The operator uses App, the control plane, with the Registry, Control, Admin and Auth surfaces: register APIs, store credentials, approve agents. The agent registers through App and calls the Broker, the data plane, which checks permissions, injects the credential and forwards the call to public or private APIs. App writes rules and credentials to PostgreSQL or SQLite (three databases: registry, control and admin); the Broker reads them and records every call.

Jentic One runs as two units over one database. App (the control plane) is where you register APIs, store credentials and approve agents. Broker (the data plane) is what agents call: it checks permissions, injects the credential after the check, forwards the request and writes an execution record. More in Architecture.

One boundary to know: the Broker protects credentials from agents running as other OS users or on other machines. An agent running as the same OS user as its CLI state can read that state — see same-host setups.

Documentation

I want to…Start here
Install and run itInstallation
Make my first API call through itFirst brokered call
Connect my agentConnecting agents
Deploy it securelySecurity
Keep it running (upgrades, backups, monitoring)Operations
Understand how it's builtArchitecture
Look up a config key, endpoint or CLI flagReference
ContributeCONTRIBUTING.md · Local setup

Everything else is in the documentation index. AI agents can start from llms.txt.

Community

Questions and ideas go to Discussions; bugs and contributions to the issues. Security reports: SECURITY.md. Support options: SUPPORT.md. For commercial use: jentic.com/contact.

License

Apache 2.0; third-party attributions in NOTICE.