Federation stays open
Rooms and messages cross organizational boundaries through the standard Matrix server-server API, directly and without protocol conversion.
Matrix + AWS serverless
Serverless Matrix messaging on AWS.
Neurons is a complete messaging product and an AWS-native alternative to operating a traditional, always-on Synapse-style stack. It implements Matrix server-server federation while delivering the Neurons web client through a real-time AppSync Events channel.
- Matrix server-server federation
- Push-based client updates
- Customer-owned AWS data plane
What the term means
Matrix interoperability with capacity that follows demand.
Neurons delivers serverless Matrix messaging as an integrated product, combining a dedicated web client with an AWS-native backend. Implemented client operations use standard Matrix client-server API contracts and event formats. The Neurons web client receives synchronization updates through real-time WebSocket push, while federation uses the standard Matrix server-server API directly.
Runtime capacity follows demand
Lambda and managed AWS services execute as messaging events arrive, allowing runtime activity to contract during idle periods and expand with demand.
The client becomes reactive
AWS AppSync Events replaces long-polling /sync with WebSocket push, avoiding held HTTP requests that are a poor cost and execution-model fit for a Lambda-based runtime.
AWS-native architecture
Managed services form the messaging runtime.
Java and Quarkus microservices are compiled natively with GraalVM and deployed as AWS Lambda functions. AppSync Events provides the real-time client channel, DynamoDB stores event-driven state, and S3 stores attachment payloads. IAM and CloudWatch complete the deployment's access-control and operational boundary.
Serverless shifts capacity planning from pre-sized application instances to managed services that respond to demand. Production capacity remains governed by configured AWS quotas, workload characteristics, deployment limits and operational policies.
Compatibility boundary
Standard Matrix APIs with a serverless synchronization channel.
Neurons uses standard Matrix client-server API contracts and event formats for its
implemented client operations. Synchronization is the deliberate channel change:
AppSync Events WebSocket push replaces long-polling /sync. Federation is a
separate boundary implemented through the standard Matrix server-server API.
| Layer | Neurons implementation | Practical consequence |
|---|---|---|
| Server-server federation | Standard Matrix federation APIs | Rooms and messages interoperate with Synapse and other Matrix homeservers without protocol conversion. |
| Client-server API | Standard Matrix contracts for implemented client operations | Requests, responses, and event formats remain Matrix-native rather than introducing a product-specific messaging protocol. |
| Client synchronization | AppSync Events WebSocket push replacing long-polling /sync | The Neurons web client consumes push updates; standard Matrix clients expect the HTTP /sync channel. |
| End-to-end encryption | matrix-sdk-crypto in participating clients | Messages and attachments use Matrix-compatible E2EE while federation connects homeservers. |
Neurons and Synapse
A serverless Synapse alternative with a distinct operating model.
Neurons preserves standard Matrix federation, API contracts and event semantics while
replacing Synapse's always-on server model with customer-owned AWS serverless services
and real-time push delivery. It adds elastic operation, a clearer customer data-plane
boundary and a foundation for domain products. The deliberate trade-off is client
compatibility: standard Matrix clients that depend on HTTP /sync cannot
connect unchanged.
A more modern operating model for Matrix messaging.
- Managed AWS services scale from idle with demand instead of requiring pre-provisioned homeserver compute.
- AppSync Events pushes updates over WebSockets instead of holding long-polling
/syncconnections. - Runtime services and customer data stay in a dedicated customer AWS account.
- Standard Matrix federation is preserved directly and without protocol conversion.
- The same secure messaging foundation can support domain-specific products.
Existing Matrix clients can connect unchanged.
- Standard clients can continue using the HTTP
/syncchannel they already support. - The broader standard client-server API surface is available without adopting the Neurons web client.
When broad drop-in client compatibility is not mandatory, Neurons provides the stronger fit for elastic, customer-owned AWS operation.
Technical questions
What to verify in an evaluation.
Is Neurons a Matrix homeserver?
Neurons fulfils the homeserver role for its dedicated web client. Implemented client operations use standard Matrix contracts and event formats, while AppSync Events supplies WebSocket synchronization. Federation uses the standard server-server API directly.
Can Neurons federate with Synapse?
Yes. Matrix server-server interoperability is a core product boundary, allowing rooms and messages to federate with Synapse and other compatible homeservers.
How does serverless capacity scale?
The runtime responds elastically within AWS quotas, configured limits and workload characteristics. Capacity testing remains part of a production deployment.
Can we use Element as the primary client?
The current synchronization channel is built for the Neurons web client. Element expects the standard long-polling /sync endpoint, while Neurons delivers the same Matrix-native event model through AppSync Events WebSocket push.
Early Access · September 2026
Evaluate serverless Matrix messaging in your AWS account.
The initial cohort is limited to five organizations and uses a paid, fixed-scope technical evaluation with agreed success criteria.
Apply for Early Access