The AI agents framework
with built-in governance.
Delta AI Agents Framework
& Runtime
How it works
You define the agent, the math based engine supervises, and every agent action is validated, authorized, or escalated back to you, strict on policy and rules, no prompt hacks!
Define the agent, its actions, and the policies it must obey. Approve the calls the engine escalates.
const support = delta.agent({
name: "support-agent",
actions: [lookupCustomer],
});
delta.deploy(support);Validates schema, budget, and risk. Authorizes or escalates every proposed action, and audits the whole run.
Reasons over the goal and proposes the next action. It never executes anything itself.
lookup-customer({ customerId: "C-42" })Define the agent, its actions, and the policies it must obey. Approve the calls the engine escalates.
const support = delta.agent({
name: "support-agent",
actions: [lookupCustomer],
});
delta.deploy(support);Validates schema, budget, and risk. Authorizes or escalates every proposed action, and audits the whole run.
Reasons over the goal and proposes the next action. It never executes anything itself.
lookup-customer({ customerId: "C-42" })One audited loop, nothing executes until the engine approves it.
How to use the Delta framework
From zero to a governed agent in four steps.
Create the engine
One engine owns everything: model access, budgets, policies, and the audit trail. Point it at a provider and pick your models.
import { createDeltaEngine, Ok } from "delta-agents";
const delta = await createDeltaEngine({
apiKey: process.env.OPENAI_API_KEY,
models: [{ name: "fast", model: "gpt-4o-mini", default: true }],
});Define a governed action
Actions declare their schema and risk score up front. The engine validates every call against them, so nothing malformed or over-risk ever runs.
const lookupCustomer = delta.action({
name: "lookup-customer",
description: "Look up a customer account by ID",
risk: 1,
schema: z.object({ customerId: z.string() }),
fn: async ({ customerId }) => Ok(await db.customer.find(customerId)),
});Compose the agent
Give the agent a role and only the actions it is allowed to use. Its capabilities are the list you hand it, nothing more.
const supportAgent = delta.agent({
name: "support-agent",
description: "Handles customer support requests",
role: "Customer Support Specialist",
rolePrompt: "Help customers resolve their issues.",
actions: [lookupCustomer],
});Deploy and send work
One line deploys the agent. Every run carries a budget, and the engine supervises it from goal to result.
delta.deploy(supportAgent);
const result = await delta.send({
goal: "Look up customer C-42",
agentName: "support-agent",
input: { customerId: "C-42" },
budget: { tokens: 5000, durationMs: 30_000 },
});Features highlight
Agents cannot execute unsafe actions
Budget enforcement across token, time, and multi-dimensional levels. Schema validation and prerequisite checks block unsafe actions before they run. Loop detection catches reasoning spirals early.
Workflows recover from failure points
Multi-phase SOPs resume from the failed step, not the start. High-risk operations pause for human approval. The engine resumes from the exact checkpoint once approved.
Agents coordinate through bounded delegation
Scoped budgets prevent delegation from running away. Automatic retries, restarts, and escalations handle unresponsive teammates. Mailbox read receipts confirm delivery across the team.
Agents retrieve context on demand
Agents retrieve past task context on demand. They record notes and improve on repeated work. Temporal awareness supports time-sensitive decisions.
Human oversight with real-time events
High-risk actions pause for approval; the engine emits typed events the moment an escalation, approval request, or task outcome occurs. Dashboards and webhooks react instantly without polling.
Tools operate under the same governance
Web search, document extraction, and custom tools all route through the same budget and audit pipeline. No exception paths, no untracked side effects.
Workflows run deterministically
Multi-phase SOPs run the same way every time, regardless of which model executes them. Conditional branching and declared prerequisites keep execution predictable.
Agents work in your channels
Agents communicate through Slack, Teams, Discord, or Telegram. Execution is decoupled from delivery, so agents keep working even when a channel is down.
Bring your own models
OpenAI, OpenRouter, or any OpenAI-compatible endpoint. Swap models freely; the governance layer stays exactly the same.