Gravity Network

The Gravity Network is Agentuity's infrastructure layer that powers all platform services. Rather than building monolithic, tightly-coupled systems, we've architected everything as composable primitives that stack on top of each other.

Layered Architecture

Agentuity is built on a layered primitive model. Each layer provides building blocks for the layers above it, creating a flexible and powerful foundation.

Core Primitives

At the foundation, we have core primitives that nearly everything else is built upon:

These core primitives are intentionally generic and protocol-based. Storage speaks S3. Databases speak standard wire protocols. This design enables portability and flexibility at the infrastructure level.

Platform Primitives

On top of the core primitives, we build higher-level platform primitives:

These primitives use the Core Primitives but don't depend on each other horizontally. They only reach down the stack, never up.

Application Services

The highest layer provides application-level services that combine multiple Platform Primitives:

For example, an inbound email service works like this:

1. Email arrives at the Agentuity email service
2. The email is processed by a preconfigured webhook
3. An event is placed on the queue
4. This triggers the Agent Runtime where you can process the email
5. Store the email in Storage for long-term retention

Each service is composed from lower-level primitives rather than built from scratch.

Why This Matters

Composability: Higher-level services are built from lower-level primitives. Need a new capability? Combine existing primitives rather than building from scratch.

Portability: Because Core Primitives use standard protocols, the underlying infrastructure can be swapped. Your workloads aren't locked into proprietary systems.

Reliability: Built on battle-tested primitives like Postgres and S3, not experimental infrastructure. Your agents run on foundations that have proven themselves at scale.

Agentic: Since you can peek behind the curtain and see what's happening across these abstractions, your agents can too. This creates better context and feedback loops, allowing your agents to build software quickly and effectively.