Agents, declared and versioned.

No agent without a descriptor. Every agent on the platform is a versioned YAML file in a Git-governed catalog — reviewed before it ships, resolvable to the exact version that ran.

Task mode — ShippedConversational mode — Beta

Request access

Descriptor as code

The descriptor is the agent

One file defines everything an agent is allowed to be. Nothing outside it can affect runtime behavior — which is why reviewing the file is reviewing the agent.

Model — pinned per agent — today claude-sonnet-4-6 via an AI gateway
System prompt & skills — versioned prompt plus reusable, versioned skill fragments
Tools with policies — every tool an MCP server, each with an allow/ask/deny policy
Typed I/O schemas — input and output validated — a schema violation is a hard failure
Budgets — max duration, tool calls and tokens — hard ceilings per run
Eval dataset & baseline — a versioned dataset and a baseline score that can only rise

aro.reconciliation-investigator.yaml

# catalogue/agents/aro.reconciliation-investigator.yaml
id: aro.reconciliation-investigator
version: 3
mode: task
model: claude-sonnet-4-6
required-role: ARO_ANALYST
tools:
  - platform.aro.get_break_detail    # allow
  - platform.aro.match_history       # allow
  - platform.aro.price_history_30d   # allow
output-schema: BreakAnalysis@v2
budgets:
  max-duration: 120s
  max-tool-calls: 12
  max-tokens: 60000
eval:
  dataset: evals/aro-recon@v3
  baseline: 0.74

Git-governed catalog

A catalog Git can prove

Agents, tools, skills, environments, bundles and eval datasets live in one Git repository. Review is the gate; history is the audit.

Pull-request review
Shipped
Every change to an agent, tool, skill or environment ships through PR review. Nothing off-catalog is callable, injectable or provisionable.
Catalog SHA per run
Shipped
Every run records the exact Git version of the catalog it executed — auditors reconstruct precisely which agent version produced any output.
A2A Agent Cards
Shipped
Each agent exposes standards-based capability metadata for discovery: GET /v1/agents/{id}/card.
Skills
Shipped
Versioned, reusable prompt fragments for cross-cutting behavior — error handling, citation format, escalation. Changing a skill re-triggers evals on every agent that declares it.
Tool bundles
Shipped
Immutable, date-versioned tool groupings (e.g. neoxam.core_20260501). Corrections publish a new dated bundle; migration is explicit and re-evaluated.
Agent families
Shipped
Product agents are families of small, scoped agents — roughly 15 tools each, one per feature area, routed by the product UI. Never one monolithic assistant.

Two modes

Task mode and conversational mode, one contract

Both modes run through the same Runner, the same policies and the same trace. The difference is state.

Task mode

Shipped

Stateless invocation by a business workflow: typed input in, schema-validated typed output back. Bounded duration and tool-call budget, no memory. The product consumes the result directly — root cause, verdict, recommended action — never free-form text a human must re-interpret.

→ submit a typed job over one stable API
→ follow live progress (SSE), cancel mid-run
→ schema violation = hard failure, never silent success

Conversational mode

Beta

Stateful multi-turn sessions embedded in product screens, with platform-managed memory — none, window or rolling summary, declared in the descriptor, never improvised by the agent. Responses stream live; history is archived; sessions survive worker crashes. First pilot: the DataHub assistant.

→ memory policy declared: none · window:N · summary
→ live-engine actions pause for confirmation (ask policy)
→ each turn is a run: traced, costed, audited

On the catalog today

The agent fleet, with its real status

We publish the maturity of every agent. Shipped agents run task mode end to end today; Beta agents are declared in the catalog and ship with the V1 milestone.

Agents in the NeoXam Agents catalog with product, mode, role and maturity status
Agent	Product	Mode	What it does	Status
aro.reconciliation-investigator	ARO	task	Investigates a reconciliation break; returns a structured BreakAnalysis: root cause, confidence, recommended action.	Shipped
dh-br-generator	DataHub	task	Generates a Business Rule expression from a plain-language spec, using the syntax dictionary and an examples corpus.	Shipped
dh-br-validator	DataHub	task	Validates a Business Rule: syntax, best-practice compliance, prioritized improvement plan.	Shipped
dh-br-evaluator	DataHub	task	Evaluates a rule against business assertions: pass/fail per assertion, coverage score, diagnostics.	Shipped
dh-br-tester	DataHub	task	Builds and runs a BRTU test suite: generates cases, schedules execution, reports results.	Shipped
dh-br-assistant	DataHub	chat	Interactive Business Rule expert in the authoring screen — draft, explain, validate, test through conversation.	Beta
datahub-assistant	DataHub	chat	Product assistant grounded in documentation and live configuration, with deep links to the exact screens.	Beta
agent-config-generator	Platform	task	Meta-agent that generates a valid agent descriptor from a natural-language description; powers the Quickstart wizard.	Beta

All shipped agents are pinned to claude-sonnet-4-6, role-gated (ARO_ANALYST, DH_DEVELOPER) and carry eval baselines between 0.70 and 0.80. Shipped V0 agents run on fixture-backed product connectors; live connectors land in Beta.

FAQ

Frequently asked questions

What exactly is an agent descriptor?

A versioned YAML and Markdown file that fully defines one agent: its model, system prompt, tools and their policies, skills, typed input and output schemas, budgets, eval dataset and required role. It is the agent's single source of truth — no runtime behavior exists outside it.

Can an agent run without being declared in the catalog?

No. The catalog-first integrity contract means nothing undeclared is callable, injectable or provisionable. Every agent enters the platform through a reviewed pull request, and every run records the catalog version (Git SHA) it executed.

What is the difference between task mode and conversational mode?

Task mode is a stateless invocation by a business workflow: typed input in, schema-validated typed output back, bounded duration and tool budget, no memory. It is shipped and running today. Conversational mode is a stateful multi-turn chat session with platform-managed memory and streamed responses, embedded in a product screen — it is in Beta.

Which model do agents run on?

The model is a field in each agent's descriptor, not an architectural commitment. Today all shipped agents run Anthropic Claude through an AI gateway. Switching or mixing providers is a configuration-and-re-evaluate operation; multiple providers live in production arrive at GA.

Can our own teams build agents?

Yes. Today an agent is declared as a descriptor in Git and shipped through PR review with eval gates. A Quickstart wizard, a templates gallery and a descriptor-generating meta-agent arrive with the Beta — the target is a product team shipping its first agent in under a day.

Keep exploring

More of the platform

General availability comes in Q3 2026. The Early Adopter Program is open now.

A limited cohort, a one-year platform trial and three workshop streams — Business ROI, Compliance, Operational fit. Bring one workflow; leave with a governed agent and the evidence to certify it.

Join the Early Adopter Program Talk to us

Agents, declared and versioned.

The descriptor is the agent

A catalog Git can prove

Pull-request review

Catalog SHA per run

A2A Agent Cards

Skills

Tool bundles

Agent families