Use cases

Make every AI task
worth running.

The next question after “does it work?” is “can we operate it?” Explore the workflows Kyberos is being built to make measurable, governable and easier to improve.

Product direction · The scenarios below describe planned capabilities built on the initial OpenAI-compatible gateway.

Autonomous agents · Planned

Give agents a budget.
Not an open tab.

An agent gets stuck retrying a tool, expanding a search or asking a model the same question. Each call looks valid. The run as a whole is going nowhere.

Kyberos is being designed to connect calls to a single run, account for cumulative model usage and evaluate each new request against a run policy. The application can then pause work or ask for approval when a boundary is reached.

The shift: delegate a task with operating limits, instead of discovering its cost after it finishes.

Illustrative policy flow · Not a live feature
  1. 01

    Define the run

    Run ID, allowed models, usage budget and maximum attempts.

  2. 02

    Check the next request

    Account for usage and in-flight work before admitting another call.

  3. 03

    Pause at the boundary

    Reject further model calls; let the application decide whether to stop or request approval.

Requires run-level instrumentation and a policy engine. In-flight charges and external tool costs need separate accounting; gateway limits alone do not guarantee a total spending cap.

Hermes · Pi · Custom agents

Keep your agent.
Connect its model calls to Kyberos.

Your agent still plans, uses tools and completes work. Kyberos sits on its model connection, providing a foundation for shared access controls and a future view of the whole task.

Agent ecosystem: Hermes · Pi · Codex · Claude Code

Integration path identified · Hermes and Pi document custom endpoint support. Codex and Claude Code are additional integration targets, subject to their endpoint and authentication options. End-to-end compatibility with Kyberos has not yet been validated for these agents. This page is an integration proposal, not a certification.

Agent runtime

Hermes / Pi / your agent

Plan · remember · execute

model calls
Gateway

Kyberos

Authenticate · forward · stream

inference
Models & providers

Your chosen model

Claude · Gemini · GPT

Multi-provider target

Agent → tools: files, shell, browser, MCP servers and external APIs. Permissions and execution remain in the agent runtime.

Model responses return along the same gateway path. Model names illustrate the target ecosystem; the initial gateway uses OpenAI, with other provider adapters planned. Kyberos sees only traffic routed through it and is not a sandbox for the agent.

Three levels of agent readiness

01 / Gateway foundation

Connect model traffic.

Use your deployed gateway URL, a Kyberos key and an enabled OpenAI model. Validate streaming and a complete tool-call round trip with your chosen agent version.

A shared model access point. Changing an endpoint alone does not add task-level tracking.

02 / Integration required

Connect calls to a task.

A planned adapter would attach run, parent-run and step identifiers, then report tool outcomes and completion status through an agreed event interface.

The basis for tracing retries and subagents together. The adapter and event contract are not yet shipped.

03 / Planned policies

Control the next step.

Evaluate cumulative model usage against a run policy. The gateway can reject new calls; the agent integration must handle that decision and pause or request approval.

Budgets and outcome analytics need both gateway policies and cooperation from the runtime.

Documented endpoint support

Hermes Agent

Hermes offers a custom OpenAI-compatible endpoint option. Run hermes model, select the custom endpoint option, and enter your Kyberos base URL, Kyberos key and enabled model.

Review auxiliary models and fallback providers separately: a main endpoint change does not establish that every agent-related call uses the same route.

Hermes endpoint documentation ↗Auxiliary model configuration ↗
Kyberos status

Candidate configuration path; agent-specific streaming, tool execution cycles, cancellation and auxiliary routing still need an integration test.

Documented provider configuration

Pi coding agent

Pi supports custom providers in ~/.pi/agent/models.json, including an endpoint, API type and environment-based key. This illustrative configuration uses Chat Completions:

{
  "providers": {
    "kyberos": {
      "baseUrl": "https://your-gateway.example/v1",
      "api": "openai-completions",
      "apiKey": "$KYBEROS_API_KEY",
      "authHeader": true,
      "models": [
        { "id": "YOUR_ENABLED_OPENAI_MODEL" }
      ]
    }
  }
}

Replace the example URL and model ID. Supply your issued key through KYBEROS_API_KEY. Set model capabilities, context limits and pricing for the actual model; this minimal example does not configure them.

Pi custom provider documentation ↗
Kyberos status

Configuration proposal only. Validate the chosen Pi version, model and API transport before relying on it.

Agent documentation reviewed on . This integration path uses an API key and a configured OpenAI upstream; it does not establish compatibility with subscription or OAuth-based agent backends.

Example workflow · Planned

“Fix the failing test.” One task, several model calls.

  1. Start: the integration creates a run ID and associates the task with a project.
  2. Work: model calls pass through Kyberos; Pi or Hermes reads files, edits code and runs tests within its own permissions.
  3. Retry: subsequent calls and child runs retain task context so usage can be grouped.
  4. Decide: a future run policy can block another model call; the runtime handles a pause or approval request.
  5. Finish: the integration reports the test result and acceptance outcome, enabling cost per accepted task.
From telemetry to decisions

More ways to change how you operate AI.

Data protection · Agent guardrailsPlanned

Give a support agent context without exposing every customer detail.

  1. CRM result
  2. Field selection + Kyberos protection
  3. Model context

A support agent needs an order status to draft a reply. Its CRM tool returns a full customer record, including contact details that the model does not need.

With Kyberos

Use a planned runtime or MCP integration to select necessary fields before they enter model context. Kyberos Data Protection would then inspect outbound model requests, replace policy-selected values and block recognizable secrets. Required checks would stop traffic on failure.

Make data exposure an explicit project decision for each protected workflow.

What to measure
Masking and blocking decisions, false positives, missed findings on approved test data, and added latency—without logging sensitive values.
What it needs
The planned Kyberos protection layer and a separate tool integration. Start with non-streaming text; detection is not guaranteed. Later restoration needs tenant- and session-scoped mappings plus recipient authorization.
Explore Kyberos Data Protection & Guardrails ↗
AWS teams · Amazon BedrockPlanned

Give each AWS workflow its own AI cost story.

  1. Support agent
  2. Kyberos + Bedrock adapter
  3. Amazon Bedrock

A support assistant and a document-processing agent both use models on Amazon Bedrock. The team needs to understand spend per resolved ticket and processed document, alongside its AWS billing view.

With Kyberos

Route model calls through a planned Bedrock adapter and attach project, workflow and run identifiers. For example, group all model calls for one support ticket and combine their usage with the resolution event from your application.

Keep your AWS inference setup while connecting model usage to business outcomes.

What to measure
Model cost per resolved ticket, retry spend and latency by workflow; reconcile estimates with AWS billing.
What it needs
A Bedrock adapter, authorized AWS identity, enabled model and approved Region or inference profile. The proposed Converse path needs request, streaming and tool-call translation; it is not just a base-URL change. Kyberos support is not yet validated.
Amazon Bedrock Converse documentation ↗
Multi-model teams · OpenRouterPlanned

Compare agent outcomes across your model catalog.

  1. Hermes / Pi / custom agent
  2. Kyberos
  3. OpenRouter → selected provider

A team uses OpenRouter to try different models for a coding agent. A cheaper request can still mean a more expensive task when the agent needs extra attempts.

With Kyberos

Use a planned OpenRouter upstream connection behind Kyberos. Run the same approved tasks with selected models, group calls by task and attempt, and report test acceptance from the agent. OpenRouter remains the model access layer; Kyberos would add workflow-level accounting.

Choose a model setup by cost per accepted task, with retries included.

What to measure
Accepted-task cost, completion rate and latency, including the actual provider route where available.
What it needs
An OpenRouter API key, supported model IDs and a validated Kyberos upstream adapter. OpenAI-compatible request formats alone do not prove compatibility. Test streaming, tool calls and usage reporting; review provider routing and data policies before enabling fallback.
OpenRouter API documentation ↗
AI SaaS · Product & financePlanned

Know which customers your AI can afford to serve.

Usage is growing, but a small group of customers generates most of the model spend. A single provider invoice hides which features and plans are sustainable.

With Kyberos

Attribute model usage to an opaque customer ID, feature and completed task. Combine that cost with revenue and non-model costs from your own systems.

Make pricing, fair-use and model decisions using cost per successful outcome.

What to measure
Model cost per resolved ticket, processed document or active customer.
What it needs
Application outcome events and your billing data. Model spend alone is not profit.
AI engineering · OptimizationPlanned

Reserve your strongest model for the work that needs it.

Simple classification and difficult reasoning both use the same premium model because no one has evidence that a cheaper option is good enough.

With Kyberos

Identify candidate workflows from usage patterns, evaluate alternatives on an approved test set, then propose a routing policy for human review.

Reduce unnecessary model spend while keeping quality thresholds explicit.

What to measure
Cost and latency compared alongside task success on the same evaluation set.
What it needs
Your quality criteria and approved evaluation data. Metadata alone cannot establish answer quality.
Engineering · Release managementPlanned

Catch an expensive prompt change before a full rollout.

A prompt update looks correct in testing, but increases output tokens, retries or latency once it meets production traffic.

With Kyberos

Tag requests with release and prompt versions. Compare a limited rollout with a baseline, and use agreed thresholds to inform expansion or rollback.

Treat AI cost and reliability regressions as release decisions.

What to measure
Change in cost per task, retry rate and p95 latency between versions.
What it needs
Version metadata and comparable traffic. Deployment and rollback remain under your control.
SRE · Support operationsPlanned

Turn a model error into a customer impact report.

A provider error appears in logs, but support still cannot tell which workflows failed, which users were affected or where retries made things worse.

With Kyberos

Correlate request IDs, workflow traces and application outcome events. Group affected requests by project, feature and opaque customer identifier.

Give engineering and support a shared view of the incident.

What to measure
Affected workflows, failed outcomes, retry chains and the incident time window.
What it needs
Application instrumentation and outcome events. A gateway cannot see tool activity it does not receive.
Platform · Production reliabilityPlanned

Make provider fallback a deliberate policy.

A provider slows down or fails. Blind retries consume time and budget, while switching models can change behavior or send data to an unapproved destination.

With Kyberos

Define approved alternatives per workflow, with capability, data-handling and cost constraints. Validate compatibility before enabling a fallback path.

Give each workflow an explicit recovery path with clear boundaries.

What to measure
Recovery rate, added latency, fallback cost and policy rejections.
What it needs
Planned multi-provider support and tested alternatives. Recovery must account for partial responses and duplicate work.
Developer tools · Engineering leadsPlanned

Measure the cost of a finished task, not just tokens.

One coding agent uses fewer tokens but needs repeated attempts. Another costs more per call but produces an accepted result sooner.

With Kyberos

Group model calls by task, agent and attempt. Attach your own test and acceptance outcomes to compare the total cost of completed work.

Choose agent setups based on useful results instead of token totals.

What to measure
Cost per accepted task, attempts to completion and abandoned-run spend.
What it needs
Agent integration and explicit acceptance events. Kyberos does not infer whether code is correct.
Start with one workflow

Bring the task you need to control.

The initial gateway provides OpenAI-compatible access, separate application credentials and a metadata-only telemetry hook. These scenarios guide what comes next. Tell us which decision your team cannot make with its current tools.

Discuss your use case

Working with sensitive data? Read about data handling and planned security controls →