Agenticaria

Agent runtime

Ship agents that know their model.

Write one blueprint, then compile model-aware prompts so behavior stays sharp when the underlying model changes. Eval before you promote, then embed the same path in your product.

Start free Docs

Scroll

Why

Right prompt. Right model.

Most teams paste the same prompt across models and hope for the best. Agenticaria treats the agent as a blueprint: compile per model family, then select the matching artifact at run time.

Without

Prompts drift as models change and nobody owns the variants
Eval lives in a spreadsheet, outside the ship path
Glue code for runs, tools, and embeds piles up everywhere

With Agenticaria

One blueprint compiles into many model-specific artifacts
Eval gates promote — only passing versions ship
Run API, widget, and callbacks are built into the same plane

Runtime plane

How work moves

Follow the path from blueprint to embed: compile, eval, run, and optional Zenith lease. Click a node or scroll to step through the story.

01 · Author

Author the agent once: goals, tools, and constraints in a single blueprint.

Click a node · scroll to step the story

Features

What you get

Everything you need to define, test, run, and embed agents — without bolting on a second control plane.

Blueprints

One agent definition holds goals, tools, and constraints. Compile it into model-specific prompt artifacts you can version and promote.

Eval & promote

Run suites before a version goes live. Promote only what passes so production stays intentional.

Runs

Execute sync, async, or streamed. Attach callbacks when a job finishes so your systems stay in the loop.

Widget

Drop-in chat for your product, with origin allowlists so embeds stay locked to the sites you trust.

Tools

Call HTTP tools during a run and keep verified receipts so every side effect is auditable.

Zenith lease

Optional. When Zenith routes the model, Agenticaria waits for the lease, then picks the matching artifact.

Console

Agents, eval, runs, and keys in one browser UI — the same surface on selfhost and cloud.

Cloud

Multi-tenant workspaces with quotas, invites, and Tapsilat plans when you are ready to sell seats.

Console

Operate in one place

Day-two work stays in the console whether you run a lab compose stack or Agenticaria Cloud. Same screens, same workflows.

Agents — edit blueprints, publish versions, and promote what passed eval
Playground — try a run against the current artifact before you ship
Runs — filter history, reclaim stuck work, and inspect the DLQ
Eval — keep suites next to the agent so promote is never a guess
Widgets & keys — mint embed configs and revoke keys without leaving the UI

Developers

Call it from your stack

Authenticate with Bearer keys and hit the Run API for sync, stream, and parity checks. Widgets and agents use the same contract — see docs for the full surface.

$ curl -X POST "$BASE/api/v1/runs" \
    -H "Authorization: Bearer $KEY" \
    -d '{"agent_id":"agt_…","input":"…"}'

const res = await fetch(BASE + "/api/v1/runs", {
  method: "POST",
  headers: {
    Authorization: "Bearer " + KEY,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ agent_id: "agt_…", input: "…" }),
});

import httpx

res = httpx.post(
    f"{BASE}/api/v1/runs",
    headers={"Authorization": f"Bearer {KEY}"},
    json={"agent_id": "agt_…", "input": "…"},
)

Zenith

Optional inference control

Agenticaria owns the agent lifecycle. Zenith owns model routing, pools, and fleet policy. Connect them when you need a lease before run — or keep a standalone OpenAI-compatible upstream.

Agenticaria

Blueprints, compile, and prompt artifacts
Eval suites, promote, and HTTP tools
Widget embed and the Run API

Zenith

Provider pools and smart routing
Route lease before chat starts
Fleet policy and residency controls

Deploy

Your lab or our cloud

Same console and Run API either way. Choose where the data plane lives and how async work is scheduled.

Selfhost

One tenant with the full console. Bring it up with Compose when you want the stack on your own network.

Cloud

Signup, plans, quotas, and invites out of the box. Multi-tenant from the first workspace.

Worker

Async jobs ride NATS so long runs and callbacks stay off the request path.

Trust

Ready for staging

Built for teams that put agents in front of real users — secrets, origins, and release hygiene are first-class.

Secrets — encrypted provider keys, HMAC callbacks, and CSRF on console forms
Origins — widget allowlists so embeds only load where you permit them
Quotas — soft plan limits with export so usage stays visible
Release — signed images and SBOM for the path to production

Pricing

Built for production teams

Lab to try the runtime. Team and Business to ship. Enterprise when you need private deploy, SSO, and a custom MSA.

Lab

Evaluate blueprints, eval, and the Run API before you buy.

Get started

Team

$249/mo

Production agents for a product squad — compile, gate, embed.

Get started

Recommended

Business

$799/mo

Multi-agent fleets, widget embeds, and Zenith route-lease ready.

Get started

Full pricing · feature matrix · talk to sales

FAQ

Same as Zenith?

No. Zenith routes inference and enforces fleet policy. Agenticaria runs agents — blueprints, eval, tools, and embeds — on top of whatever upstream you choose.

Need Zenith?

No. A standalone OpenAI-compatible endpoint is enough to get started. Connect Zenith later when you want route-lease and shared policy.

Self-host?

Yes. Selfhost gives you the full console on a single tenant. Cloud adds signup, billing, quotas, and invites.

SDK?

Call the Run API from any language — curl, fetch, or httpx work today. For product UI, drop in the widget script with an origin allowlist.

Start with one agent.

Create a free workspace, compile your first blueprint, and embed it when it passes eval.

Create workspace Docs