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.
dashedyou buildsolidXAP handles
1Your applications
MobileDesktopWeb apps & APIsBI toolsAI agents
↕read & write
2XAP in-memory data grid
Your logicAgent workflowsEvent handlersTransactionsSecurityMonitoring
datalogic+ backup
datalogic+ backup
datalogic+ backup
…
Hot data · RAMWarm data · SSD
↓every change saved in the background
3Your persistence layer
RDBMSNoSQL
4Runs anywhere
On-premCloudHybridGS Service GridKubernetes / OpenShift
1 · Your applications
Apps, BI tools and AI agents read and write through XAP instead of hitting the database directly.
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 · Your persistence layer
Every change is written to your existing RDBMS or NoSQL store in the background, so it stays the permanent record.
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.
XAP evolution
Agentic processing layerSpecialized agents on your dataReasonNew
Data integrationSync with your systems of recordConnectToday
Event processingLogic that runs next to the dataReactToday
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
reads, writes
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.
Select a use case to flip the card and see an example.
Finance · Data quality
Catch a bad price the moment it lands
TriggerA price tick arrives
RulesCompare with the last good value and peers
Local LLMWhich source is wrong?
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
TriggerA supplier record lands
RulesNormalize units, names, categories
Local LLMClassify unseen product titles
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
TriggerA new customer record is created
RulesMatch on tax ID, email and phone
Local LLMAre these two records the same person?
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
TriggerA trade differs between front office and ledger
RulesCompare amount, date and counterparty
Local LLMWhat caused the break, and who owns it?
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
TriggerAn expected update does not arrive
RulesCompare the last update time with the allowed age for the feed
Local LLMIs this silence expected, or a real outage?
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
TriggerA claim is submitted
RulesCheck required fields and policy status
Local LLMDoes the text match the claim type?
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
TriggerA product record is saved
RulesCheck the required fields for its category
Local LLMPropose the missing values from the title and description
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
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.
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.
03Auto-fixRules you trust apply their fixes automatically.Routine work stops reaching your team. People handle only the exceptions.
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
Pick one data type
Attach an ADU in observe mode
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.