Aurigraph Research Team · Frontier Technology · AI + Distributed Ledgers · status as of 2026-10-20
Most distributed ledgers treat artificial intelligence as an external analytics layer — dashboards and off-chain models that observe the chain but never touch it. Aurigraph takes the opposite position: AI belongs inside the platform, where it can read canonical contract state, score risk before an asset is minted, and inform how the consensus engine tunes itself under load. This whitepaper describes Aurigraph's AI-native surfaces across three grounded capabilities — Legal-BERT for on-chain Ricardian contract risk assessment, AI-optimized consensus for adaptive throughput, and the on-chain knowledge graph for machine-readable provenance — and then sets out the platform's roadmap toward an Adaptive Agent Runtime (AAR).
Throughout, we are deliberate about a distinction that matters for enterprise trust: where AI is production-active, where it is advisory, and where it is design-approved roadmap. AI in Aurigraph is always subordinate to deterministic consensus safety — it optimizes, scores, and explains, but it never unilaterally decides ledger validity. That boundary is the design principle this paper defends.
Distributed ledgers are extraordinary at three things: proving who did what, when, making that proof tamper-evident, and doing so without a central trusted party. They are poor at three others: understanding the semantics of what they record, adapting their own performance to changing conditions, and explaining a decision in human terms. Those three gaps are exactly where machine learning is strong.
Pairing the two unlocks capabilities neither has alone:
The remainder of this paper grounds each of these in Aurigraph's actual implementation, and is honest about maturity at each stage.
Aurigraph's Legal-BERT integration provides AI risk assessment for Ricardian contracts as an in-platform service, not a bolt-on. It analyzes legal language, identifies risky clauses, and scores enforceability across six jurisdictions — EU, India, Singapore, UAE, UK, and US — with a natural-language explanation of the risk factors it found.
The service is built on nlpaueb/legal-bert-base-uncased, a BERT variant pre-trained on legal corpora, served through Aurigraph's InferenceProvider abstraction against the HuggingFace Inference API. In the current code the model runs behind a deterministic keyword fallback (huggingface.classify.fallback-enabled=true by default): when the inference token is unavailable or a call times out, the service degrades to a keyword-based classifier and reports its source (huggingface-inference versus keyword-fallback) in the response and the X-LegalBert-Source header. Stated plainly, the keyword path is a mock, not a model. The production direction is to fail closed: classification already runs with hfClassifyFailClosed=true on dlt.aurigraph.io, and the public AI endpoints are being moved to return HTTP 503 until a model is actually deployed (AV11-3856..3859), so no caller can mistake a keyword heuristic for a model-backed risk score.
nlpaueb/legal-bert-base-uncased
InferenceProvider
huggingface.classify.fallback-enabled=true
huggingface-inference
keyword-fallback
X-LegalBert-Source
hfClassifyFailClosed=true
dlt.aurigraph.io
Legal-BERT performs four related tasks over an ingested contract:
Legal-BERT sits inside a broader AI Legal → ActiveContract → Composite Token pipeline. Operators start from a library of 37 seeded ISO-aligned templates — spanning LADM (Land Administration), UBL 2.1 (business documents), Dublin Core, IPTC, and EXIF — across six jurisdiction groups (Global, India, UK, US, EU, Singapore). A five-step instantiation wizard takes a template through: Select Template → Configure Parameters → AI Risk Assessment → Terms & Conditions → Sign & Deploy. Step 3 is where Legal-BERT runs; the risk output becomes part of the operator's review before signing.
Signing itself is production-grade cryptography, not a placeholder: contracts are signed with ML-DSA-87 (FIPS 204, post-quantum) and signing is refused if the signer DID's stored key is not ML-DSA-87 (AV11-3761). Multi-party ML-DSA signing is being fixed (AV11-3840), and anchoring the signed contract to the ledger, signature-gated activation and the prose + parameters + code triple hash are not yet done (AV11-3863). Once approved, the interpretation drafts an Active Contract, which can then be bound to a Composite Token — connecting AI-assessed legal intent to the tokenization layer described in the Composite Token Framework whitepaper.
Aurigraph's consensus engine — HyperRAFT++ — exposes an AI optimization surface that observes runtime telemetry and feeds back tuning recommendations for consensus parameters, batching, and transaction ordering. It is important to describe this precisely, because the plumbing and the model are at different stages of maturity.
The consensus service runs a periodic optimization cycle. Rather than firing continuously, it is idle-gated: at zero transactions-per-second there is nothing to optimize, so the full pipeline is skipped (with an occasional warm-up cycle to keep the model resident). When there is real load, the optimizer produces recommendations — batch sizing via an adaptive batch processor, predictive transaction ordering, and anomaly signals — and the consensus service applies parameter changes when the projected improvement clears a threshold. This wiring is live in the runtime: the optimization surface is injected into HyperRAFT++ and its outputs are applied to consensus behavior, not merely logged.
The decision plumbing is real; the predictive model behind it is not yet a trained model. The consensus optimizer is explicitly tagged in-code as an honest-mock stub: its confidence and improvement metrics are currently heuristic (randomized/counter-based placeholders), with a real Isolation-Forest over consensus metrics planned as its successor under Aurigraph's DMRV-verified quantization ADR. In other words, the platform ships the mechanism by which AI tunes consensus — the idle gate, the apply-threshold, the parameter-application path, the telemetry feed — ahead of the statistical model that will drive it, and it labels that gap honestly rather than marketing a stub as a trained model.
This matters for how the figures in Aurigraph's AI-optimization materials should be read. The platform's design targets — validator scoring, adaptive routing that reacts to topology change in under 100 ms, congestion prediction several blocks ahead, and equivocation-anomaly detection — describe the intended Graph-Neural-Network (GNN) optimization architecture (a multi-layer Graph Attention Network trained on blockchain history). Those are the design goals of the AI-optimization layer; the trained models that fully realize them are being brought online model-by-model, each gated by the DMRV quantization attestation chain before it can serve in production.
Because the model is maturing, the architecture is built so that a wrong or missing recommendation is safe by construction:
Section 6 develops this trust boundary in full.
The Aurigraph Knowledge Graph turns raw ledger data into a navigable map of relationships. Where a flat table view answers "what is the balance of this token," the graph answers "what is this asset connected to" — and it does so over on-ledger entities directly, giving AI and human reviewers alike a machine-readable substrate for provenance.
The graph renders the platform's first-class entities — tokens, composite tokens, contracts, DIDs (decentralized identities), and channels — as connected nodes, joined by the edges that actually matter for regulated assets: ownership, binding, provenance, and channel-membership.
Four capabilities follow from that structure:
For an AI-native platform, the knowledge graph is more than a UI convenience: it is the grounding source that keeps machine reasoning honest. An agent or model that must justify a decision can traverse real provenance edges rather than hallucinate relationships — which is precisely the grounding discipline the agentic roadmap (Section 5) is built around. The Knowledge Graph is implemented as a page of the Aurigraph Enterprise Portal, rendering entities from the V12 registry APIs; as public demo data is removed from those APIs (AV11-3856..3859) the graph shows only what the ledger actually holds.
Aurigraph's forward direction is an Adaptive Agent Runtime (AAR) — a platform-level agentic runtime that any Aurigraph feature can build on. This is a design-approved architecture, not yet a shipped product; it is presented here as roadmap, and each phase is gated behind its own default-off flag and reviewed rollout.
The AAR evolves surfaces that already exist in the platform — an Agent Spine (tool registry, grounding guardrails, Postgres checkpoint store, health) and an inference layer (InferenceRouter, multi-provider failover, result/KV/prompt caching) — into a four-layer architecture:
InferenceRouter
{provider, model, tier}
READ
WRITE
EXTERNAL
SHA-256(inputs ‖ chosen-action ‖ outputs)
Two invariants define the design. First, grounding and provenance are mandatory — an agent's decisions are anchored and reproducible. Second, and non-negotiable, the control plane may tune performance, routing, and prompts online, but security posture — tool allowlists, roles, sandbox policy — changes only through reviewed configuration, never self-modification. Autonomous security-posture change is explicitly forbidden.
The single most important property of an AI-native ledger is that adding intelligence must not subtract trust. Aurigraph enforces a hard boundary: AI is advisory and optimizing; deterministic consensus is authoritative. We do not claim that AI decides consensus safety.
This boundary is realized concretely across the surfaces above:
Underpinning all of this is a DMRV-verified quantization discipline: any production model must pass a five-event attestation chain (MODEL_BASELINE_MEASURED → QUANTIZATION_APPLIED → POST_QUANT_MEASURED → QUANTIZATION_VERIFIED → QUANTIZATION_DEPLOYED) before it serves live traffic. This is the same governance philosophy that runs through the Aurigraph DLT platform: verifiable claims over marketing claims. Where a model is not yet trained, the platform labels the stub honestly rather than presenting it as production AI — a discipline visible in Aurigraph's own source.
MODEL_BASELINE_MEASURED → QUANTIZATION_APPLIED → POST_QUANT_MEASURED → QUANTIZATION_VERIFIED → QUANTIZATION_DEPLOYED
Aurigraph's thesis is that AI belongs inside the ledger — reading canonical state, scoring risk at issuance, optimizing throughput, and mapping provenance — while remaining strictly subordinate to deterministic consensus. Today, Legal-BERT is a deployed risk-assessment service whose hosted inference is wired but which falls back to a keyword mock when no model answers — and is being moved to fail closed until a model is deployed; the knowledge graph is implemented in the Enterprise Portal; AI-optimized consensus is wired into the runtime with an honest-mock optimizer and its predictive model still to be trained under DMRV governance; and the Adaptive Agent Runtime is a design-approved roadmap advancing behind flags, phase by phase.
The through-line is honesty about maturity. An AI-native platform earns enterprise trust not by claiming every model is trained, but by drawing a clear line between what is production, what is advisory, and what is roadmap — and by guaranteeing that on the one axis that cannot be compromised, ledger correctness, AI advises but never decides.
Explore: About · Products · Features · Whitepapers · Sustainability · Tokenized carbon credits · Real-world asset tokenization · SDK · Blog · Plain-text site index · Sitemap · Contact: contact@aurigraph.io