Home · Solutions · JUSTE AGENTS / aOS API
The platform, without the interface

Call the AML workforce from your own system.

JUSTE is an agentic operating system: a workforce of specialised AI agents running screening, classification and due diligence under rules codified from a firm's own policy. The aOS API exposes that workforce programmatically — same agents, same guardrails, same evidence.

What comes back is not a match list. It is a governed decision, with the reasoning, the rule that decided it and the provenance attached.

Regulation railsAI recommendsPolicy governsHumans sign offEvidence survives
GOVERNED DECISION · RESPONSEillustrative
// the screening ran, and then the policy decided
{
  "status": "blocked_pending_senior_authority",
  "overall_risk": "high",
  "risk_types": {
    "sanctions":      { "ai": "low",  "final": "low"  },
    "pep":            { "ai": "low",  "final": "low"  },
    "adverse_media":  { "ai": "low",  "final": "low"  },
    "territorial":    { "ai": "low",  "final": "high" }  },
  "override": {
    "rule":           "4.2",
    "policy_version": "3.1",
    "reason":         "third-country funds trigger EDD"
  },
  "required_action": "mlro_authentication",
  "provenance": {
    "agent": "risk-classifier",
    "model": "[recorded]",
    "prompt_version": "[recorded]"
  },
  "inspection_report": "rpt_..."
}

Illustrative shape, not the published schema. The point is what the response contains: the AI's view, the policy's view, and which won.

What you are calling

Not an endpoint. A workforce with a chain of command.

Nineteen operational agents run across the platform, ten of them in the core AML workforce. They are specialised rather than general: one screens, one classifies, one builds due-diligence questions, one evaluates the answers.

Every material output passes through three of them before a human sees it — and the human is still the one who decides.

1

The producing agent

Does the work: runs the screening, drafts the classification, generates the questions the identified risk drivers call for.

2

The QA agent

Checks the work before it goes anywhere: completeness, internal consistency, whether the output actually answers what was asked.

3

The supervising agent

Applies the firm's codified policy, records any override with its rule and version, and determines what human authority is now required.

The governed response

Every call returns the decision and how it was reached.

A screening API that returns matches leaves your users with the hard part: deciding, and evidencing that they decided properly. The aOS API returns the whole chain, so an integration inherits the governance rather than having to build it.

What comes backWhy it is there
risk_typesEach risk type rated separately, with the AI's recommendation and the final classification shown side by side. A single blended score hides exactly the information a supervisor asks about.
overrideWhere the firm's policy overruled the AI: the rule reference, the policy version in force and the reason. This is the evidence, not a log line.
required_actionWhat must happen next under the firm's own rules — nothing, targeted due diligence, or authentication by a named senior authority.
provenanceThe agent, the model and the prompt version behind each material output, so a decision made today can be re-examined against the exact system state that produced it.
inspection_reportA reference to the complete evidenced record: what was screened, what was found, what policy required, what the human did, with timestamps.
The important part

An API call cannot weaken a firm's governance.

This is the question every compliance officer asks when their software vendor announces an AML integration: does going through the API let someone skip the controls? Here the answer is structural.

The guardrails live in the policy engine, not in the interface, so they apply identically to every caller
High risk returns a blocked status that only the firm's MLRO or nominated senior authority can clear
Policy-set fields are locked — changing one requires a recorded review, through the API as through the screen
Every call is attributable to a user and an application, and lands in the same audit trail
No free-form model access — agents run inside codified workflows, and the API does not expose the underlying models
The firm's policy travels with the call, so one integration serves every customer's different risk appetite
Who builds on it

Three shapes of integration.

Software platforms

If regulated firms manage clients or matters inside your product, AML is a gap your users feel every day. Offer it natively instead of sending them elsewhere. The Clio Manage integration is built this way and runs in production.

See the Clio integration

Multi-entity and high-volume firms

Trigger screening from your own intake workflow, your CRM or your case management system, and pull the governed result back into the record your people already work in.

Talk about your workflow

Consultants and outsourced MLROs

Operate across a portfolio of client firms, each running its own codified policy, with escalated cases arriving already assembled and every action evidenced against the right firm.

See partner options
Getting started

How an integration usually goes.

1

Scope the flow

Where screening should start in your product, what data you already hold, and where the result and report need to land.

2

Sandbox access

Credentials and a test environment with a sample codified policy, so you can see governed responses before touching a real client.

3

Build the narrow version

One flow that works end to end beats a broad plan that does not. Weeks rather than quarters.

4

Go live with a firm

Launch with a customer who wants it, on their own policy, and expand from there.

To complete before publishing Link the developer documentation, state the authentication model, publish rate limits and environment URLs, and confirm whether webhooks are available for status changes such as an MLRO clearing a blocked file. Also confirm the response schema in the hero, which is illustrative and deliberately not presented as the published contract.
Questions

What technical teams ask first.

What exactly is the aOS API?

The JUSTE agentic operating system, exposed programmatically. The same agent workforce behind the interface — screening, policy-governed classification, proportionate due diligence and evidence production — called from another system, with the firm's own codified policy and human oversight points enforced identically.

Can a call bypass the guardrails?

No. The guardrails sit in the policy engine rather than the interface. High risk returns a blocked status requiring the firm's MLRO or nominated senior authority, and policy-set fields cannot be altered without a recorded review.

Whose policy applies on an integrated call?

The policy of the firm the call is made for. That is what makes a single integration viable across sectors: each customer's own risk appetite travels with their tenant rather than being hard-coded into your product.

What about the data?

Processing takes place predominantly in the UK and EEA, with some sub-processors in the US under appropriate safeguards. Customer and end-client data is never used to train or improve models, in any form. See AI transparency.

How is it priced?

On the same basis as the rest of the platform: by inspection report volume, with unlimited seats. An integration therefore does not penalise your largest customers for being large.

Is there a working example?

Yes. The Clio Manage integration is built on this API and runs in production: screening starts from a Clio contact and the completed reports return to the matter documents.

Tell us where screening should start in your product.

That one answer usually settles most of the integration design. We would rather ship something narrow that works than plan something broad that does not.