Platform Architecture

Understanding how Auteryn works under the hood. This guide covers the technical architecture, design decisions, and how components work together.

High-Level Architecture

┌─────────────────────────────────────────────────────────────┐
│                      Auteryn Platform                       │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌────────────────┐      ┌──────────────────┐              │
│  │  Web Console   │      │   REST API       │              │
│  │  (Dashboard)   │◄────►│   (Public)       │              │
│  └────────────────┘      └──────────────────┘              │
│                                   │                          │
│                                   ▼                          │
│  ┌──────────────────────────────────────────────┐          │
│  │         Agent Orchestration Layer            │          │
│  │  - Agent lifecycle management                │          │
│  │  - Task scheduling & execution               │          │
│  │  - Event routing & webhooks                  │          │
│  └──────────────────────────────────────────────┘          │
│                    │              │                          │
│         ┌──────────┴──────┬───────┴──────┐                 │
│         ▼                 ▼              ▼                  │
│  ┌──────────┐      ┌──────────┐   ┌──────────┐            │
│  │ Sandbox  │      │ Sandbox  │   │ Sandbox  │            │
│  │ Agent A  │      │ Agent B  │   │ Agent C  │            │
│  │          │      │          │   │          │            │
│  │ - Files  │      │ - Files  │   │ - Files  │            │
│  │ - Shell  │      │ - Shell  │   │ - Shell  │            │
│  │ - Browser│      │ - Browser│   │ - Browser│            │
│  └──────────┘      └──────────┘   └──────────┘            │
│                                                              │
│  ┌──────────────────────────────────────────────┐          │
│  │         Knowledge Layer                      │          │
│  │  - Vector database (embeddings)              │          │
│  │  - Document storage                          │          │
│  │  - Semantic search                           │          │
│  └──────────────────────────────────────────────┘          │
│                                                              │
│  ┌──────────────────────────────────────────────┐          │
│  │         Integration Layer                    │          │
│  │  - OAuth management                          │          │
│  │  - API proxies                               │          │
│  │  - Webhook receivers                         │          │
│  └──────────────────────────────────────────────┘          │
│                                                              │
└─────────────────────────────────────────────────────────────┘

Core Components

1. Agent Orchestration Layer

Responsibilities:

Agent lifecycle (create, start, stop, delete)
Task scheduling and execution
Event routing and webhooks
Resource allocation
Load balancing

Technology:

Containerized services on managed cloud orchestration
A managed relational database for agents, conversations and runs
Background queues and an in-memory store for run events and caching

2. Sandbox Environment

Responsibilities:

Isolated execution environment
Filesystem management
Terminal access
Browser automation
Snapshot management

Technology:

Isolated containers on managed cloud infrastructure
Filesystem snapshots kept in cloud object storage
Chromium for the browser
Debian-based Linux

Isolation:

Container boundary per sandbox session
Filesystem restricted to /workspace
Resource limits (CPU, memory, disk)

3. Knowledge Layer

Responsibilities:

Document ingestion and indexing
Semantic search
Source synchronization

Technology:

A managed vector index, searched by meaning through text embeddings
Document storage in cloud object storage
Sync jobs that run on a background queue

Features:

Semantic search (not just keyword)
Multi-source aggregation
Sync on demand or on a schedule (hourly, daily or weekly, by plan)

4. Integration Layer

Responsibilities:

OAuth flow management
API credential storage
Webhook routing
Rate limiting
Error handling

Technology:

Connection credential store (OAuth tokens, encrypted)
Loop event intake (webhooks are queued, then start agent runs)
A cache for tokens and event fan-out

Data Flow

Agent Execution Flow

1. User sends message/trigger
   ↓
2. Orchestration layer receives request
   ↓
3. Agent instructions loaded
   ↓
4. Knowledge queried (if needed)
   ↓
5. Sandbox executes task
   ↓
6. Integrations called (if needed)
   ↓
7. Response streamed to user

Event-driven runs (Loops)

1. External event occurs (GitHub PR, Jira ticket)
   ↓
2. Webhook received by integration layer
   ↓
3. Event routed to configured agent
   ↓
4. Agent processes event in sandbox
   ↓
5. Actions executed (comment, update, notify)
   ↓
6. Event marked complete

Scalability

Horizontal Scaling

Auteryn scales horizontally:

Sandboxes: one per agent, so different agents work in parallel
API: scales automatically with load

A new sandbox can take a minute or two to start when the platform has to add capacity; the workspace shows Preparing computer… meanwhile.

Load handling

Auteryn runs on cloud infrastructure with horizontal scaling. Email contact@auteryn.ai for high-volume deployment guidance.

Security Architecture

Defense in Depth

Multiple security layers:

Network Layer - VPC isolation, firewall rules
Application Layer - Authentication, authorization
Data Layer - Encryption at rest and in transit
Sandbox Layer - Container isolation, resource limits

Encryption

At rest: databases and object storage are encrypted
Credentials: Connection credentials and OAuth tokens are also encrypted with AES-256-GCM
In transit: TLS 1.2 or higher
Backups: database backups are encrypted

Compliance

Enterprise customers can discuss DPAs, data residency and audit requirements with our team.

Learn more about security →

Reliability & Availability

High Availability

Infrastructure:

Services run in more than one availability zone
Load balancing
Health checks
Automatic scaling

Status: live service status is at status.auteryn.ai.

Disaster recovery

Backup strategy:

Database backups with encryption
Sandbox filesystem snapshots in cloud object storage

Recovery: Contact security@auteryn.ai for enterprise RPO/RTO requirements.

Monitoring

What we monitor:

API response times
Sandbox health
Integration status
Error rates
Resource usage

Technology Stack

Infrastructure

Agent runtime: Containerized services
Sandboxes: Isolated containers
Storage: Cloud object storage
Knowledge search: a vector index with semantic embeddings
Network: VPC isolation, CDN edge delivery
Monitoring & logging: Metrics, dashboards, and centralized logs with alerting

Frontend

Console: React 18, TypeScript
Docs: Astro, Starlight
Widget: Preact, running in a frame on Auteryn’s own origin

API Design

Conventions

Base URL: https://agent-api.auteryn.ai, with every route under /api/
Main routes: POST /api/run runs an agent and streams the reply as Server-Sent Events; POST /api/run/async runs it in the background; /api/tasks reads conversations, their messages and their runs with a member token, or in the workspace; an agent token reaches only a task’s stream and cancel (see Agent token scope)
Methods: GET, POST, PATCH, DELETE
Status codes: standard HTTP codes, listed in Errors & rate limits
Pagination: a run’s events page with a cursor (GET /api/runs/{run_id}/events); lists take a limit

Rate Limiting

Limits apply per organization and user, the same on every plan. By default POST /api/run takes 30 requests a minute. A 429 response has a Retry-After header: wait that long before you retry. See Errors & rate limits.

Webhooks

Inbound webhooks start Loops. Auteryn does not call you back when a run finishes: read the result through the API (see Async & background runs).

API documentation →

Performance Optimization

Async Processing

Long-running tasks run asynchronously. Submit a run to the async endpoint and it’s queued for background processing; you get the run and task IDs at once and can check its status or stream its events until it completes.

# Queue a run in the background: returns 202 with the run id and task_id right away
POST /api/run/async

# Check progress, or stream the task's events as the run goes
GET /api/run/{task_id}/status
GET /api/tasks/{task_id}/stream

Parallel Execution

Each agent has its own isolated sandbox, so different agents work in parallel. Runs of the same agent share its sandbox: one uses it at a time, and the others wait for their turn.

See the API reference for the full request and response shapes.

Extensibility

Auteryn is designed to be extended without writing platform code. You shape what an agent can do through configuration:

Custom integrations

Connect any service that has an MCP server through a Custom MCP integration, then attach it to an agent. See Integrations and Custom MCP & webhooks.

Custom skills

Author reusable workflows — a standard operating procedure the agent follows for a given task type — and enable them on your agents. See Skills.

Event-driven Loops

Trigger agents from external events or schedules with Loops: run an agent whenever a GitHub issue is opened, or every week.

Resources

Questions?

Can I run agents on my own hardware? Yes. On paid plans, Internal agents can run on your own Linux machine. See Run agents on your machine.
How do you keep it up? Services run in more than one availability zone behind load balancers, with health checks, automatic scaling and monitoring.
What about data residency? Data is stored and processed primarily in the United States; there is no EU or custom region today.
Can I audit the infrastructure? Enterprise customers can request security documentation and discuss audit requirements with our team.

View all FAQs →