Platform Architecture

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:

• Python / FastAPI services
• SQS for background task queues; Redis for event streaming and caching
• PostgreSQL for metadata
• Containerized services on managed cloud orchestration

2. Sandbox Environment

Responsibilities:

• Isolated execution environment
• Filesystem management
• Terminal access
• Browser automation
• Snapshot management

Technology:

• Docker containers
• Persistent volumes
• Chromium for browser
• Linux (Ubuntu 22.04)

Isolation:

• GKE 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
• Version management

Technology:

• Vector store (Pinecone) with Bedrock Cohere embeddings
• Document storage in cloud object storage (GCS for synced KB assets)
• Sync jobs via kb-sync-worker (SQS)

Features:

• Semantic search (not just keyword)
• Multi-source aggregation
• Real-time sync
• Version history

4. Integration Layer

Responsibilities:

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

Technology:

• tools-service-mcp (OAuth token storage, encrypted)
• flow-workers (webhook ingest → SQS → agent runs)
• Redis (token cache, 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 Flow

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: Unlimited parallel execution
• API: Auto-scaling based on load
• Knowledge: Distributed search
• Integrations: Rate-limited per service

Performance Characteristics

Metric	Performance
Agent response time	< 2s (median)
Sandbox start time	< 5s (cold start)
Snapshot creation	< 1s (incremental)
Knowledge search	< 500ms
API latency	< 100ms (p95)
Webhook processing	< 200ms

Load handling

Auteryn runs on cloud infrastructure (AWS for agent runtime, GCP for sandboxes) with horizontal scaling. Contact enterprise@auteryn.ai for high-volume deployment guidance.

---

Security Architecture

Defense in Depth

Multiple security layers:

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

Encryption

All data encrypted:

• At rest: AES-256 encryption
• In transit: TLS 1.3
• Credentials: Separate encryption key per customer
• Backups: Encrypted snapshots

Compliance

• Compliance — Enterprise customers can discuss DPAs and audit requirements with our team
• GDPR - EU data residency available
• CCPA - California privacy compliance
• HIPAA - Available for Enterprise (BAA required)

Learn more about security →

---

Reliability & Availability

High Availability

Infrastructure:

• Multi-region deployment
• Automatic failover
• Load balancing
• Health checks

Availability: Multi-region cloud deployment with health checks and failover patterns. Enterprise customers can discuss SLAs with our team.

Disaster recovery

Backup strategy:

• Database backups with encryption
• Sandbox filesystem snapshots (GCS)
• Cross-region options for Enterprise

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

Alerting: Internal monitoring with on-call escalation for Enterprise (contact sales for details).

---

Technology Stack

Backend

• API: Python, FastAPI
• Database: PostgreSQL
• Cache & streaming: Redis
• Queue: SQS
• Search: Vector store with semantic embeddings for knowledge retrieval

Infrastructure

• Agent runtime: Containerized services on AWS
• Sandboxes: GKE Autopilot (GCP)
• Storage: Cloud object storage (GCS)
• Network: VPC isolation, CDN edge delivery
• Monitoring & logging: Metrics, dashboards, and centralized logs with alerting

Frontend

• Console: React 18, TypeScript
• Docs: Astro, Starlight
• Widget: Vanilla JS (no dependencies)

---

API Design

RESTful Principles

All APIs follow REST conventions:

• Resources: /agents, /tasks, /messages
• Methods: GET, POST, PUT, DELETE
• Status codes: 200, 201, 400, 401, 404, 500
• Pagination: Cursor-based
• Versioning: /v1/, /v2/

Rate Limiting

Protect against abuse:

Plan	Rate Limit	Burst
Free	60 req/min	100
Starter	300 req/min	500
Pro	1,000 req/min	2,000
Enterprise	Custom	Custom

Webhooks

Event-driven architecture:

{
  "event": "agent.task.completed",
  "timestamp": "2026-04-02T10:15:23Z",
  "agent_id": "agent_123",
  "task_id": "task_456",
  "status": "success",
  "data": { ... }
}

API documentation →

---

Performance Optimization

Caching Strategy

Multi-level caching:

1. Browser cache - Static assets (24 hours)
2. CDN cache - Global edge caching
3. API cache - Redis (5 minutes)
4. Database cache - Query results

Async Processing

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

# Queue a run in the background — returns task_id and run_id right away
POST /api/run/async

# Stream events or check status as the run progresses
GET /api/tasks/{task_id}

Parallel Execution

Because each agent runs in its own isolated sandbox, many tasks execute in parallel across the platform. Submit multiple async runs and they proceed independently.

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 external service via a Custom API integration or an MCP server, then attach it to an agent. See Integrations and Custom API.

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 flows

Trigger agents from external events or schedules with Flows — for example, run an agent whenever a GitHub issue is opened or on a weekly cron.

---

Roadmap

Coming Soon

• GPU support - For ML workloads (Enterprise)
• Custom regions - Deploy in your preferred region
• VPC peering - Connect to your private network
• Audit logs API - Programmatic access to logs

Under Consideration

• On-premise deployment - Self-hosted option
• Air-gapped environments - For high-security needs
• Custom LLM models - Bring your own model
• Edge deployment - Run agents closer to users

View changelog →

---

Resources

• API Documentation
• Security Architecture
• Best Practices
• System Status

---

Questions?

• What cloud provider do you use? Auteryn runs across AWS (agent runtime) and GCP (sandbox compute on GKE Autopilot).
• Can I deploy on-premise? Enterprise customers can request on-premise deployment.
• How do you ensure uptime? Multi-region deployment, automatic failover, 24/7 monitoring.
• What about data residency? EU and US regions available. Custom regions for Enterprise.
• Can I audit the infrastructure? Enterprise customers can request security documentation and discuss audit requirements with our team.

View all FAQs →