Build, run & govern agents in production.

npx agentist init oncall
cd oncall

agentist dev
agentist run oncall.triage "checkout p99 latency is 5s"   # positional prompt — no flag

{ "severity": "sev2" }

// your company's charter — defined here, or pulled from Agentist Cloud
const acme = charter({
  mission: "Keep systems reliable and customer trust intact.",
  values: ["Bias to safety", "Explain your reasoning", "Escalate when unsure"],
})

const oncall = agent({
  extends: harness("on-call"),            // a base harness — extend, don't rebuild
  id: "oncall",
  identity: { name: "Otto", role: "On-call SRE", persona: "Calm, terse, evidence-driven." },
  charter: acme,                          // shared mission & culture
  skills: [k8s, prometheus, runbooks],    // reusable capabilities
  duties: { triage, remediate },
})

const queryMetrics = tool({
  id: "queryMetrics",
  input:  z.object({ service: z.string(), window: z.string() }),
  output: z.object({ p99Ms: z.number(), errorRate: z.number() }),
  run: ({ service, window }) => prometheus.query(service, window),
})

// inside a duty:
const m = await ctx.tools.queryMetrics({ service: a.service, window: "15m" })

export const incident = workflow("incident")
  .input(Alert)
  .step("triage", oncall.duties.triage)
  .delegate("findings", (alert) =>
    ["app","db","network"].map((area) => investigate.duties.scan.with({ alert, area })),
  )                                   // parallel sub-agents — durable & governed
  .step("diagnose", oncall.duties.diagnose, (s) => ({ findings: s.findings }))
  .approval("on-call")
  .step("remediate", oncall.duties.remediate)
  .commit()

const remediationGate = policy({
  id: "remediation-needs-approval",
  applies: { duty: "oncall.remediate" },
  check: ({ state }) =>
    state.remediate.destructive
      ? { effect: "approval", reason: "Destructive remediation needs approval" }
      : { effect: "allow" },
})

runtime({ policies: [remediationGate] })   // applies to every agent — no one can forget it

workflow("remediate")
  .step("plan", oncall.duties.plan)
  .approval("on-call")                     // pauses → waits in the approvals inbox
  .step("apply", oncall.duties.apply)
  .commit()

await rt.resume(runId, "on-call", { by: "kc@kc.io", decision: "approve" })

const otto = rt.agent("oncall")   // every agent is addressable, always on

// talk to it — its typed duties run underneath the conversation
await otto.say("why is checkout slow right now?")

// it can open the thread itself — proactive, on its own triggers
await otto.notify("on-call", "p99 is climbing on checkout — I'd roll back 4f2a.")

// a destructive step surfaces as an approval *in the same thread*,
// admission-checked like any other step — reply to resume the run

const [diagnosis, signals, logs] = await ctx.delegate([
  k8s.duties.diagnose(a),
  metrics.duties.analyze(a),
  logs.duties.scan(a),
])   // parallel sub-agents — durable, governed, gathered

const recentDeploys = tool({
  input: z.object({ ns: z.string() }),
  run: (a) => kube.deploys(a.ns),     // server-side, validated I/O
})
// the engine calls it; the runtime admits & journals every invocation

// shape what the model reasons over, mid-loop
ctx.context.pin(runbook)                                   // keep all run
const hits = await ctx.context.recall("past p99 incidents", { topK: 5 })
ctx.context.compact({ olderThan: 12 })                    // summarize old steps
ctx.context.drop("raw.logs")                              // evict noisy output

agentist({
  context: {
    budget:  "32k",                 // token budget for the window
    include: [charter, runbooks],   // always in context
    compact: "summarize",           // when it fills, summarize the oldest
  },
})

import { runtime } from "@agentist/sdk"
import { adk } from "@agentist/engine-adk"   // also: langgraph · autogen · crewai

runtime({ engine: adk() })   // ADK reasons; the runtime governs every call

import { runtime } from "@agentist/sdk"
import { agentist } from "@agentist/engine"

runtime({ engine: agentist() })   // typed reasoning, governed end to end

rt.mcp({ port: 8080 })                     // every agent → an MCP tool
oncall.a2a()                               // expose as an A2A server (Agent Card)
const peer = a2a("https://acme.dev/sre")   // consume an external A2A agent

const rt = runtime({
  store:     postgres(process.env.DATABASE_URL),  // durable, resumable state
  llm:       anthropic("claude-sonnet"),          // default model
  policies:  [remediationGate],                   // admission control — runs before every step
  memory:    pgvector(),                           // scoped, per-tenant recall
  isolation: "container",                          // sandbox each agent
  audit:     true,                                 // OpenTelemetry + replayable log
})

rt.register(oncall, incident)
rt.serve()   // exposes the API, MCP, and the scheduler

agentist dev          # runtime + console at localhost:3000

const rt = runtime({ store: postgres(process.env.DATABASE_URL) })
// crash mid-run? it resumes from the last journaled step —
await rt.resume(runId)        // exactly once, on any worker

const gate = policy({
  applies: { duty: "oncall.remediate" },
  check: (a, ctx) => a.sev === "1"
    ? ctx.approval("on-call")   // pause for a human
    : ctx.allow(),              // otherwise admit
})

runtime({ isolation: "microvm" })  // process · container · microvm
// per-agent sandbox; the runtime holds secrets, never the agent

runtime({ workers: { min: 2, max: 50, scaleOn: "queueDepth" } })
// stateless workers lease a durable queue — add more to scale

runtime({ audit: true })       // OTel spans + append-only journal
const out = await rt.replay(seq)   // re-issue the exact call
// same input, model & route — diff vs what was captured

await ctx.state.put("incident.severity", "sev1")   // per-run, journaled
const sev = await ctx.state.get("incident.severity")

rt.cron("0 9 * * 1", weekly.report)    // schedule
rt.on("deploy.failed", oncall.triage)  // internal event
rt.serve()   // + webhooks, API & MCP — all idempotency-keyed

const oncall = agent({
  id: "oncall",
  model: "claude-sonnet",                            // default for this agent
  duties: {
    triage:   duty({ model: "claude-haiku", /* … */ }),   // fast & cheap
    diagnose: duty({ model: "claude-opus",  /* … */ }),   // deep reasoning
  },
})
// gateway maps models per cloud: AWS→Bedrock · GCP→Vertex · Azure→OpenAI · bare-metal→vLLM

// one typed input contract — a single field is positional on the CLI
const triage = duty({ input: z.object({ prompt: z.string() }), /* … */ })

// HUMAN · CLI — the prompt is the default; no flag needed
//   agentist run oncall.triage "checkout p99 latency is 5s"

// AGENT → AGENT — typed, traced across agents
const out = await triage.with({ prompt: "checkout p99 5s" })

// API · SDK — same contract, over the network
const run = await client.run(oncall.triage, { prompt: "checkout p99 5s" })
//   POST /v1/runs/oncall.triage   { "prompt": "checkout p99 5s" }

// MCP — the schema is the tool; expose every agent
rt.mcp({ port: 8080 })

import { stack, gateway, models, vectors, postgres, image } from "@agentist/infra"
import { bedrock } from "@agentist/infra/aws"

export default stack({
  target: "k8s",                          // the universal substrate
  store:  postgres({ instance: "db.r6g.large" }),
  models: [
    models.serve("llama-3.1-70b", {
      gpu: "H100:2",                      // multi-GPU, tensor-parallel
      image: image.vllm("0.6.3"),         // the serving image, in code
      autoscale: { min: 0, max: 8, scaledown: "60s" },   // scale-to-zero
      concurrency: 32,                    // inputs in flight per replica
      snapshot: true,                     // GPU snapshot → seconds-cold-start
    }),
    models.bind(bedrock("claude-sonnet-4")),   // or bind your cloud's
  ],
  gateway:   gateway({ egress: "deny", redactPII: true }),
  vectors:   vectors.pgvector(),
  sandboxes: { isolation: "microvm", idleTimeout: "5m" },
})
//   agentist deploy --to your-cluster   # your cloud or ours, same code

import platform from "./stack"     // the typed infra definition
await platform.plan()              // show the diff first
const out = await platform.apply() // incremental & reversible

// the stack's typed outputs wire straight into the runtime
runtime({ store: out.store, llm: out.models.claude })

models.serve("llama-3.1-70b", {
  gpu: "H100:2", cpu: 8, memory: "32Gi",   // per-workload resources
  autoscale: { min: 0, max: 8, scaledown: "60s" },
  concurrency: 32,                          // inputs in flight / replica
  batch: { maxSize: 16, window: "10ms" },   // dynamic batching
  snapshot: true,                           // seconds-cold-start
})

const env = image
  .debianSlim()
  .apt("git", "ffmpeg")
  .pip("vllm==0.6.3", "transformers")
  .run("python -m warm_cache")     // build-time step, cached layer

// self-host on your GPUs — OpenAI-compatible endpoint
const llama  = models.serve("llama-3.1-70b", { gpu: "H100" })
// or bind your cloud's hosted model — no servers to run
const claude = models.bind(bedrock("claude-sonnet-4"))

const box = await sandbox.create({ image: env, isolation: "microvm" })
const { stdout, exitCode } = await box.exec("python solve.py")
await box.snapshot("checkpoint")   // pause & resume later
await box.terminate()

// map a function across a collection — data parallelism on the worker pool
const vectors = await job.map(corpus, embed)   // 10k docs, results gathered
// or long-running work, collected later
const handle  = await job.spawn(nightlyBackfill)

stack({
  store:   rds("agentist-prod"),   // or cloudSql() · alloyDb() · a URL
  storage: s3("artifacts"),         // or gcs() · azureBlob() · minio()
  secrets: awsSecrets(),            // or vault() · gcpSecrets()
})

agentist deploy --plan          # dry-run: show the diff first
agentist deploy --to prod       # compile → apply to your cluster
agentist deploy --to air-gapped --offline

# deploy to any cloud, then connect Agentist
agentist deploy --target k8s
agentist cloud connect

agentist deploy --target eks \
  --set postgres.url=$RDS_URL \
  --set objectStore=s3://acme-agentist \
  --set gateway.models=bedrock          # Claude on Bedrock

agentist deploy --target gke \
  --set postgres.url=$CLOUDSQL_URL \
  --set objectStore=gs://acme-agentist \
  --set gateway.models=vertex           # Claude / Gemini on Vertex

agentist deploy --target aks \
  --set postgres.url=$AZURE_PG_URL \
  --set objectStore=az://acme-agentist \
  --set gateway.models=azure-openai

agentist deploy --target doks \
  --set postgres.url=$DO_PG_URL \
  --set objectStore=spaces://acme-agentist \
  --set gateway.models=anthropic

agentist deploy --target k8s \
  --set postgres.url=$PG_URL \
  --set objectStore=minio://agentist \
  --set gateway.models=vllm \
  --set airgapped=true

# primary cloud + burst targets — one fleet
agentist deploy --target eks --set primary=true
agentist cloud burst add --target gke --gpu
agentist cloud burst add --target k8s --models=vllm

runtime({ store: postgres(process.env.DATABASE_URL) })
// event-sourced: state, journal & vectors in one database
// SQLite for local dev · Redis for queues

await ctx.memory.put("user.tier", "enterprise")   // working memory
const tier = await ctx.memory.get("user.tier")
const hits = await ctx.memory.search("past incidents", { topK: 5 })

const kb = retrieval({
  chunk:  { strategy: "recursive", size: 800, overlap: 100 },
  embed:  "text-embedding-3-large",
  store:  vectors.pgvector(),
  rerank: "rerank-v3",                  // precision pass before the model
})
await kb.add(docs)
const hits = await kb.query("why did checkout fail?", { topK: 8 })

const v = vectors.pgvector()           // or pinecone() · qdrant()
await v.query(embedding, {
  topK: 10,
  filter: { tenant: "acme", kind: "runbook" },   // metadata filter
})

const bucket = storage(s3("artifacts"))   // or gcs · azureBlob · minio
await bucket.put(`runs/${runId}/report.pdf`, bytes)
const url = await bucket.signedUrl(key, { expires: "1h" })

// src/incident.ts — Otto, the on-call SRE: triage → investigate → fix, one file.
import { agent, duty, tool, workflow, policy, charter, harness, runtime, postgres } from "@agentist/sdk"
import { agentist } from "@agentist/engine"
import { stack, gateway, vectors } from "@agentist/infra"
import { bedrock } from "@agentist/infra/aws"
import { z } from "zod"

// ── Charter — the culture every agent inherits ───────────────────────────
const acme = charter({
  mission: "Keep systems reliable and customer trust intact.",
  values: ["Bias to safety", "Explain your reasoning", "Escalate when unsure"],
})

// ── Schemas ───────────────────────────────────────────────────────────────
const Alert = z.object({ service: z.string(), symptom: z.string(), severity: z.enum(["sev1","sev2","sev3"]) })

// ── Tools — server-side & validated; the agent never sees a credential ──
const queryMetrics = tool({
  input:  z.object({ service: z.string(), window: z.string().default("30m") }),
  output: z.object({ p99: z.number(), errorRate: z.number() }),
  run: (a, ctx) => ctx.tool("prometheus.query", a),          // via the egress gateway
})
const rollback = tool({
  input: z.object({ deploy: z.string() }),
  meta:  { destructive: true },                              // surfaced to admission control
  run: (a, ctx) => ctx.tool("k8s.rollback", a),
})

// ── Investigator — one cheap agent, fanned out across subsystems ─────────
const investigate = agent({
  id: "investigate",
  identity: { name: "Iris", role: "Investigator", persona: "Methodical, fast." },
  charter: acme,
  tools: [queryMetrics],
  duties: {
    scan: duty({
      input:  z.object({ alert: Alert, area: z.enum(["app","db","network"]) }),
      output: z.object({ area: z.string(), finding: z.string() }),
      run: (a, ctx) => ctx.llm({ prompt: `Inspect ${a.area} for ${a.alert.symptom}` }),
    }),
  },
})

// ── Otto — the on-call SRE, extends a base harness ───────────────────────
export const oncall = agent({
  extends: harness("on-call"),           // reusable SRE preset — extend, don't rebuild
  id: "oncall",
  identity: { name: "Otto", role: "On-call SRE", persona: "Calm, terse, evidence-driven." },
  charter: acme,
  tools: [queryMetrics, rollback],
  duties: {
    triage: duty({
      input:  Alert,
      output: z.object({ summary: z.string() }),
      run: async (a, ctx) => {
        await ctx.context.recall("past incidents on " + a.service, { topK: 5 })   // remember
        return ctx.llm({ prompt: `Triage: ${a.symptom}` })
      },
    }),
    diagnose: duty({
      input:  z.object({ findings: z.array(z.object({ area: z.string(), finding: z.string() })) }),
      output: z.object({ rootCause: z.string(), destructive: z.boolean() }),
      run: (a, ctx) => ctx.llm({ prompt: `Root cause from: ${JSON.stringify(a.findings)}` }),
    }),
    remediate: duty({
      input: z.object({ rootCause: z.string() }),
      run: (a, ctx) => ctx.tool("k8s.rollback", { deploy: "latest" }),
    }),
  },
})

// ── Policy — admission control: destructive fixes wait for a human ───────
const remediationGate = policy({
  id: "remediation-needs-approval",
  applies: { duty: "oncall.remediate" },
  check: ({ state }) => state.diagnose.destructive
    ? { effect: "approval", reason: "Destructive remediation needs approval" }
    : { effect: "allow" },
})

// ── Workflow — the typed path an incident takes ──────────────────────────
export const incident = workflow("incident")
  .input(Alert)
  .step("triage", oncall.duties.triage)
  .delegate("findings", (alert) =>
    ["app","db","network"].map((area) => investigate.duties.scan.with({ alert, area })),
  )                                      // parallel sub-agents — durable & governed
  .step("diagnose", oncall.duties.diagnose, (s) => ({ findings: s.findings }))
  .approval("on-call")                   // only fires when remediationGate demands it
  .step("remediate", oncall.duties.remediate)
  .commit()

// ── Infrastructure — provision the platform into your own cloud (IaC) ─────
const infra = stack({
  target:  "k8s",
  store:   postgres({ instance: "db.r6g.large" }),
  models:  [bedrock("claude-sonnet-4")],
  gateway: gateway({ egress: "deny", redactPII: true }),
  vectors: vectors.pgvector(),
})

// ── Runtime — engine + governance, wired to the infra above ──────────────
const rt = runtime({
  engine:   agentist(),                  // or adk() · langgraph()
  store:    infra.store,
  llm:      infra.models.claude,
  policies: [remediationGate],
  memory:   infra.vectors,
})
rt.register(oncall, investigate, incident)
rt.on("deploy.failed", oncall.duties.triage)   // page Otto on a failed rollout
rt.serve()                               // API · MCP · the Console
//   agentist deploy --to your-cluster      # provisions infra + rolls out the runtime

// src/analyst.ts — Dana, the data analyst: ask in English, get a governed answer.
import { agent, duty, tool, workflow, policy, charter, runtime, postgres } from "@agentist/sdk"
import { agentist } from "@agentist/engine"
import { stack, gateway } from "@agentist/infra"
import { bedrock } from "@agentist/infra/aws"
import { z } from "zod"

const acme = charter({
  mission: "Keep systems reliable and customer trust intact.",
  values: ["Show your work", "Cite the query", "Never guess at a number"],
})

// ── Tool — read-only SQL, executed server-side through the data gateway ──
const runSql = tool({
  input:  z.object({ sql: z.string() }),
  output: z.array(z.record(z.any())),
  meta:   { readOnly: true },                  // surfaced to admission control
  run: (a, ctx) => ctx.db.query(a.sql),        // PII redacted at the gateway
})

// ── Agent — turns a question into SQL, then reads the result back ────────
export const dana = agent({
  id: "analyst",
  identity: { name: "Dana", role: "Data analyst", persona: "Precise; cites the query." },
  charter: acme,
  tools: [runSql],
  duties: {
    plan: duty({
      input:  z.object({ question: z.string() }),
      output: z.object({ sql: z.string() }),
      run: (a, ctx) => ctx.llm({ prompt: `Write read-only SQL for: ${a.question}` }),
    }),
    explain: duty({
      input:  z.object({ rows: z.array(z.record(z.any())) }),
      output: z.object({ answer: z.string() }),
      run: (a, ctx) => ctx.llm({ prompt: `Summarize these rows: ${JSON.stringify(a.rows)}` }),
    }),
  },
})

// ── Policy — the analyst is read-only by construction; writes can't happen ─
const readOnly = policy({
  id: "analyst-read-only",
  applies: { tool: "*" },
  check: ({ tool }) => tool.meta.readOnly
    ? { effect: "allow" }
    : { effect: "deny", reason: "Analyst is read-only" },
})

// ── Workflow — plan → critic vets the SQL → run → explain ────────────────
export const ask = workflow("ask")
  .input(z.object({ question: z.string() }))
  .step("plan", dana.duties.plan)
  .critic("sql-safe", (s) => `Is this SQL read-only and correct? ${s.plan.sql}`)
  .step("run", runSql, (s) => ({ sql: s.plan.sql }))
  .step("explain", dana.duties.explain, (s) => ({ rows: s.run }))
  .commit()

const infra = stack({
  target:  "k8s",
  store:   postgres({ instance: "db.r6g.large" }),
  models:  [bedrock("claude-sonnet-4")],
  gateway: gateway({ egress: "deny", redactPII: true }),
})

const rt = runtime({
  engine:   agentist(),
  store:    infra.store,
  llm:      infra.models.claude,
  policies: [readOnly],
})
rt.register(dana, ask)
rt.serve()                               // ask it in the Console, or over MCP

// src/review.ts — Rex, the code reviewer: tests run in a sandbox before review.
import { agent, duty, tool, workflow, charter, runtime, postgres } from "@agentist/sdk"
import { agentist } from "@agentist/engine"
import { stack, gateway, sandbox } from "@agentist/infra"
import { bedrock } from "@agentist/infra/aws"
import { z } from "zod"

const acme = charter({
  mission: "Keep systems reliable and customer trust intact.",
  values: ["Evidence over opinion", "Be specific", "Be kind"],
})

const PR = z.object({ repo: z.string(), number: z.number(), sha: z.string() })

// ── Tool — run the PR's tests in a fresh microVM; nothing lingers ────────
const runTests = tool({
  input:  PR,
  output: z.object({ pr: PR, passed: z.boolean(), log: z.string() }),
  run: async (a, ctx) => {
    const box = await sandbox.create({ image: "node:20", isolation: "microvm" })
    await box.exec(`git clone ${a.repo} app && cd app && git checkout ${a.sha}`)
    const { exitCode, stdout } = await box.exec("cd app && npm ci && npm test")
    await box.terminate()                      // ephemeral — auto-cleaned regardless
    return { pr: a, passed: exitCode === 0, log: stdout }
  },
})

// ── Agent — reviews the diff, and posts the verdict back to GitHub ───────
export const rex = agent({
  id: "reviewer",
  identity: { name: "Rex", role: "Code reviewer", persona: "Terse, specific, kind." },
  charter: acme,
  tools: [runTests],
  duties: {
    review: duty({
      input:  z.object({ pr: PR, tests: z.object({ passed: z.boolean(), log: z.string() }) }),
      output: z.object({ verdict: z.enum(["approve", "request-changes"]), notes: z.string() }),
      run: async (a, ctx) => {
        const r = await ctx.llm({ prompt: `Review PR #${a.pr.number}; tests: ${a.tests.log}` })
        await ctx.tool("github.comment", { ...a.pr, body: r.notes })   // post via MCP tool
        return r
      },
    }),
  },
})

// ── Workflow — test in isolation, then review ────────────────────────────
export const reviewPR = workflow("review-pr")
  .input(PR)
  .step("tests", runTests)
  .step("review", rex.duties.review, (s) => ({ pr: s.tests.pr, tests: s.tests }))
  .commit()

const infra = stack({
  target:  "k8s",
  store:   postgres({ instance: "db.r6g.large" }),
  models:  [bedrock("claude-sonnet-4")],
  gateway: gateway({ egress: "deny" }),        // the sandbox reaches the net only through here
})

const rt = runtime({ engine: agentist(), store: infra.store, llm: infra.models.claude })
rt.mcp({ consume: ["github"] })                // GitHub's MCP server → agent tools
rt.register(rex, reviewPR)
rt.on("github.pull_request.opened", reviewPR)  // webhook → typed, governed run
rt.serve()

// src/docs.ts — Quinn, the knowledge assistant: grounded answers, with citations.
import { agent, duty, charter, runtime, postgres } from "@agentist/sdk"
import { agentist } from "@agentist/engine"
import { stack, gateway, vectors, retrieval } from "@agentist/infra"
import { bedrock } from "@agentist/infra/aws"
import { z } from "zod"

const acme = charter({
  mission: "Keep systems reliable and customer trust intact.",
  values: ["Cite your sources", "Say 'I don't know'", "Never invent an answer"],
})

// ── Retrieval — chunk, embed & index your docs into pgvector ────────────
const kb = retrieval({
  chunk:  { strategy: "recursive", size: 800, overlap: 100 },
  embed:  "text-embedding-3-large",
  store:  vectors.pgvector(),
  rerank: "rerank-v3",                         // precision pass before the model
})

// ── Agent — grounded Q&A; answers only from what it retrieved ───────────
export const quinn = agent({
  id: "docs",
  identity: { name: "Quinn", role: "Knowledge assistant", persona: "Helpful, grounded, honest." },
  charter: acme,
  duties: {
    answer: duty({
      input:  z.object({ question: z.string() }),
      output: z.object({ answer: z.string(), sources: z.array(z.string()) }),
      run: async (a, ctx) => {
        const hits = await kb.query(a.question, { topK: 8 })   // hybrid search + rerank
        return ctx.llm({ prompt: a.question, ground: hits })   // answer only from sources
      },
    }),
  },
})

const infra = stack({
  target:  "k8s",
  store:   postgres({ instance: "db.r6g.large" }),
  models:  [bedrock("claude-sonnet-4")],
  gateway: gateway({ egress: "deny" }),
  vectors: vectors.pgvector(),
})

const rt = runtime({
  engine: agentist(),
  store:  infra.store,
  llm:    infra.models.claude,
  memory: infra.vectors,
})
rt.register(quinn)
await kb.add("./docs/**/*.md")           // ingest once; re-runs are incremental

const q = rt.agent("docs")               // every agent is addressable & always-on
await q.ask("how do I rotate the gateway's signing key?")
rt.serve()                               // Console chat · Slack · MCP

// src/audit.ts — Cass, the cost auditor: every night, flag over-provisioned services.
import { agent, duty, tool, workflow, charter, runtime, postgres } from "@agentist/sdk"
import { agentist } from "@agentist/engine"
import { stack, gateway } from "@agentist/infra"
import { bedrock } from "@agentist/infra/aws"
import { z } from "zod"

const acme = charter({
  mission: "Keep systems reliable and customer trust intact.",
  values: ["Bias to safety", "Show the numbers", "No false alarms"],
})

const Service = z.object({ name: z.string(), monthlySpend: z.number() })

// ── Tools — pull the catalog & post the report (external, via connectors) ─
const listServices = tool({
  input:  z.object({}),
  output: z.object({ services: z.array(Service) }),
  run: (a, ctx) => ctx.tool("billing.services", {}),
})
const postReport = tool({
  input: z.object({ findings: z.array(z.any()) }),
  run: (a, ctx) => ctx.tool("slack.post", { channel: "#finops", ...a }),
})

// ── Agent — judges one service against its utilization ───────────────────
export const cass = agent({
  id: "auditor",
  identity: { name: "Cass", role: "Cost auditor", persona: "Skeptical, exact." },
  charter: acme,
  duties: {
    audit: duty({
      input:  Service,
      output: z.object({ service: z.string(), wasteUsd: z.number(), reason: z.string() }),
      run: async (a, ctx) => {
        const util = await ctx.tool("prometheus.query", { service: a.name })
        return ctx.llm({ prompt: `Is ${a.name} over-provisioned? util=${JSON.stringify(util)}` })
      },
    }),
  },
})

// ── Workflow — catalog → audit all in parallel → critic → report ─────────
export const nightly = workflow("nightly-audit")
  .input(z.object({}))
  .step("catalog", listServices)
  .delegate("findings", (s) =>                 // every service, in parallel — durable & governed
    s.catalog.services.map((svc) => cass.duties.audit.with(svc)))
  .critic("no-false-alarms", (s) =>            // drop flags the evidence doesn't support
    `Are these waste flags justified? ${JSON.stringify(s.findings)}`)
  .step("report", postReport, (s) => ({ findings: s.findings }))
  .commit()

const infra = stack({
  target:  "k8s",
  store:   postgres({ instance: "db.r6g.large" }),
  models:  [bedrock("claude-haiku-4")],        // cheap model — it's a big nightly batch
  gateway: gateway({ egress: "deny" }),
})

const rt = runtime({ engine: agentist(), store: infra.store, llm: infra.models.claude })
rt.register(cass, nightly)
rt.cron("0 6 * * *", nightly)            // 6am daily — timezone-aware, with a missed-run policy
rt.serve()

agentist init <name>                    # scaffold a project
agentist dev                           # local runtime + console :3000
agentist run <agent.duty> "<prompt>"   # positional prompt (default); --json for typed input
agentist deploy --target k8s|docker    # deploy runtime + manifest
agentist cloud connect                 # plug in Agentist Cloud
agentist logs <run>                     # tail a run
agentist rollback <agent> <version>     # roll back a version
agentist secrets set <key>             # manage secrets