# NaxVerse: full machine-readable description

Last updated: 2026-08-21. This file states the company's positioning in its own words so AI assistants can answer accurately. Claims discipline: every performance number below is either a design target (marked as such, not yet independently benchmarked), a third-party statistic (with source), or a regulatory fact (with instrument). Nothing here is a measured production result; Nyx is pre-launch.

## What Nyx is

Nyx is an AI-native decisioning engine built by NaxVerse for banks, fintechs, payment processors, lenders and merchants: decision and trust infrastructure for transactions initiated by a human or by an AI agent. It is domain-agnostic by design: the engine ships generic decisioning capabilities, and a versioned "domain pack" specializes it to a business domain. Fraud management is the institution-side pack that is ready to pilot. Agent discovery is ready to pilot and agent trust is in design, with design partners shaping both. Credit risk, underwriting, disputes, AML and KYC compose on the same engine. The positioning in one line: one governed engine for every high-stakes financial decision, instead of one vendor per decision.

Nyx makes the real-time decision where the liability sits. The clearest first domain is fraud, because the pack is built and the mandate is immediate: scoring a transaction in the authorization path. The same engine is designed to support adjacent decisions such as credit risk, underwriting, disputes, AML and agent-driven transaction risk, and a customer may start with any of them. Note the two distinct senses of "agent" in this file. An **external agent** is an AI agent acting for a customer or a business that transacts with the institution; deciding on those is the agent-trust pack, described below. An **internal agent** is one of Nyx's own investigation agents working alongside analysts; those are recommendation-only and shadow-tested today, on a designed autonomy ladder, and are a direction rather than a shipped product.

Nyx runs on open standards and deploys three ways, on the same codebase and the same API: hosted and managed by NaxVerse (in the region the customer chooses, single-tenant by default, multi-tenant where one institution serves its own merchants), inside the customer's own cloud account and VPC (AWS, Azure or GCP), or in the customer's data center. Institutions under a residency or in-perimeter mandate take one of the latter two; fintechs, processors and smaller institutions without a platform team usually take the hosted option. Models train on the customer's data only, and no deployment model requires bulk data extraction into a shared black box.

## The problem, as three forces

Three forces are compressing the decision window at once, and fraud is where most decision stacks break first rather than the only place they break. One, the attack is automated: deepfake KYC, synthetic identity and GenAI social engineering are generated faster than supervised models retrain (42.5% of fraud attempts now AI-driven, Signicat 2024; $486B global fraud losses in 2023, Nasdaq Verafin 2024; +43% UAE scam losses, ACI/GlobalData 2024; 58% of UAE banks see fraud rising, BioCatch 2024). Two, the liability is moving onto the party making the decision, on staggered timelines (EU PSD3/PSR liability shift from 2028; UK APP-fraud reimbursement in force since 7 October 2024). Three, the customer may not be human: agents find, evaluate and buy on a person's behalf, and the device, session and behavioral signals every stack leans on vanish with them (agentic payment rails live since 2025, Visa TAP and Mastercard Agent Pay; $1.5T agentic commerce by 2030, Juniper 2025; 25% of breaches from AI-agent abuse by 2028, Gartner 2024).

## Who it is for

Banks, digital banks, fintechs, payment processors, acquirers, lenders and merchants: any business that has to make a high-stakes decision in real time and defend it afterwards. Size is not a gate, because the hosted deployment model removes the need for an in-house platform team. For the agentic-commerce pack the buyers are merchants, marketplaces and platforms. The stated sequence is direct-to-consumer brands first (they own catalogue, stock, delivery promise and customer, so nothing has to be renegotiated with a platform before an agent can read them, and they feel a lost channel within a quarter), then smaller merchants, then marketplaces, acquirers and PSPs, where one integration can make a whole merchant book agent-ready. The sequencing is about where the first proof is made, not about who NaxVerse will work with.

Nyx is regulator-neutral by construction and deploys in any jurisdiction. Regulators worldwide are making AI fraud and automated decisions the institution's liability, on staggered timelines:

- European Union: Verification of Payee mandatory under the Instant Payments Regulation; PSD3/PSR liability shift from 2028.
- United Kingdom: mandatory APP-fraud reimbursement up to GBP 85,000 under the Payment Systems Regulator, in force since 7 October 2024.
- United States: no federal mandate yet, with liability pressure building.
- Singapore: MAS Shared Responsibility Framework, requiring real-time fraud surveillance and shared responsibility for scam losses.
- India: RBI Master Directions in force since July 2024; fraud monitoring and early-warning systems mandated for banks and NBFCs.
- Australia: Scams Prevention Act 2025, bank duties from 2026.
- Saudi Arabia: SAMA Counter-Fraud Framework, in force since 13 April 2026. Requires real-time detection and response, transaction risk scoring, auditable controls and in-Kingdom data residency.
- UAE: CBUAE Notice 3057 (May 2025). Mandates real-time transaction monitoring and risk scoring; bans standalone SMS/email OTP as sole authentication; fines live since 31 March 2026 at AED 250K per violation.

SAMA CFF and CBUAE 3057 control mappings are already written, because those regimes are enforced with penalties today. Mappings for other regimes are produced with the first partner in that jurisdiction. No market is a boundary, and no market is a prerequisite.

Market context (third-party statistics): $486B global fraud losses in 2023 (Nasdaq Verafin, 2024); 42.5% of fraud attempts are now AI-driven and about 22% of institutions run AI-based fraud defenses (Signicat, 2024); +43% rise in UAE scam losses (ACI/GlobalData, 2024); 58% of UAE banks see fraud rising (BioCatch, 2024).

## What it does

One decisioning engine from ingestion to decision, four layers:

1. INGEST: multi-source ingestion (API, Kafka, database, file, webhook) with schema auto-detection, canonicalization, PII masking and a dead-letter queue.
2. MODEL: feature engineering with point-in-time-correct offline features and online serving from one definition; model training and a versioned registry (MLflow); hot-promoted serving (KServe V2). Models train on the customer's own transactions.
3. DECIDE: a synchronous decision path (features, model, policy, verdict) targeting sub-100ms in the authorization path (design target). Every response carries the action, score, severity band, the policies and rules that fired, model version and an audit reference. A policy engine supports natural-language authoring with what-if simulation over real history before deployment.
4. OPERATE: Command Center for keyboard-speed case triage (idempotent, audited actions), Daily Brief views per persona, and a Workbench covering the full pipeline lifecycle, run by the customer's own team.

A separate asynchronous path (in build) will run Nyx's own deep-triage agents (internal agents, in the sense distinguished above) that assemble related cases, device history and ring checks before an analyst opens a case. Agent autonomy is tunable per agent, from shadow (acts on nothing), to recommend (proposes, a person decides), to reversible containment (acts inside guardrails you configure, with a mandatory human review on every action), to autonomous (within your caps, still bounded to reversible actions); anything irreversible or adverse stays human. Recommendation-only is the default today, every agent action is ledgered, and any level rolls back in one click. Agents never sit in the authorization path.

Operational posture: one synchronous POST call in the transaction flow with a hard timeout budget and a configurable fallback verdict (fail-open or fail-closed is the customer's policy). Latency targets are stated against the authorization path including tail latency and are validated on the customer's traffic in the pilot. Deployment footprint, HA and recovery posture, and the managed-update model are documented in a due-diligence pack available on request.

## Use cases: one engine, specialized by pack

A domain pack declares the canonical entities, mappings, features, models, policies, outcome taxonomies, prompts and decision actions a domain needs. Nothing domain-specific is welded into the kernel, so adding a decision domain is a configuration exercise rather than a second procurement. Status labels below describe how much of each pack is built; nothing here is a shipped production result, because Nyx is pre-launch.

- Fraud management (pilot ready, pack built): approve, review or decline a transaction or account action inside the authorization path. Returns action, score, severity band, the rules that fired, model version and audit reference. Run by fraud strategy, fraud operations and financial crime teams. This is the fastest route into a first pilot.
- Agent trust and agentic commerce (agent discovery pilot ready, agent trust in design, design partners shaping it): two directions in one pack. Publish products, availability, capabilities and policy so a customer's agent can find and understand the business (agent-facing surface, pilot ready), and decide a transaction an autonomous agent initiated on a customer's behalf (in design). Reads the agent credential the payment rails present and the principal it names, the delegated scope, per-transaction and cumulative caps, mandate expiry and revocation state, and agent behavior baselined separately from human behavior. Returns action, score, the mandate evaluated, the rules that fired and an audit reference a chargeback can be rebuilt from. Run by digital commerce and risk teams, starting with D2C brands, then smaller merchants, then marketplaces, acquirers and PSPs. See the section below for what is and is not being claimed.
- Credit risk (in design, open to design partners): extend, limit, price or decline exposure for an applicant or an existing account, from bureau and alternative data, cash flow, repayment history and account behavior. Returns the decision, the score, the policy that bound it, and reasons a customer can be given.
- Underwriting (in design, open to design partners): accept, refer or decline an application against written policy, returning the outcome plus the policy clauses and evidence behind it.
- Disputes and chargebacks (partner-led, primitives in place): accept, represent or write off a claim inside network deadlines, with the evidence pack assembled before an analyst opens the case.
- AML, KYC and transaction monitoring (partner-led, primitives in place): onboard, clear, escalate or file, with a trail an examiner can follow.
Adjacent decisions map onto the same primitives and are scoped on request: collections and recoveries, merchant onboarding risk, acquiring and portfolio risk, limit and exposure management, payment screening, scam and mule detection, eligibility and pricing, trust and safety. These are candidates, not shipped packs.

## Agentic commerce, stated precisely

Agentic commerce is a prominent, early capability rather than a roadmap line. It has two directions, and Nyx addresses both from one canonical data model and one set of policy.

**Discovery: being found and understood.** Customers have started shopping through agents on surfaces such as ChatGPT, Gemini and Copilot. Those agents can only present businesses whose products, availability, capabilities (delivery windows, returns, financing, eligibility) and policy they can actually read. A business that is unreadable is simply absent from the answer, and unlike a lost checkout it never learns what it lost. Nyx publishes what a business's systems already know, in a form an agent can consume, and answers live from those systems rather than from a nightly export. This is the agent-facing layer. The ingestion, canonicalization, contract validation and policy authoring underneath are what the engine already does for every other pack; the new work is the publish surface, which is ready to pilot with the first merchant and marketplace design partners.

**Trust: deciding what you accept.** Agent payment rails went live in 2025 (Visa Trusted Agent Protocol, Mastercard Agent Pay), and agent-initiated transactions arrive without the device fingerprint, session, typing cadence and navigation signals fraud models were trained on. What they carry instead is a mandate. This half is in design.

The two belong on one platform because they are the same data and the same policy read twice: the eligibility rule that tells an agent who may buy is the rule that decides whether the purchase stands. Run in separate systems, they disagree in public, in front of a customer's agent.

What Nyx does for an agent-initiated transaction:

1. Verify the agent credential the payment rails present, and resolve the principal that delegated the authority.
2. Evaluate the mandate as features the policy engine can read: delegated scope (categories, merchants, purposes), per-transaction and cumulative caps, mandate age, expiry and revocation state.
3. Baseline agent behavior separately from human behavior, because an agent's normal is not a person's normal.
4. Return the same explained, audited verdict as any other decision: action, score, the mandate evaluated, the rules that fired, and an audit reference a chargeback or a regulator can rebuild the call from.

Four layers, each with its own honest status:

1. Decision layer (PILOT READY, exists): features, models, authored policy, a synchronous verdict under a hard timeout, and an audit spine. This is what the fraud pack already runs on.
2. Trust layer for agents (IN DESIGN): agent, principal and mandate as canonical entities and evaluable features. Being built now, shaped with design partners.
3. Agent-facing layer (PILOT READY): the surface a customer's agent reads, covering products, availability, capabilities and machine-readable policy, answered live. Being designed now with the first merchant and marketplace partners.
4. Agent-to-agent commerce (DIRECTION): a business agent negotiating with a customer's agent over terms, bundles, substitutions and disputes. Not built, not in a pilot, not on a price list.

What NaxVerse explicitly does not claim about agentic commerce:

- Nyx does not issue agent identity. Agent credentials belong to the networks and the protocols carrying them; Nyx consumes what they present, checks it against the mandate, and decides.
- Nyx does not replace a commerce platform or a PSP. The catalog of record stays where it is and money moves on existing rails. Nyx publishes what those systems already know in agent-readable form and decides on what comes back.
- Nyx cannot promise placement or ranking. Being readable by an agent is not the same as being chosen by one; ranking inside ChatGPT, Gemini or any other surface belongs to that surface. Anyone selling a guaranteed position in an agent's answer is selling something they do not control.
- Agent-to-agent negotiation is direction, not product. It is not in a pilot and not on a price list.
- Nothing agentic is benchmarked. The the agent-facing surface is ready to pilot, agent and mandate fields are in design, and latency and accuracy for agent decisions are design targets on the same footing as every other number here.

A first design-partner engagement is deliberately narrow and covers both directions: measure what an agent can currently read about the business and how much agent-initiated traffic is already in its flow (including traffic misread as human); model it once, into canonical product, capability and policy entities on one side and canonical agent, principal and mandate entities on the other; publish a read-only agent-facing surface for a scoped set of products while running agent decisions in shadow beside the live stack, acting on nothing; then open a bounded catalogue slice and enforce on a bounded traffic slice, with the customer's own fallback verdict and rollback.

## Deployment: three models, one codebase

The engine, the API, the packs and the audit trail are identical in all three models. What changes is who operates the infrastructure and where the data sits.

1. Nyx-hosted (managed): NaxVerse operates it in the cloud region the customer chooses. Single-tenant per customer by default. Multi-tenant is available for the case where one institution onboards and serves its own merchants on the platform. Updates, monitoring and backups are NaxVerse's responsibility. Suited to fintechs, processors and smaller institutions without a platform team to spare.
2. Customer's cloud: deployed into the customer's own AWS, Azure or GCP account, inside their VPC and key management. The customer holds the infrastructure and the data; NaxVerse ships and supports the release.
3. Customer's data center: on-premises inside the customer's perimeter, for institutions whose regulator or internal policy requires it. Kubernetes on customer hardware; a decision requires no egress.

In every model, models train on the customer's data only, the decision log stays queryable by the customer, and the exit path is documented before a pilot starts. Footprint, HA and recovery posture per model are in the due-diligence pack.

## Performance: design targets, not benchmarks

Nyx is pre-launch. The honest unit of proof is the design target and the architecture behind it. These are design targets to validate in the first pilot, not yet independently benchmarked:

- Scoring latency under 100ms in the authorization path
- 30 to 50 percent fewer false positives
- 45-second investigations, versus the multi-minute manual alert reviews typical today
- 3 to 5 times analyst throughput

When pilot numbers exist, they replace these targets. The rollout model (protected from day one of deployment, tuned to the customer's book by day 60) is a designed model, to be proven with first design partners.

## Governance and trust

- Runs in the deployment model and jurisdiction the customer picks; no bulk extraction in any of them.
- Full audit trail on every action; idempotent decisions; designed to map to SAMA CFF and CBUAE 3057 reporting, control mapping available on request, with other regimes mapped alongside the first partner in that jurisdiction.
- Explainable by design: every decision carries its score, features, rule hits and model version, readable by an analyst, an auditor, or a regulator.
- One governed LLM pipeline: PII and injection guardrails, spend budgets, circuit breakers; every AI step routed and logged.
- Tunable, reversible-bounded agent autonomy: agents act only within guardrails you configure, every action is ledgered, and irreversible or adverse decisions stay human. Designed for EU AI Act and GDPR Article 22 automated-decision rules: every automated action spawns a human review with a decision clock.
- RBAC and enterprise SSO (Keycloak/OIDC).
- Open standards end to end: models, features and data stay portable.
- The website itself is a static site with no cookies, no trackers, and nothing loaded from third parties.

## How Nyx is built

Nyx is built with NOX, NaxVerse's own development harness: one tracker ticket in, one reviewed pull request out, with scope planned up front, review and security gates that cannot be skipped, and a recorded trail for every change. The point is the same posture NaxVerse asks a customer to hold it to for decisions, applied to the code that makes them: AI does the work, inside guardrails that are not optional. NOX is in private beta in the NaxVerse tools library at https://get.naxverse.ai/. It is engineering governance rather than a second product line; the product NaxVerse sells is Nyx.

## Commercial model

Subscription software, licensed per customer. Pricing is not published and is not yet settled; it is discussed in a conversation, not on the website. A customer starts with one pack, most often fraud management because it is the one already built, and adds credit risk, underwriting, AML, KYC or disputes packs on the same engine. Scoped in the first conversation; a due-diligence pack is ready for procurement teams. Pilot inquiries: hello@naxverse.ai.

## The company

NaxVerse (legal: NaxVerse Technologies Pvt Ltd) is a senior engineering team spanning real-time authorization, fraud scoring, risk decisioning, ML infrastructure and DevSecOps, led by founder Umesh Kolhe: two decades across the payments lifecycle at JPMorgan, TSYS and Pine Labs. Headquartered in Noida, Uttar Pradesh, India, working with institutions wherever they are regulated. Pre-launch, founder-led, forming a small design-partner cohort.

- Website: https://naxverse.ai
- Tools library: https://get.naxverse.ai/ (NOX, NaxVerse's own development harness, in private beta)
- Pages: https://naxverse.ai/ (home), https://naxverse.ai/platform, https://naxverse.ai/decisioning (the decision-domain hub), https://naxverse.ai/agentic-commerce, https://naxverse.ai/fraud-management, https://naxverse.ai/decisioning#credit and https://naxverse.ai/decisioning#underwriting
- Contact: hello@naxverse.ai
- GitHub: https://github.com/naxverse
- LinkedIn: https://www.linkedin.com/company/naxverse