Products

Products built from production experience.

Each product began as a solution to a challenge we encountered repeatedly in production systems, and each is built and used by our own engineers. Every product ships with the Curo standard built in: a named owner, earned autonomy, and a replayable audit trail.

Sovereign & governed AI · our newest AI products

Adamant

In development

Sovereign AI platform: private, air-gapped AI that runs entirely on your own infrastructure.

Adamant turns servers you own into a governed AI environment, with no connection to the internet at install or at run time. It ships as one signed offline bundle: hardened Kubernetes, GPU enablement, open-weight models behind an OpenAI-compatible API, document search with cited answers, and an agent runtime whose every tool call is checked against policy. Single sign-on, role-based access and deny-all outbound networking are on by default, and every exchange is sealed by the AI Decision Recorder.

DEPLOYS — on your own servers, fully air-gapped · signed offline updates · WORKS WITH — NVIDIA GPUs, Kubernetes, LDAP, SAML and OIDC directories.

Offline by design — one signed bundle, no internet at install or run time
Open models, private API — OpenAI-compatible, on your own GPUs
Cited answers — document search that respects existing permissions
Governed agents — every tool call checked against policy
Provable boundaries — deny-all egress and a full usage audit

Curo / AI Decision Recorder

In development

A tamper-proof, replayable record of every AI decision, built for regulators and auditors.

The AI Decision Recorder captures each AI decision as it happens: the model and version, the instructions, the documents and tools used, the policy applied and who approved it. Records are sealed in a hash chain with signed checkpoints, so any alteration is detectable, and kept on write-once storage under your retention rules. Any decision can be rebuilt as a complete case file, and an open-source verifier lets auditors check integrity without Curo software.

DEPLOYS — self-hosted or air-gapped · drop-in proxy or Python SDK · WORKS WITH — OpenAI-compatible model APIs, MCP tools, OpenTelemetry.

Capture without rewrites — drop-in proxy, SDK and tool-call capture
Tamper-evident — hash chains and signed, timestamped checkpoints
Case files on demand — rebuild any decision end to end
Independent verification — an open-source verifier for auditors
Privacy-aware — per-person encryption; erasure without breaking the record

Curo / Agent Proving Ground

Research

Rehearse AI agents in a simulated copy of your business before they go live.

Agent Proving Ground runs an agent through thousands of realistic scenarios against simulated versions of your systems, with synthetic customers, system failures and adversarial attempts, before it touches anything real. Each agent version receives a readiness report and a recommended level of autonomy, backed by evidence.

ORIGIN — the testing discipline behind the Curo standard of earned autonomy.

Simulated systems — stateful mocks of CRM, ERP, ticketing and payments
Synthetic users — personas from routine to adversarial
Readiness reports — pass rates, worst failures and regressions
Release gate — blocks versions that regress on critical scenarios

Curo / Agent Gateway

Research

A secure front door for the AI agents your customers send to do business with you.

Agent Gateway lets outside AI agents act for your customers safely. It verifies which agent is calling and whom it represents, applies the limits the customer has consented to, completes the transaction through your existing systems, and records every action.

ORIGIN — the Curo permission and audit framework, applied to inbound agent traffic.

Verified agents — the agent and the customer behind it
Delegated consent — spending and action limits set by the customer
Policy and abuse controls — rate limits, step-up confirmation, fraud detection
Full record — every agent transaction kept as evidence

Curo / Expertise Capture

Research

Turns your senior experts' unwritten know-how into supervised AI skills.

Expertise Capture interviews experienced staff through structured sessions and real case walk-throughs, turns what they know into reusable skills, and returns every skill to the expert for review and approval before anyone relies on it. Approved skills guide new staff and Curo agents, with the source credited.

ORIGIN — a research program alongside our Enterprise AI Solutions practice.

Guided interviews — case-based sessions, by voice or text
Expert approval — nothing is used until the expert signs off
Provenance — every skill traced to its source
For people and agents — guidance for staff, tools for agents

Curo / Agent Risk Rating

Research

An independent risk score and certificate for every AI agent.

Agent Risk Rating assesses any agent, from any vendor, against a published methodology: what it can touch and spend, how it behaves under test and in production, and which controls surround it. The grade follows the weakest critical area, updates as the agent changes, and comes with a specific improvement plan.

ORIGIN — a research program alongside our Security & AI Governance practice.

Evidence-based — test and production records, not questionnaires alone
Weakest-link grading — one serious gap cannot hide
Continuous re-rating — grades update when the agent changes
Improvement plan — the specific changes that raise the grade

AI agents & assistants · from our AI practice

Curo / Keeper

Early access

The autonomous SRE agent for continuous, supervised Kubernetes operations.

Keeper follows the same loop as your on-call engineers (observe, reason, plan, act, and verify) across every registered cluster simultaneously. It predicts incidents before they occur, correlates them with recent changes, resolves low-risk issues automatically, routes higher-risk actions for human approval, verifies every fix by re-observing the cluster, and rolls back automatically if a change causes a regression. Every cycle is recorded in an audit trail, and every rollback generates a postmortem.

ORIGIN — the Curo standard implemented in code: people approve critical actions, and the agent is accountable for the rest. From the Latin cūrō, “I take care of it.”

Predicts with lead time — node pressure, crashloop trends, scheduling risk
Graduated autonomy — full-auto in dev, approval-gated in production
Closed-loop remediation — verified fixes, auto-rollback on regression
Learns per issue — prefers proven fixes, escalates recurring failures
Human-on-the-loop ChatOps — Slack / Teams approvals, ROI metrics, auto-postmortems

Curo / Reconciler

Early access

Autonomous exception resolution for finance operations.

Reconciler operates across your systems of record, including ledgers, banks, payment processors, and ERPs. It matches the records that agree and investigates those that do not. The agent resolves routine breaks itself and queues decisions that require judgment for a person, with the full evidence attached.

ORIGIN — built for the exception queues of payments and settlement operations.

Matches across systems — n-way reconciliation, not just A-to-B
Closes routine exceptions — supervised at first, autonomous with a track record
Human review for judgment calls — evidence assembled, decision retained by your team
Replayable audit — every action logged, every close explainable

Curo / Knowledge Assistant

In development

Answers from your company's knowledge, with the source for every answer.

Knowledge Assistant answers questions from your own contracts, policies, tickets, and wikis rather than the internet. Every answer cites the document and passage it came from, so people can verify it before acting, and when your sources do not support an answer, it says so rather than guessing. It respects your existing permissions: users receive answers only from documents they are authorized to access.

ORIGIN — our Enterprise AI Solutions practice, packaged as a product.

Cited answers — every claim linked to its source passage
Permission-aware — answers only from documents the user can open
Acknowledges uncertainty — “not in your documents” instead of a guess
Measured quality — tested against the questions your teams actually ask

Curo / Support Agent

In development

Resolves customer tickets end to end, and escalates when it should.

Support Agent reads each ticket, finds the answer in your knowledge base and account systems, and resolves what it can, including answers, refunds within policy, and account changes. Anything outside policy or below its confidence threshold is handed to a person with the full context already summarized. Like every Curo agent, it starts under supervision and earns autonomy one ticket type at a time.

ORIGIN — our Autonomous AI Agents practice, packaged as a product.

End-to-end resolution — answers and actions, not just suggested replies
Policy limits — refunds, credits, and changes only within your rules
Structured handover — escalations arrive with a summary and the evidence
Earned autonomy — supervised first, widened per ticket type

Curo / Document AI

In development

Automated extraction, classification, and routing for business documents.

Document AI reads invoices, contracts, claims, and forms, pulls out the fields that matter, classifies each document, and routes it into the right system or queue. Low-confidence fields are flagged for human review rather than passed through unchecked. Every extracted value links back to where it appears on the page.

ORIGIN — the document intelligence work in our Enterprise AI Solutions practice.

Extraction — the fields that matter, from clean and messy documents
Classification & routing — into the right system, queue, or person
Confidence-based review — people review only low-confidence fields
Traceable — every value linked to its place in the source

Curo / Warden

In development

The governance layer for autonomous agents, from any vendor.

Warden is the Curo standard delivered as software: permission boundaries agents cannot cross, a replayable log of every action, staged autonomy that is earned rather than assumed, and a reliable kill-switch. For any organization running agents, Warden answers the auditor's essential question: <em>who authorized this action?</em>

ORIGIN — the permissioning and audit framework built inside every Curo agent engagement.

Permission boundaries — what an agent may touch, spend, and send
Replayable action log — every action, with full context
Staged autonomy — supervised → assisted → autonomous, by evidence
Compliance evidence — audit-ready reports, not screenshots

Curo / AI Evaluation

In development

Verifies AI quality before changes reach your users.

AI Evaluation tests your copilots, agents, and retrieval systems against the questions and tasks your users actually bring, on every change. It scores answer quality, catches regressions, and tracks cost and latency, so every model or prompt change is released with evidence. Results are kept over time, so you can show exactly when quality moved and why.

ORIGIN — the evaluation discipline behind every AI system we build.

Real-world test sets — built from your users' actual questions
Regression checks — on every model, prompt, or data change
Cost & latency budgets — tracked alongside quality
Evidence over time — a history you can show a reviewer

Curo / Runbook

Research

Turns your operational runbooks into supervised automations.

Most operations teams maintain runbooks that engineers execute manually, often under pressure during incidents. Runbook reads them and executes them step by step under human supervision. Once a procedure has a proven track record, Runbook runs it autonomously and involves a person only at decision points.

ORIGIN — a research program alongside our Operate practice.

Reads your existing runbooks — no migration project
Executes with supervision — a human approves each step, then each run
Earned autonomy — granted per procedure, based on track record

Platforms · Kubernetes & infrastructure operations

KubeMaestro

Early access

Enterprise multi-cluster operations platform for Kubernetes.

KubeMaestro lets teams operate Kubernetes without the command line. Create clusters on bare metal, VMs, or the cloud (EKS, AKS, GKE), manage multi-OS worker nodes, install Helm charts, stream logs and shells, and handle backup and disaster recovery, all from one no-code dashboard.

DEPLOYS — desktop app or self-hosted · WORKS WITH — minikube, kubeadm, EKS, AKS, GKE, OpenShift.

No-code cluster creation — bare metal, VMs, EKS / AKS / GKE
Unified multi-cluster dashboard — YAML editor, port-forward, scaling
Helm & workloads — install, upgrade, rollback; live logs and in-container shell
Audit trail — every action taken in KubeMaestro, searchable
Backup & disaster recovery — scheduled backups, restore with namespace mapping

CmdGrid

Early access

One control plane for all your infrastructure automation.

CmdGrid orchestrates Ansible, Terraform, and more from a single interface. Execute playbooks with live progress monitoring, manage Kubernetes across AWS, GCP, Azure, and on-prem, bind playbooks to roles, open interactive SSH terminals, and keep a comprehensive audit trail, with role-based access control and real-time updates built in.

DEPLOYS — self-hosted, Docker · WORKS WITH — Ansible, Terraform, AWS, GCP, Azure, on-premises.

Real-time Ansible execution — live progress, full run history
Role-based playbooks & RBAC — granular permissions per team
Multi-cluster Kubernetes — AWS, GCP, Azure, on-premises
Interactive SSH terminal — direct cluster access with audit logging

AirLift

Early access

Migrate, back up, and recover any Kubernetes workload — from a single binary.

AirLift moves a namespace, or an entire cluster, to any other cluster, backs up to S3, GCS, Azure, or local storage, and replicates continuously for async disaster recovery. Direct cluster-to-cluster streaming with no intermediate storage, AES-256-GCM encryption, and no agents to install. Available as a single binary or a GitOps Kubernetes operator. Migration and backup are free; continuous DR, compliance reporting, and enterprise support come with a paid plan.

DEPLOYS — single binary or Kubernetes operator · WORKS WITH — CSI VolumeSnapshots, Prometheus, Slack, Teams, PagerDuty.

Namespace & cluster migration — direct streaming, StorageClass & registry mapping
Backup anywhere — S3 / GCS / Azure / local / NFS, CSI snapshots
Continuous async DR — RPO tracking, failover and failback
Secure & auditable — AES-256-GCM, GFS retention, compliance reports
Pre-flight & rollback — validate before you migrate, roll back after

Curo / Witness

Early access

Real-time security detection, with audit evidence retained for the long term.

Witness is security monitoring and audit evidence for Kubernetes in one platform, running entirely inside your clusters — no SaaS, no internet. Agents on every node stream audit events, Kubernetes events, metrics, logs, and syslog to one server. A rule engine turns exec-into-pod, secret access, and RBAC changes into real-time incidents, and the same record is retained long after the cluster discards it, so <em>“who deleted that secret, when, and from which IP?”</em> can be answered in seconds, with a CSV export. Built for SOC 2, ISO 27001, and PCI evidence.

DEPLOYS — inside your clusters, an agent on every node · offline install bundle · TLS-encrypted agents · web console.

Real-time security incidents — exec-into-pod, secret access, RBAC changes
Who-did-what search — user, verb, resource, namespace, real source IP, result
Retention that outlives rotation — audit logs and events kept past their one-hour etcd expiry
One console — metrics, logs, events, and audit across every cluster
Alerts — Slack, webhook, email
Air-gapped by design — no SaaS, no internet required

Every product comes with an accountable owner.

  • A named engineer owns each deployment — our products encode the Curo standard rather than dilute it.
  • Autonomy is earned per customer, per workflow — no product is fully autonomous on day one.
  • Exit-ready by design — your data, your logs, exportable at any time.

Early access is deliberately limited.

Each product opens to a small number of teams at a time: enough to prove it in production, and few enough that every deployment has a dedicated owner. The software runs in real environments today. Features may still change, and rather than a support queue, you work directly with the engineer responsible for your deployment.

General availability follows once a product has established a production track record. If any of these challenges is consuming your team's time, contact us to discuss early access.