ZaphiraProtects enterprise systems for agentic workloads XAPIn-memory data grid DIHDigital integration hub Company
XAP

Any Speed. Any Scale.

GigaSpaces XAP is a high-performance in-memory data grid that pairs ultra-fast transaction execution with embedded business logic, event workflows, and autonomous agents. For mission-critical applications demanding accurate, near real-time responses, XAP delivers distributed ACID compliance, complete persistence, and automatic high availability, powering your digital enterprise at scale across any environment.

Overview

XAP lets you put your business rules where the data lives. You define the logic that makes your application work, including constraints, validations, aggregations, event-driven workflows, and AI agents. XAP runs that logic inside the in-memory data grid (IMDG), next to the data it governs, and takes care of performance, scale, high availability, persistence, and deployment.

Because logic and data share one place, your code works on live objects directly. There are no extra network hops to fetch data and no serialization at each step. Logic can be built-in or custom. Java code can be sent at runtime to run colocated in every data partition, and it can be changed when needed with no downtime. Changes to data can trigger logic inside the grid, and live client-side caches stay current as the data changes.

Your team focuses on the business rules. Your customers get the outcomes that matter: low-latency responses, capacity that grows with demand, automatic failover, durable data, cost control through tiering, and enterprise-grade security.

What You Build, What XAP Handles

XAP separates your application logic from the infrastructure that runs it. You define what the system should do, and XAP makes sure it runs fast, scales, and stays available.

You build

Your business rules

  • Constraints and validation rules that apply as data changes
  • Custom aggregations and data changes tailored to each use case
  • Event-driven workflows and event handlers
  • Autonomous agents, MCP tools, and the semantic layer that describes your data
  • Indexes for your queries, and tiering rules that decide what stays in RAM
  • Persistence sources and security policies
XAP handles

The platform

  • Performance. Logic runs where the data lives, with low latency and high throughput
  • Scale. Capacity grows with load. Scaling out a stateful service pauses it briefly while data redistributes between processes
  • High availability. Synchronized replicas and automatic failover within the cluster
  • Persistence. Fast recovery from the source, and reliable write-behind to the store
  • Transactions. ACID transactions with isolation levels, and rollback on failure
  • Runtime code. Java code runs colocated in every data partition, and it can be changed at runtime with no downtime
  • Deployment. Hot rolling deployments, upgrades, and recovery
  • Operations and security. Monitoring with alerts, role-based access control, and encryption in transit and at rest

Key Business Benefits

  • Millisecond response time at any scale

    Hot data stays in memory, so applications get near-instant access even under heavy concurrency. Capacity grows with load, and scaling out a stateful service pauses it briefly while data redistributes.

  • Predictable latency

    Off-heap storage reduces Java garbage collection pauses, keeping performance steady on large in-memory datasets.

  • Transactional integrity

    ACID transactions across multi-space deployments, with two-phase commit (2PC) for strict consistency.

  • Logic, agents, and code where the data lives

    Aggregations, data changes, custom logic, embedded agents, and Java code sent at runtime run inside the grid. They cut network round trips and serialization overhead, and each one can be tailored to the use case.

  • Real-time reactivity

    Push and polling event mechanisms deliver real-time data subscriptions, with optional FIFO ordering and guaranteed delivery.

  • Continuous multi-source ingestion

    Connectors and write-behind persistence sync with relational, NoSQL, and legacy stores. CDC and ETL pipelines filter, transform, and enrich data before it lands in XAP.

  • Lower total cost of ownership

    Business-driven tiering keeps the most valuable data in RAM and warmer data on SSD, balancing TCO and performance.

  • Always-on availability

    Synchronized replicas fail over automatically inside the cluster, and asynchronous multi-site replication supports disaster recovery.

  • Faster time-to-market

    Easy deployment and full JDBC access shorten project timelines.

How XAP Works

Digital applications, mobile, desktop, web apps and APIs, and BI tools, connect to XAP's rich data access API. Inside the grid, colocated code and agent workflows, transactional support, event-driven processing, monitoring, and security and compliance controls operate directly on data held in partitions distributed across the cluster, each replicated for high availability. Business-driven tiering keeps hot data in RAM and optional warm data on SSD, and the grid scales those partitions up or out as load changes.

  1. 1 · Your applications

    Apps, BI tools and AI agents read and write through XAP instead of hitting the database directly.

  2. 2 · XAP

    Data lives in memory, split into partitions across servers. Each partition has a live backup, so nothing is lost if a server fails. Your logic and agents run inside each partition, right next to the data. Business rules decide what stays in RAM and what moves to SSD.

  3. 3 · Your persistence layer

    Every change is written to your existing RDBMS or NoSQL store in the background, so it stays the permanent record.

  4. 4 · Runs anywhere

    On-prem, in any cloud, or hybrid, with rolling upgrades and automatic recovery.

Under the XAP Hood

High Availability

XAP keeps applications available through synchronized replicas inside the cluster. If a primary partition is unavailable, XAP manages failover, split-brain handling, and data affinity. For disaster recovery and geo-redundancy, data is replicated asynchronously between sites, including hybrid environments.

Persistence and Never Lose Writes

XAP data persistence handles fast cache recovery from the persistence layer (source) and delegates changes made within the space to the persistence layer (endpoint). The XAP mirror service (write-behind) provides reliable asynchronous persistence to the store, with strong consistency that ensures data integrity and freshness, unlike solutions that support only eventual consistency between nodes.

Every operation is written to a redo log, and the redo log is synchronously replicated to the backup. This guarantees that each change is delivered to the mirror, so if a failover occurs, acknowledged writes are not lost and pending changes continue to the persistence store.

The same mechanism guarantees delivery for durable notifications and for live local view side caches. Subscribers and local views receive every change, so no update is lost.

Transactions and Event Delivery

Transactions are supported across all APIs with isolation levels, and they can propagate from a microservice to the data node and roll back on failure. Applications receive events through polling or notifications, with optional FIFO and FIFO grouping, and guaranteed or once-only delivery for workflows that must not lose or reorder events.

Scaling Up and Out

XAP delivers a scaling process that can be performed both horizontally and vertically. You define when to scale and how, increasing or reducing the number of partitions allocated to a service, over Kubernetes, Red Hat OpenShift, or the GigaSpaces Service Grid. Automation can apply your scaling rules. Scaling a stateful service horizontally requires a short quiesce while data redistributes between processes.

Flexible Deployment

XAP can be deployed on any public cloud, private cloud, or hybrid environment: easy deployment and provisioning across any scale; hot rolling and automated deployment, upgrading, monitoring, and recovery; support for elastic orchestration systems such as Kubernetes and Red Hat OpenShift; and efficient, cost-effective data replication across regions, clouds, or between on-premises and cloud deployments.

Business-Driven Storage Tiering

Data is stored in multiple tiers, hot (in-memory) and warm (SSD). User-defined business rules place the most important data, the most accessed data, or the data that should be retrieved the fastest, in hot storage, while less frequently accessed data is kept in warm storage.

Native Multi-Criteria Queries and Fast Aggregations

XAP supports an unlimited number of advanced indexes, including nested objects, collections, compound index, geo-spatial, and full-text search, with SQL-99 compliance. Aggregations are performed server-side, either out of the box or with custom code, in the same memory space as the data, avoiding data retrieval back to the client and reducing networking and serialization overhead.

Semantic search is also available, so applications can find data by meaning alongside the multi-criteria queries above.

Multi-Model Data Support

XAP is a multi-model in-memory data grid that supports structured, semi-structured, and unstructured data models in a single solution, without fragmenting data across multiple different data stores.

Security and Monitoring

Role-based access control (RBAC) integrates with Spring Security and LDAP, and custom security can be added. Single sign-on (SSO) is supported with OpenID. Data is encrypted at rest and in transit, with SSL on the transport layer.

Monitoring works with OpenTelemetry for metrics and traces. Predefined and custom metrics can trigger alerts when thresholds are met.

Operational Reporting

XAP easily integrates with operational reporting and data integration tools.

XAP Evolution: Agentic Data Unit (ADU)

XAP adds a new layer on the platform you already run: Agentic Data Units (ADUs), specialized agents that run inside your in-memory data layer, next to the data.

  1. Agentic processing layerSpecialized agents on your dataReasonNew
  2. Data integrationSync with your systems of recordConnectToday
  3. Event processingLogic that runs next to the dataReactToday
  4. In-memory data gridFast, scalable, transactionalStoreToday

Your existing apps extend to new agentic capabilities

  • No code changes
  • No data model changes
  • On the XAP you run today

An AI breakthrough for the data layer

XAP today Deterministic

  • Extreme performance
  • Complex logic, coded by hand in Java

LLM and agentic reasoning New

  • Logic is generated, not hand-coded
  • New AI use cases on your data
Triggers
Data change eventA write or update in your data
Incoming messageFrom an external agent, via A2A
XAP in-memory data layer
Your dataIn-memory data objects
ADU
Business logicYour rules
+
LLM reasoningUnderstands, decides
Specialized data agent
ActionFix, flag, notify
Many ADUs side by side in one XAP, one per concern
  • Price quality
  • Freshness
  • Validation
  • Duplicates
  • Yours

An agent embedded into your data layer

  • Starts on a trigger: a change in your data, or a message from an external agent over the A2A protocol.
  • Rules plus reasoning: it combines your business logic with LLM reasoning, so it can decide on cases that rules alone cannot.
  • Local and private: the LLM is local, and the analysis runs in place, so raw records are never copied out.

Fast where work repeats, smart where it needs judgment

You describe the business logic in plain language and the ADU builds both paths for you.

Repetitive work

Deterministic code, written by the ADU

  • The same answer every time
  • In-memory speed
  • No model call, no wait

Judgment calls

An LLM flow that reasons over the context

  • Handles what rules cannot
  • Explains its decision
  • Local, your data stays inside

It gets faster and cheaper over time: a judgment that keeps repeating becomes code.

  • Finance · Data quality

    Catch a bad price the moment it lands

    1. TriggerA price tick arrives
    2. RulesCompare with the last good value and peers
    3. Local LLMWhich source is wrong?
    4. ActionQuarantine and propose a fix
    ArrivesEURUSD  10.841  (previous 1.0841)
    Resultquarantined, peer source confirms 1.0841

    Instead of: a nightly price sanity batch

  • Retail · Data cleaning

    Clean supplier data on arrival

    1. TriggerA supplier record lands
    2. RulesNormalize units, names, categories
    3. Local LLMClassify unseen product titles
    4. ActionClean record, steward reviews
    Arrives"Choc. Chip Cookie 12oz BX"
    ResultChocolate Chip Cookies | 340 g | Bakery

    Instead of: cleanup scripts after load

  • Banking · Customer data

    Match and merge a customer the moment they are added

    1. TriggerA new customer record is created
    2. RulesMatch on tax ID, email and phone
    3. Local LLMAre these two records the same person?
    4. ActionMerge with an audit trail, or flag for a steward
    Arrives"J. Smith, 12 Oak St" and "John Smith, 12 Oak Street"
    Resultsame person, merged into customer 4471

    Instead of: a periodic deduplication job

  • Capital markets · Operations

    Triage a break between two systems as it appears

    1. TriggerA trade differs between front office and ledger
    2. RulesCompare amount, date and counterparty
    3. Local LLMWhat caused the break, and who owns it?
    4. ActionClassify the break and route it to the right team
    ArrivesTrade T-5521: front office 250 lots, ledger 2.5 lots
    Resultunit mismatch, routed to Operations with a suggested correction

    Instead of: a manual review of breaks each morning

  • Market data · Feeds

    Alert when data goes stale

    1. TriggerAn expected update does not arrive
    2. RulesCompare the last update time with the allowed age for the feed
    3. Local LLMIs this silence expected, or a real outage?
    4. ActionMark the values as stale and alert the owner
    ArrivesFeed LSE-EQ: no update for 4 min (allowed 5 s)
    Resultmarket open, real outage: values marked stale, owner alerted

    Instead of: finding out when a user reports a wrong number

  • Insurance · Data validation

    Check a claim the moment it is submitted

    1. TriggerA claim is submitted
    2. RulesCheck required fields and policy status
    3. Local LLMDoes the text match the claim type?
    4. ActionSuggest the fix, notify the adjuster
    ArrivesClaim 88213: "burst pipe in kitchen", type: theft
    Resultmismatch, suggested type: water damage

    Instead of: a manual review after submission

  • Retail · Product data

    Spot and fill the gaps

    1. TriggerA product record is saved
    2. RulesCheck the required fields for its category
    3. Local LLMPropose the missing values from the title and description
    4. ActionFill the gaps as suggestions, steward confirms
    ArrivesSKU 20931 "Trail running shoe, size 42": category and material empty
    Resultcategory: Footwear > Running, material: proposed, steward to confirm

    Instead of: a catalog audit once a quarter

  • Your use caseAny logic tied to your data

Illustrative examples. Your data and rules will differ.

Start by observing, earn autonomy

  1. 01ObserveThe ADU only flags issues. It proposes nothing and changes nothing.No risk. You see what it would catch and build trust in its judgment.
  2. 02SuggestThe ADU proposes a fix with its reason. A steward approves it first.Your team keeps the final say, and approved fixes are applied without rework.
  3. 03Auto-fixRules you trust apply their fixes automatically.Routine work stops reaching your team. People handle only the exceptions.
  4. 04AutonomousThe LLM resolves judgment calls within your limits.Cases that needed a person are handled as the data changes, inside your limits.

Every action is audited. You decide when a rule moves up.

Next step: one pilot

  1. Pick one data type
  2. Attach an ADU in observe mode
  3. Promote the rules you trust

XAP FAQs

Answers to the questions we hear most from teams evaluating XAP.

XAP is an in-memory data processing platform (grid) that runs low-latency applications.

It complements real-time databases by managing portions of the data in memory.

Yes, XAP is middleware that optimizes data access patterns, and can be scaled to support thousands of concurrent transactions.

No, XAP only replicates the critical or latency-sensitive data.

Other data can be stored on SSDs or similar storage devices.

XAP learns the relationship between the objects in the grid, and as with databases, can execute complex SQL queries.

XAP is not an alternative for a data warehouse, and cannot be used to run analytics on huge amounts of data.

XAP primarily supports structured data, but can support unstructured data and document formats in certain use cases.

XAP has a built-in mechanism to support in-memory event notifications and other types of memory buses.

It can be easily integrated with any streaming solution such as Apache Kafka.

XAP clusters can be replicated from any environment to any other environment.

XAP supports all kinds of application workloads such as in-memory event buses, live client-side caching, custom embedded code, and application management and orchestration.

XAP can store Java objects, documents, and key-value pairs, and utilizes secondary indices for efficient memory consumption and ease of use.

Yes, XAP arrives with an embedded disk-based solution, which persists the data to enable fast recovery, and lowers TCO.

Yes, XAP maintains a synchronized replica that allows consistent replication.

It also manages failover, split brains, and data affinity if the primary partition is not available.

Yes.

XAP's live client-side caches keep data close to microservices and edge applications, and stay current as the data changes. XAP is an in-memory data grid, so it also provides ultra-fast processing, high availability, and consistency.

Kafka is a streaming bus that supports pub/sub patterns and stores data temporarily on disk.

XAP stores data in-memory and provides efficient access tools similar to RDBMS, such as indexing and embedded code. XAP uses real-time, in-memory Java objects with no need to transform to and from JSON.

XAP is used primarily for mission-critical use cases such as online trading, real-time risk management, and in retail, transportation, and healthcare.

XAP is also used in data processing for AI and large language models.

Yes it does.

XAP can store Java objects, documents, and key-value pairs, and utilizes secondary indices for efficient memory consumption and ease of use. XAP also includes a .NET SDK and libraries for native integrations.

Yes.

XAP provides ACID transactions across multi-space deployments and client activity, including two-phase commit (2PC) for strict consistency.

XAP's off-heap storage option keeps data outside the Java heap.

This reduces GC-driven latency spikes and keeps performance steady on large in-memory datasets.

Yes.

XAP is a processing engine that co-locates data with logic in a highly customized way. Aggregations (such as Sum and Avg) and data changes (such as Set and Increment) are available out of the box or as custom code, tailored to each use case. This cuts network round trips and serialization overhead.

XAP supports push and polling event mechanisms and real-time data subscriptions, so applications react to data changes as they happen.

Yes.

XAP provides full JDBC support, so existing BI tools, reporting engines, and SQL-based applications can query the in-memory grid.

XAP connects to relational, NoSQL, and legacy stores through connectors and write-behind persistence.

CDC and ETL pipelines can filter, transform, and enrich data from multiple upstream sources before it is written to XAP.

Yes.

XAP offers a lightweight gRPC thin client for serverless platforms such as AWS Lambda and for modern microservices, without heavy client dependencies.

Yes.

XAP's Agentic Data Unit (ADU) embeds autonomous agents in the data layer, so they work on live data without moving records across the network. External agents can trigger workflows in the data layer, and data changes can trigger workflows too. Each workflow can be deterministic business logic or LLM-driven, and agents can communicate with other agents using the A2A protocol.

Get started

Where are you with XAP?

New to XAP

See it run on your own workload, and what XAP handles for your team.

Already running XAP

Get ready for agentic workloads on the estate you already run.

Explore Zaphira