A high-throughput distributed compute network powered by Apple Silicon Macs. REST API for async job processing and Server-Sent Event (SSE) streaming. Pay per token, no commitments, no quotas. EU-sovereign by design.
Utility Tier compute: data is protected in transit via standard TLS but is not processed in isolated hardware memory. Designed for non-sensitive public data, web scraping, and synthetic data generation. You are responsible for sanitizing all PII and PHI client-side before submission.
Pricing is optimized for generative workloads (Chatbots & Agents) using our 1:20 Generative Envelope. For every 1 input token you buy, you get up to 20 output tokens included. You pay strictly for the prompt. The generation is on us.
Four layers of defensive architecture engineered specifically for distributed Apple Silicon nodes.
Eliminate “garbage in, garbage out” at the edge.
Strict schema validation on every ingress point. Runtime type-safety drops malicious payloads — like strings injected into numerical fields — before they ever touch the logic layer. This architecture is what maintained stability during our 1B-entry stress test.
Mitigate supply-chain attacks and human error.
Our CI/CD pipeline integrates Static Analysis Security Testing to audit the codebase in real-time. It proactively hunts for leaked secrets, insecure dependencies, and logical hidden holes, keeping the stack enterprise-ready and resilient against automated exploits.
Signature-based AV is too high-latency for real-time streams.
Rigid application-layer verification designed for telemetry packets. The gateway enforces strict schema matching and validation constraints on all incoming payloads, dropping malformed inputs or irregular parameters before they can touch downstream processing node loops.
Defending distributed communication vectors.
Multi-layered transit cryptography. All data payloads routed across the orchestrator plane to processing edge nodes are encapsulated within secure TLS 1.3 cryptographic tunnels, protecting data-in-transit from structural interception risks.
A scalable backbone purpose-built to coordinate, visualize, and persist a global DePIN fleet.
High-concurrency persistence with deterministic tracking.
A battle-tested relational database featuring native Row-Level Security (RLS) and continuous, timestamped system audit trails. It serves as the authoritative cloud coordinator for the DePIN network, managing global authentication and active worker state at scale.
Precision rendering without the overhead of heavy GIS suites.
SVG-based vector grid rendering powers our Command Center — a lightweight, government-grade geospatial interface for the Copenhagen Genesis Node with sub-millisecond interaction speeds.
Synchronous UI/UX for asynchronous hardware.
Advanced cache management and optimistic UI updates keep the dashboard in sync with Mac Mini M4 hardware. Our Live Throughput telemetry uses high-frequency polling to visualize network health without a single page refresh.
Ship without breaking the swarm.
Atomic edge rollouts with instant global propagation and one-click rollback. Versioned worker contracts let us push new dispatcher logic to thousands of Mac Mini M4 nodes without dropping a single in-flight job — the fleet keeps earning while we deploy.
Every node in our fleet is a Mac running inside Apple's own walled garden — the same hardware-rooted trust model that protects two billion consumer devices, now coordinating sovereign AI compute.
Native macOS credential storage isolated from configuration files.
Nodes leverage native macOS storage frameworks, using the system Keychain to isolate and persist host authentication credentials. Network identity tokens never sit in plaintext configuration files. Execution sandboxing relies on standard operating-system process segmentation and memory access controls.
Trust starts before the kernel does.
Apple Silicon enforces a cryptographically verified boot process from the hardware Boot ROM up through the signed system kernel. Host edge environments inherit this secure execution sequence, providing a tamper-resistant system runtime baseline before processing any jobs.
The same separation perimeter used to isolate system runtimes.
The inference daemon executes inside an independent, local process memory space bound strictly to a non-public loopback interface (127.0.0.1). By restricting local port exposure, buyer processing workloads are segmented away from standard remote execution entryways.
Inference never leaves the silicon.
All token generation runs on the Apple Neural Engine and unified memory of the M4 — no PCIe bus, no external GPU, no hyperscaler tenancy. The attack surface of a traditional cloud GPU (shared VRAM, side-channel leakage, hypervisor escapes) simply does not exist on our fleet.
A typical hyperscaler GPU instance trusts the hypervisor, the firmware, the driver stack, and the shared tenancy layer — four perimeters you don't control. Our Apple Silicon fleet collapses that chain into localized, hardware-rooted execution perimeters. The result is a measurably tighter containment boundary and a significantly smaller attack surface for your live inference workloads.
To achieve maximum throughput on the depin.as grid, we recommend optimizing your data density before submission. While our architecture supports massive concurrency, the speed of your upload and subsequent processing is heavily influenced by Request Volume versus Data Volume.
The Performance Principle: High Density, Low Overhead
Every document submitted to the grid requires a cryptographic handshake, database indexing, and a security scan. If you submit 100,000 documents of 1KB each, you incur the "latency tax" of 100,000 individual operations.
For optimal performance:
| Feature | Fragmented Data (Sub-optimal) | High-Density Data (Optimized) |
|---|---|---|
| Document Size | 1KB - 50KB | 1MB - 10MB |
| Network Overhead | High (Per-request latency) | Low (Sustained throughput) |
| Processing Speed | Limited by I/O handshakes | Limited only by Node CPU |
| Effective Cost | Standard | Maximum ROI |