# System Overview

This page gives a high-level view of how the main developer-facing and network-facing repos fit together.

## High-level architecture

```
Application
  |                         Rust / CLI
  | REST or gRPC                |
  v                             v
 antd                      ant-core / ant
  |                             |
  +-------------+---------------+
                |
                v
             ant-node
                |
                v
            saorsa-core
                |
                v
         saorsa-transport
                |
                v
            Autonomi peers
```

## Developer interfaces

The main developer entry points are:

* `ant-sdk`, centered on the `antd` daemon plus language SDKs
* `ant-client`, centered on `ant-core` and the `ant` CLI

These interfaces target the same network, but one uses a local daemon and the other connects directly from Rust or CLI code.

## Network and node layer

The `ant-node` crate builds on `saorsa-core::P2PNode`. It adds configuration, chunk storage, payment verification, replication, upgrade handling, and node runtime management on top of the core P2P layer.

`ant-core` and `ant-node` also share wire-message types, payment-proof types, and devnet manifest types through `ant-protocol`.

In the repos used for this page, `ant-node` documents chunk storage as its active network data type.

## Routing and transport

`saorsa-core` provides the P2P node, DHT, bootstrap handling, trust system, and routing-table logic around typed addresses and peer identity. It is also responsible for publishing dialable self-addresses and coordinator hints into DHT records. `saorsa-transport` provides QUIC transport, NAT traversal, address discovery, and relay fallback where direct hole punching is not enough.

The transport story includes:

* observed-address discovery and address propagation across the network
* reachability tracking by scope: loopback, local-network, or global
* best-effort UPnP port mapping as an extra public candidate on compatible routers
* peer-ID-based hole-punch coordination, with coordinator hints and coordinator rotation when one path cannot help
* relay fallback for some CGNAT cases
* QUIC-based post-quantum transport security centered on ML-KEM-768 and ML-DSA-65

That post-quantum framing applies to transport identity and session establishment. Content self-encryption remains a separate client-side layer built around BLAKE3 and ChaCha20-Poly1305.

## Data path

On the client side, `self_encryption` turns uploaded content into a `DataMap` plus encrypted chunks. Developer-facing clients such as `antd` and `ant-core` prepare and retrieve that content, while `ant-node` stores and serves chunk data across the network.

## Upstream sources

* [ant-sdk](https://github.com/WithAutonomi/ant-sdk)
* [ant-client](https://github.com/WithAutonomi/ant-client)
* [ant-node](https://github.com/WithAutonomi/ant-node)
* [ant-protocol](https://github.com/WithAutonomi/ant-protocol)
* [self\_encryption](https://github.com/WithAutonomi/self_encryption)
* [saorsa-core](https://github.com/saorsa-labs/saorsa-core)
* [saorsa-transport](https://github.com/saorsa-labs/saorsa-transport)
* [saorsa-pqc](https://github.com/saorsa-labs/saorsa-pqc)

## Related pages

* [Core Concepts Overview](/developers/core-concepts/overview.md)
* [SDK Overview](/developers/sdk/install/reference/overview.md)
* [Using the Autonomi CLI](/developers/cli/use-the-cli.md)
* [Developing in Rust](/developers/developing-in-rust/rust.md)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.autonomi.com/developers/architecture/system-overview.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.