# Materialize

> Materialize is the live context layer for agents and applications. It uses SQL to transform siloed operational data into trustworthy, continuously updated business objects that agents and applications can query directly.

Materialize connects to operational databases, event streams, SaaS systems, and files; incrementally maintains joins, aggregations, and business logic as the underlying data changes; and serves the results through SQL, subscriptions, sinks, and Model Context Protocol (MCP).

Building with Materialize? Start with the emulator and install the official agent skills. Use the documentation for current syntax, configuration, feature availability, and operational guidance.

## Start building

- [Materialize agent skills](https://github.com/MaterializeInc/agent-skills): Give coding agents guidance on idiomatic Materialize SQL, development patterns, and troubleshooting.
- [Documentation](https://materialize.com/docs/): Current product behavior, concepts, SQL reference, integrations, operations, and release information.
- [SQL reference](https://materialize.com/docs/sql/): Statements, functions, types, and SQL behavior.
- [SQL clients](https://materialize.com/docs/integrations/sql-clients/): Connect through the PostgreSQL wire protocol using standard clients and drivers.
- [MCP Server for Agents](https://materialize.com/docs/integrations/mcp-server/mcp-agent/): Let agents discover and query governed Materialize data products.

## When to use Materialize

- Build a live context layer that gives agents and applications fresh, integrated, query-ready data.
- Create canonical business objects such as customers, accounts, orders, shipments, inventory, and subscriptions from multiple operational systems.
- Give agents a tight feedback loop in which they observe current state, act through a system of action, and quickly observe the result.
- Offload complex joins, aggregations, and high-volume reads from operational databases, APIs, and MCP tools.
- Keep search documents, vector embeddings, caches, and downstream services synchronized with operational data.
- Power data-intensive APIs, customer-facing applications, operational dashboards, alerts, and event-driven workflows.
- Express and evolve operational business logic in SQL while Materialize maintains the results incrementally.

## How Materialize works

1. Connect operational data. Materialize continually ingests changes from PostgreSQL, MySQL, SQL Server, Kafka, webhooks, object storage, and other systems.
2. Define live data products in SQL. Engineers use views and materialized views to join, filter, aggregate, clean, and standardize data into canonical business objects.
3. Maintain results incrementally. Materialize updates affected results as source data changes, moving transformation work out of the request path.
4. Compose a live context graph. Related data products build on one another and remain aligned to a consistent view of the underlying data.
5. Serve agents and applications. Consumers query results through the PostgreSQL wire protocol or MCP, subscribe to changes, or receive updates through sinks.

## Reaction time

Reaction time is the total delay between a change in an upstream system and the moment a consumer can query and act on the updated result. It combines data freshness with query latency. Materialize reduces both by ingesting changes continuously, maintaining transformations incrementally, and serving indexed results without recomputing the full query on each read.

This enables an interactive agentic feedback loop: an agent observes current state, takes an action in a system of record, sees the resulting change through Materialize, and uses that evidence to choose its next step. Materialize reports p99 end-to-end latency of single digit seconds or less observed in production; actual reaction time depends on the source, transformation, index, and workload.

- [Reaction time, freshness, and query latency](https://materialize.com/docs/concepts/reaction-time/): Understand the components of reaction time and how to measure freshness.

## Where Materialize fits

- Operational databases remain authoritative systems of record for transactional writes. Materialize consumes their change streams and maintains the integrated, read-optimized context used by agents and applications.
- Kafka and event streams carry individual changes. Materialize turns those changes into current, queryable business state and can publish meaningful updates downstream.
- Warehouses and lakehouses support historical exploration and large analytical scans. Materialize supplies live operational context and can deliver data products to Apache Iceberg for historical analysis.
- Search and vector databases provide retrieval. Materialize computes search-ready entities, keeps attributes and embedding inputs current, and emits entity-level changes for precise index updates.
- MCP tools and APIs expose capabilities to agents. Materialize precomputes and governs the data products behind those tools, reducing request-time work and supplying typed, current context.

## Product and operations

- [Ingest data](https://materialize.com/docs/ingest-data/): Connect databases, Kafka, webhooks, and files using change data capture and native integrations.
- [Transform data](https://materialize.com/docs/transform-data/): Build and optimize continuously maintained SQL transformations.
- [Serve results](https://materialize.com/docs/serve-results/): Query maintained results, subscribe to changes, and publish updates downstream.
- [Troubleshooting](https://materialize.com/docs/transform-data/troubleshooting/): Diagnose slow queries, lagging dataflows, snapshotting, hydration, memory usage, and unhealthy clusters.
- [Support](https://materialize.com/docs/support/): Find support channels and community resources.
- [Service status](https://status.materialize.com/): View current availability and incident history.
- [Release notes](https://materialize.com/docs/releases/): Check current feature status, improvements, and compatibility information.
- [Pricing](https://materialize.com/materialize-pricing/): Cloud pricing, free trial availability, Self-Managed Community and Enterprise licenses, and cluster capacity.

## Optional

- [Live Context Graph architecture](https://materialize.com/docs/architecture-patterns/live-context-graph/): Model business objects and their relationships as composable, continuously updated data products.
- [Search Is How Agents See the World](https://materialize.com/blog/agent-search/): Why search freshness becomes a correctness requirement for autonomous agents.
- [Context Graphs at Agent Scale](https://materialize.com/blog/happy-writers-happy-readers/): Why incremental context assembly serves both flexible operational writers and agent readers.
- [Customer stories](https://materialize.com/customer-stories/): Production architectures and results from Bilt Rewards, Day AI, Neo Financial, Vontive, and other customers.
- [Materialize GitHub](https://github.com/MaterializeInc/materialize): Source code, license, development, and contribution information.
- [Materialize blog](https://materialize.com/blog/): Conceptual articles, product announcements, and engineering deep dives.