AGENTS

Anyone can build an agent. We build the contract first.

Our agents do real work on your hardest documents and data. Each one is built on a contract that says what it does, what it may touch and who owns it, so your tenth agent works with the first instead of becoming the tenth silo.

An enterprise AI agent should be built on a contract: a named owner, a declared capability, inputs and outputs as schemas, permissions, versioned knowledge and an evaluation record. DataFactZ registers every agent this way so new agents compose with existing ones instead of becoming silos.

OUR AGENTS

Four agents, already doing the work.

Each agent is live on realistic sample data. Pick one, watch it work, then run it yourself.

Every agent runs in your cloud, on your data, with people approving what matters.

WHY OURS DON’T BECOME SILOS

Every agent built without a contract is a future integration project.

Nobody decides to build silos. They accumulate, one reasonable decision at a time, until the tenth agent costs what the first did.

  1. Month 1A team builds an agent for one job. It works. Everyone is delighted.
  2. Month 4Another team builds another. Its own prompts, its own credentials, its own idea of what a “policy” is.
  3. Month 9Nobody can say how many exist. None can call another. Each is its own security review.
  4. Month 18The tenth costs what the first did, and now there are ten things to maintain.

The day an agent needs one more call, say a new REST source:

  1. 01The requirement arrives: this agent now needs a REST source.
  2. 02Reopen the codebase. Write the call. Redeploy.
  3. 03A new outbound dependency, so a new security review.
  4. 04Regression-test everything it already did correctly.
  5. 05And the next request of the same kind starts over.
Built as a taskReopen the codebaseA redeploy, a security review and a regression test, every time.
  1. 01The contract already says sources are reached through adapters.
  2. 02Register the REST adapter. Point it at the endpoint.
  3. 03Permissions, audit and lineage inherit from the contract.
  4. 04Nothing that already worked was opened.
  5. 05And the next request of the same kind is the same shape.
Built as a contractRegister an adapterA configuration change. Permissions, audit and lineage come with it.
THE CONTRACT

An agent is a contract with an implementation behind it.

Before a line of code, every agent gets a contract. Fill it in for one agent and it is documentation. Fill it in for every agent and it is how they find and trust each other. We set up the same registry for your agents, in your cloud.

  • 01Declared, not implementedCapability, inputs, outputs, permissions and modes are stated in the contract before a line of code exists.
  • 02Knowledge outside the codeThe model, the dictionary and the rules live in documents your people own and edit, not in prompts and not in a repo. Change the document and the behaviour changes on the next run.
  • 03Built to composeEvery agent is designed as a member of a system, whether or not the second one exists yet.
registry / agents / partner-intake-agent.yamlv1 · illustrative
id:partner-intake-agenta name the whole enterprise uses
owner:one accountable human, not a team inbox
capability:profile partner bordereaux and land them in the canonical schemaprecise enough that another team can reuse it
inputs:partner_submissions[] · period
outputs:canonical_bordereaux · dq_report · exceptions[]schemas, not prose: this is what makes it callable
tools:sftp · mailbox · fabric_lakehouseand by omission, everything it may not touch
data_scope:underwriting.* · read · reviewer identityinherited per mode, never assumed
knowledge:bordereaux_schema · dq_rules · partner_profilesthe contracts it reasons from, each versioned
modes:scheduled · interactiveenabled deliberately, one at a time
evaluation:data-quality gate pass rate, tracked per partnerhow trust gets earned rather than asserted
audit:every run, decision and override · queryable
registry / agents / site-intelligence-agent.yamlv1 · illustrative
id:site-intelligence-agenta name the whole enterprise uses
owner:one accountable human, not a team inbox
capability:answer site-history questions with every claim cited to a source documentprecise enough that another team can reuse it
inputs:site_id · question
outputs:cited_report · source_listschemas, not prose: this is what makes it callable
tools:document_store · gis · restand by omission, everything it may not touch
data_scope:projects.* · read · requester identityinherited per mode, never assumed
knowledge:site_taxonomy · citation_rules · document_indexthe contracts it reasons from, each versioned
modes:interactive · service · connectorenabled deliberately, one at a time
evaluation:citation accuracy, reviewed by an engineerhow trust gets earned rather than asserted
audit:every run, decision and override · queryable
registry / agents / field-records-agent.yamlv1 · illustrative
id:field-records-agenta name the whole enterprise uses
owner:one accountable human, not a team inbox
capability:turn handwritten field logs into structured data, every value traceable to its sourceprecise enough that another team can reuse it
inputs:scanned_logs[] · project
outputs:boring_log · values_with_source · exceptions[]schemas, not prose: this is what makes it callable
tools:blob_storage · vision · warehouseand by omission, everything it may not touch
data_scope:operations.field.* · read · project identityinherited per mode, never assumed
knowledge:log_templates · unit_rules · soil_dictionarythe contracts it reasons from, each versioned
modes:scheduled · interactiveenabled deliberately, one at a time
evaluation:field-level accuracy against a reviewed samplehow trust gets earned rather than asserted
audit:every run, decision and override · queryable
registry / agents / incentive-comp-agent.yamlv1 · illustrative
id:incentive-comp-agenta name the whole enterprise uses
owner:one accountable human, not a team inbox
capability:price a plan change and brief every rep before it goes liveprecise enough that another team can reuse it
inputs:plan_document · scenario
outputs:payout_simulation · rep_briefings · approval_requestschemas, not prose: this is what makes it callable
tools:crm · hris · payroll_export (read)and by omission, everything it may not touch
data_scope:compensation.* · read · leader identityinherited per mode, never assumed
knowledge:plan_rules · quota_book · approval_policythe contracts it reasons from, each versioned
modes:interactive · serviceenabled deliberately, one at a time
evaluation:payout variance against finance sign-offhow trust gets earned rather than asserted
audit:every run, decision and override · queryable
One agent, four front doors
  • ScheduledA clock · Nobody. It just runs.
  • InteractiveA question · A person, in a chat
  • ServiceAn API call · Another app, or another agent
  • ConnectorA tool call over MCP · Claude, Copilot, a notebook
SAFE NEAR YOUR NUMBERS

AI-assisted, human-approved, deterministic at run time.

AI does the reading, matching and drafting up front, where a person can review it. What runs every night is generated, versioned code. Same input, same output, every time.

Design time · AI-assistedThe agent authors
  • Reads the source against your dictionary
  • Proposes mappings with a confidence score
  • Drafts the rules, and explains each one
GateA person approves
Run time · deterministicThe pipeline executes
  • Generated code, checked into your repo
  • No model call in the nightly path
  • Reproducible, diffable, revertible
Autonomy is a dial, and you hold itAuto-apply at ≥ 0.90
Example: a new partner’s bordereaux, mapped by the Partner Data Intake agent
3 auto-applied2 steward review1 held
  • Policy Ref → policy_number0.99auto-applied
  • Gross Prem → gross_written_premium0.95auto-applied
  • Inception → inception_date0.91auto-applied
  • Risk Postcode → risk_postcode0.84steward review
  • Cov Type → coverage_code0.68steward review
  • Fld_17 → ?0.37held

Below 0.60 nothing reaches the output unattended. Nothing is dropped and nothing is guessed. A reviewer’s correction teaches the rules.

UNDER THE HOOD

The technology, behind the contract.

The technology changes every quarter. The contract is what keeps it swappable.

  • LLMs, retrieval and evaluation

    Generative AI

    Models read documents, match fields and draft rules at design time, and answer questions over lineage at run time. The contract names the model, so swapping it is a configuration change.

  • Documents, drawings and handwriting

    Computer vision

    Scanned logs, plans, forms and handwriting become structured, traceable data, with every value linked back to the box it came from. For live video and cameras, see Edge AI.

  • Approvals, audit trails and guardrails

    AI governance

    Confidence gates decide what auto-applies, what a steward reviews and what is held. Every run, decision and override is logged and queryable, and permissions narrow per mode.

QUESTIONS

Asked often.

What is an agent registry?

A catalogue of every agent in the business, each described by the same contract: a name, an owner, what it does, its inputs and outputs, what it may touch, the knowledge it reasons from, its modes and how it is evaluated. Fill it in for one agent and it is documentation. Fill it in for every agent and it is how they find and trust each other.

Do we need a registry before our first agent?

No. We write the contract for your first agent as we build it, and that contract is the first entry. The registry grows one agent at a time.

Does the AI make decisions on its own in production?

Only as far as you let it. AI does the reading, matching and drafting up front, and a person approves it. Pipelines then run as generated, versioned code with no model call in the nightly path. Confidence thresholds decide what auto-applies, what a steward reviews and what is held.

Which models and platforms do you use?

We are model-agnostic and build in your cloud: Azure, Microsoft Fabric, Databricks or Snowflake. The contract names the model and the tools, so changing either is a configuration change, not a rebuild.

Will this lock us into one AI protocol?

No. MCP is a published standard today, so we expose agents over it now. Agent-to-agent protocols are moving quickly but still consolidating, so we design for them without depending on one. The registry, contracts, identity and lineage are durable whichever protocol wins, and that is where we put the investment.

Do we need a separate agent for every team that wants one?

Usually not. One agent can open several front doors: a scheduled run, an analyst asking questions in chat, another system calling it as a service, or a connector inside Claude or Copilot. Same core and contract, with permissions narrowed for each.

Can our people use an agent from Claude or Copilot?

Yes. In connector mode an agent is exposed over MCP, so it shows up as a tool in Claude, Copilot or a notebook, scoped to exactly what that person is allowed to see.

Who owns the contracts and knowledge?

You do. The canonical model, data dictionary and rules are documents your stewards own and edit. They stay yours whatever happens next.

How long does a first agent take?

Weeks, not quarters, for one well-scoped job, in your cloud, with your people in the loop from week one.

Start with one agent. Registered from day one.

Bring us one rules-heavy job your team re-derives every cycle. We will scope it on a whiteboard with you, and the second agent will already be half designed.

  • ScopeOne agent, one well-defined job, end to end
  • ShapeWeeks, not quarters. In your cloud.
  • PeopleYour stewards in the loop from week one
  • GateConfidence thresholds and tolerances that you set, not us
  • Done meansIt reconciles to a number you already trust, and the lineage survives a question
  • You keepThe contract, the model, the dictionary and the rules