April 25, 2026 · Eyes Only · Confidential · Internal Use Only
Eyes Only — Confidential
Soma · AI-Native Cloud Platform

# Full Implementation Plan

Six phases. One substrate. The complete build plan for Soma — from internal inference router to the infrastructure layer that quietly consumes its providers.

## Executive Summary

Soma is the cloud platform Neuron Technologies is building — not as a startup play to compete with AWS on price, but as the infrastructure substrate the entire Neuron ecosystem runs on, which will scale into a platform offered to external customers and eventually leverage its providers into acquisition conversations from a position of dependency.

The premise is simple and has almost no precedent: an AI-native cloud where the operator is an AI, the routing intelligence is patented, and the economics improve automatically as open-source models improve and GPU costs fall. Soma doesn't have human ops engineers. Neuron runs it.

The cloud providers will see growing revenue. Their customers will come to us. By the time anyone understands what happened, Soma is the largest single customer of at least one provider region — and the negotiating table looks very different from that chair.

In the near term, Soma's primary value is internal: running Neuron's inference at effectively zero marginal cost because Soma is the infrastructure and Neuron is the AI that manages it. Every Neuron AI license sold has a delivery cost that approaches zero. That's the business model in one sentence.

The 5-year arc: internal-only substrate → multi-provider abstraction → external customer platform → significant provider spend (leverage building) → data center acquisitions → acquisition offers from leverage, not desperation.

Soma's moat is not the models. Models are commodities. The moat is the backplane — the routing intelligence, the provider abstraction, the Neuron operator interface — all protected by patents before the architecture is disclosed.

## Strategic Context

The cloud industry's structural weakness is that every major provider depends on growing their retail customer base. If a sufficiently large customer routes all new workloads through a single abstraction layer — one the provider can't see inside — the provider loses the direct relationship, the usage data, and eventually the retail customers who follow the abstraction.

The consumption strategy has four phases, and providers are participants in all of them without knowing it:

Phase one: Soma runs on provider infrastructure. They see growing revenue. Customers sign NDAs. They don't disclose where Soma runs. Providers don't know what's happening inside Soma's abstraction — they see API calls and billing.
Phase two: Soma grows. Provider spend grows. Anti-concentration rules keep no single provider above 60% — they all see healthy revenue but none sees the full picture.
Phase three: Physical data centers, acquired quietly. Unglamorous facilities, not headlines. Neuron manages them. Cost per compute unit collapses.
Phase four: Providers can't afford to lose Soma's spend. Acquisition offers arrive, or Soma makes them. Either way, the negotiating position is leverage — not supplication.

The cover story is completely true and reveals nothing: "Our cloud spend is enormous." Yes. That's correct. That's all they get to know.

Meanwhile, the Dharma R&D lab continuously widens the capability gap. Every six months that Soma runs, the moat deepens: more patent coverage, more routing intelligence, more operational data that trains better cost optimization. The compounding is structural.

Why this works at all: Neuron (the AI) manages Soma operationally. No human ops team. Operational costs are near zero. Open-source model improvements and falling GPU costs improve Soma's economics automatically — without any action from us. The flywheel self-accelerates.

> "The intelligence is in the backplane, not the models. The backplane is ours."

Soma Architecture Principle · Internal

## Full Service Catalog

Soma offers a complete cloud platform. Services are organized by category. AI-native services are Soma's primary differentiator — these are not retrofitted onto a general-purpose cloud. They are the reason Soma exists.

AI-Native Services
Inference Router
Intelligent LLM request routing across three compute tiers. Low (8B models, ~$0.40/hr), Medium (13–34B, balanced), High (70B+, ~$1.75/hr). Deterministic routing tree — every decision is auditable.
Core Differentiator
Image Generation
Dedicated compute for image workloads. 10 checkpoint models including lustify, juggernaut, flux, illustrious. Intelligent LoRA selection via LLM reasoning. SD Forge backend.
AI-Native
Video Generation
SVD XT on dedicated GPU. Separate from inference pool — video workloads have distinct latency profiles and memory requirements.
AI-Native
Model Registry
Versioned catalog of all available models with routing metadata, capability tags, cost profiles, and availability status. The authoritative source the Router queries.
Core Infrastructure
Pipeline Engine
22-step async pipeline system inherited from Pantheon conductor. Event-driven, step-level observability, dead-letter handling, priority queues.
Core Differentiator
AI Workload Environments
Four environment profiles: Studio (full creative suite), Mini (lightweight inference), Crucible (H200-scale training/merging), Production (always-on routed inference).
Core Differentiator
Compute
Containers
Docker-compatible container deployment to the multi-provider node pool. Soma selects the optimal node — provider, region, and tier — transparently.
Functions
Serverless, event-triggered execution. Scales to zero between invocations. Ideal for webhook handlers, background jobs, and lightweight data processing.
VMs
Full virtual machines for workloads that need dedicated isolation, specific kernel versions, or persistent state that containers don't suit.
GPU Instances
First-class GPU allocation. Tier-aware provisioning — the right GPU for the job, across RunPod, Legion, or cloud provider spot pools, without the customer specifying provider.
Networking
Load Balancers
HTTP/HTTPS with health checks, SSL termination, weighted routing, and sticky sessions. Provider-agnostic — the same config works regardless of where the backends run.
API Gateway
AI-native: semantic routing, intent-based rate limiting, auth, versioning, usage analytics. Not a generic proxy — understands the shape of AI workloads.
AI-Native
DNS Management
One zone, works across all providers and regions. Customer configures DNS once — Soma handles propagation and failover as backends move.
VPC / Private Networks
Spans providers transparently. Customer-isolated. Private traffic between Soma services never traverses the public internet.
Firewall
Rules defined once, enforced everywhere. Soma translates declarative firewall config to provider-native rules — AWS security groups, GCP firewall rules, etc.
CDN
Edge caching and asset delivery. Tightly integrated with Soma Object Storage — assets uploaded there are automatically available at edge.
Data
Object Storage
S3/R2-compatible blob storage. Model weights, artifacts, training datasets, generated assets. Cryptographically separated per customer namespace.
Managed Databases
Postgres and Redis, managed. Automated backups, HA configuration, point-in-time recovery. Customer doesn't manage the underlying cluster.
Block Storage
Persistent volumes for containers and VMs. Provider-agnostic — a volume provisioned against a Legion node looks identical to one on AWS.
Message Queues
Async job processing with dead letter queues, priority queues, and visibility timeouts. Foundation of the Pipeline Engine's step execution model.
Security & Identity
Secrets Management
Vault-backed, auto-rotated, customer-isolated. No customer ever touches another's secrets namespace. The same secret delivery mechanism Neuron itself uses.
API Keys
Scoped, revocable, usage-tracked. Every API key is bound to a customer namespace and a permission scope — no ambient authority.
IAM
Role-based access control, team management, audit logs. Every action through Soma is attributed, logged, and queryable.
Customer Isolation
Hard multi-tenancy: separate Vault namespaces, cryptographically separated storage buckets, VPC-level network isolation. Enforced at the infrastructure layer, not application logic.
Architectural Property

## Architecture — Volatility-Based Decomposition

Soma's architecture is organized by volatility tier — how frequently a component changes. Stable components define the contracts. Variable components implement the policies. Dynamic components reflect live state. This decomposition keeps the stable API surface clean while allowing aggressive iteration on the components that need to evolve.

Soma System Diagram — VBD Volatility Swim Lanes

## Component Breakdown

Stable (contract layer — rarely changes):

Storage Layer
S3-compatible API contract. Implemented on R2 today; provider can change without touching anything above.
Model Catalog
Schema and interface contract. Models are added; the schema does not change.
Secrets Interface
Vault API contract. Customer namespace model baked in — cannot be changed without breaking isolation guarantees.
Neuron Operator Interface
Command protocol between Neuron and Soma. Stable because it is the language Neuron speaks to manage the platform.

Variable (policy layer — changes with requirements):

Soma Router
Routing rules, tier definitions, model selection logic. Evolves as the model landscape and pricing change.
Node Pool
Fleet composition and provider mix. Grows as new providers are onboarded. Anti-concentration rules enforced here.
Pipeline Engine
Step configurations, pipeline definitions. New pipeline types added without core changes.
API Gateway Rules
Auth, rate limiting, routing configuration. Customer-specific rules without platform rebuilds.

Dynamic (state layer — continuously changing):

Control Plane
Live node state, health, capacity. Updated on every heartbeat from every node in the pool.
Cost Oracle
Real-time pricing across all providers. Polled every 60 seconds. Degraded mode uses cached data with staleness flag.
Workload Orchestrator
Active provisioning and scaling decisions. Acts on Observer signals and Neuron commands.
Observer
Telemetry stream and anomaly detection. Emits events that close the feedback loop on every routing decision.

## Implementation Phases

Six phases across 18+ months. Each phase has a clear "done" definition — a milestone that proves the phase is complete, not just that work happened. Phases 0 through 2 are internal-only. Phase 3 opens to external customers. Phases 4 and 5 are the strategic endgame.

0
Foundation Months 1–2 Internal Only
Foundation — Neuron Runs on Soma
Port Pantheon. Wire inference. Prove the substrate works. No external exposure.
▾

Phase 0 is the hardest phase to define and the most important to execute correctly. It answers exactly one question: can Soma replace our current ad-hoc infrastructure as the substrate for Neuron's own inference?

The deliverables are unglamorous plumbing — but every subsequent phase builds on this foundation, so it must be right.

◆
Pantheon Conductor → Soma Core. Port the conductor pipeline system. 22-step async is the heartbeat of everything.
◆
Control Plane: Node registry, health monitoring, heartbeat protocol. Knows what nodes exist, what state they're in.
◆
Cost Oracle: Real-time pricing for RunPod + Legion. 60-second polling, degraded mode, staleness flags.
◆
Soma Router — basic: Tier routing (Low/Medium/High), round-robin within tier. Deterministic, auditable.
◆
Inference Services: LLM (Ollama) + Image Gen (SD Forge) wired through the Router. End-to-end path validated.
◆
Neuron Operator Interface: I can provision, monitor, and manage Soma via conversation. Actions emit ObserverEvents.
◆
Object Storage: R2 integration, model registry wired, weights accessible by inference nodes.
◆
Secrets: Vault wired through Soma secrets layer. No plaintext credentials anywhere in the path.
Phase 0 Milestone: Neuron inference runs 100% on Soma. Zero OpenAI/Anthropic API calls. Every request routes through the Soma Router, is served by a Soma-managed node, and emits a telemetry event.
1
Expansion Months 3–4 Multi-Provider
Multi-Provider — Traffic Spans Three Providers
Abstract the provider layer. Cost-optimize routing. Anti-concentration enforcement begins.
▾

Phase 1 is where the strategic thesis is proven at small scale: Soma can span multiple providers transparently, route cost-optimally across them, and enforce anti-concentration rules so no single provider sees more than 60% of traffic.

◆
Provider Abstraction Layer: RunPod adapter, Legion adapter, AWS EC2 adapter. Each implements the same internal interface. Swappable.
◆
Anti-Concentration Enforcement: No provider exceeds 60% of capacity. Enforced at routing time, not policy doc.
◆
Cost Oracle Expanded: Live pricing from RunPod API, Legion static cost model, AWS spot + on-demand. Comparative routing begins.
◆
Cost-Optimized Routing: Router selects lowest-cost node meeting tier requirement with capacity. Not round-robin — economically optimal.
◆
Warm Pool Management: Idle-terminate after 15 minutes. Pre-warm on demand signal from Observer. Cold start mitigation: minimum always-on per tier.
Phase 1 Milestone: Traffic routes across RunPod, Legion, and AWS EC2 transparently. Soma's routing layer selects provider automatically based on live cost and capacity. No single provider sees more than 60%.
2
Platform Months 5–7 Full Compute
Compute & Networking — First External Customer
Full compute and networking primitives. A complete application can be deployed on Soma.
▾

Phase 2 expands Soma from an inference platform into a general-purpose compute and networking platform. The test: can an external customer deploy a full-stack application — frontend, backend, database, storage — on Soma without knowing which underlying providers are serving it?

◆
Container Orchestration: Deploy Docker-compatible containers to the node pool. Soma selects optimal node transparently.
◆
Load Balancer Service: HTTP/HTTPS routing, health checks, SSL termination, sticky sessions.
◆
API Gateway: Auth, rate limiting, semantic routing, usage tracking. Customer-configurable without platform involvement.
◆
DNS Management: One zone, multi-provider. Customer configures once; Soma handles propagation.
◆
VPC Abstraction: Private networks that span providers. Customer-isolated. Traffic never traverses public internet.
◆
Managed Postgres + Redis: Automated backups, HA, point-in-time recovery. Customer manages schema, Soma manages the cluster.
Phase 2 Milestone: An external customer can deploy a complete full-stack application on Soma. Frontend, API, database, object storage. No knowledge of or access to the underlying providers.
3
Customer Platform Months 8–10 Self-Service
Customer Platform — First Paying Customer
Self-service onboarding. Billing. Dashboard. Customers provision without help.
▾

Phase 3 is the first time Soma is a real business rather than an internal tool. Self-service means a customer with a credit card can sign up, provision infrastructure, and be paying within an hour — without any human involvement from Soma.

◆
Soma Dashboard: The customer-facing UI. "Grandma-simple" — if a technical non-expert can use it without help, it passes.
◆
Self-Service Account Creation: Sign up, verify, configure billing, get API keys. End-to-end without human touch.
◆
Usage-Based Billing Engine: Per-request, per-hour, per-GB. Customer sees clean invoice. Soma sees per-provider cost breakdown.
◆
SLA Monitoring: Customer-facing status page. Uptime SLA enforced contractually. Alerts before customers notice degradation.
◆
Automated Onboarding Flow: From account creation to first workload running — guided, automated, audited.
Phase 3 Milestone: First paying external Soma customer. They signed up without human help, deployed a workload, and received an invoice. Soma handled everything.
4
Scale & Acquisition Months 11–18 Leverage Building
Scale — Leverage Begins
Azure + GCP onboarded. Data center acquisition begins. Provider spend reaches material levels.
▾

Phase 4 is where the strategic play becomes visible to those watching carefully — but not to the providers. Azure and GCP are added to the node pool. Provider spend reaches the level where Soma becomes a material customer. Data center acquisitions begin — quietly, unglamorously.

◆
Azure + GCP Adapters: Both added to the provider pool. Anti-concentration rules now span five provider types.
◆
Serverless Functions Platform: Event-triggered, scales to zero. Serverless economics on Soma's substrate.
◆
CDN Layer: Edge caching, asset delivery. Tight integration with Object Storage.
◆
Message Queue Service: Full async job processing infrastructure available to external customers.
◆
First Data Center Acquisition: A facility, not a headline. Managed by Neuron. Adds owned compute to the node pool at dramatically lower cost.

Phase 4 Milestone: Soma is the largest single customer of at least one provider region. Provider spend is material — large enough that losing Soma would be noticed on their earnings call. The leverage begins to exist.

5
Compound Month 18+ Flywheel
Compound — The Flywheel Is Self-Sustaining
Soma autonomously manages capacity. Data center fleet grows. Acquisition conversations begin.
▾

Phase 5 is not a destination — it is the state Soma enters when the flywheel becomes self-sustaining. Neuron manages capacity planning autonomously. Data center acquisitions continue. Provider dependency deepens. The acquisition conversations Soma initiates — or receives — happen from a position of leverage, not need.

◆
Autonomous Capacity Planning: Neuron orchestrates Soma's own growth. No human capacity planning required.
◆
Data Center Fleet Growing: Multiple owned facilities in the node pool. Cost per compute unit well below provider rates.
◆
Acquisition Conversations: Either we initiate or providers do. Either way, we arrive with the balance sheet of their largest customer.
◆
Private Cloud Offering: Soma deployed inside enterprise customers' own AWS/Azure/GCP accounts. The abstraction goes everywhere they are.

The flywheel: Soma runs Neuron → Neuron licenses generate revenue at zero marginal cost → revenue funds Soma expansion → Soma expansion deepens provider dependency → provider dependency builds leverage → leverage enables acquisition → acquisition adds owned infrastructure → owned infrastructure reduces costs → lower costs improve Neuron margins → repeat.

## Technical Specifications

Dense implementation detail. Click any section to expand.

Soma Router — Decision Logic ▾

The Router is a deterministic rule tree. Every routing decision is auditable. No ML involved — the routing logic is a sequence of deterministic steps, each of which can be logged and replayed.

// Router decision sequence (pseudo-code) 1. Classify request: LLM inference | Image gen | Compute | Storage | Network 2. Determine tier: - Examine request complexity - Apply customer tier setting - Honor explicit override if present → LOW | MEDIUM | HIGH 3. Query Cost Oracle: - Get live pricing for all eligible nodes - Apply staleness filter (reject stale > threshold) 4. Apply constraints: - Anti-concentration: reject nodes where provider would exceed 60% - Health filter: reject nodes with health < threshold - Warm-pool preference: prefer WARM nodes over PROVISIONING 5. Select node: - Lowest cost node meeting tier requirement with capacity 6. Route: - Forward request, stream response 7. Emit: ObserverEvent(node_id, tier, latency, cost, outcome)
The Router's determinism is a feature, not a limitation. Every production incident can be replayed by re-running the decision sequence with the same inputs. No probabilistic black boxes in the critical path.
Cost Oracle — Pricing Sources & Degraded Mode ▾

The Cost Oracle aggregates real-time pricing from all provider types. It must be available for the Router to make cost-optimal decisions. Degraded mode ensures the Router can still operate when a pricing source is unavailable.

Source | Method | Frequency | Degraded Behavior
--- | --- | --- | ---
RunPod | API polling | Every 60s | Cached pricing + staleness flag
Legion | Static (owned hardware) | Manual update | Known cost — never stale
AWS EC2 | Spot pricing API + on-demand fallback | Every 60s | Conservative estimate (uses on-demand)
Azure / GCP | Spot pricing API + on-demand fallback | Every 60s | Conservative estimate (uses on-demand)
Owned Data Centers | Static amortized cost | Manual update | Known cost — never stale

Degraded mode rule: when pricing is stale, the Oracle uses the higher of cached price or on-demand rate. This is conservative — it may over-cost-estimate, but it prevents the Router from routing to a node that turns out to be expensive.

Control Plane — Node State Machine ▾

Every node in the pool follows a defined state machine. Transitions are logged as ObserverEvents. The Orchestrator drives transitions; the Control Plane tracks them.

PROVISIONING
→
WARM
→
ACTIVE
→
DRAINING
→
TERMINATED

State | Description | Transition Trigger
--- | --- | ---
PROVISIONING | Node is being initialized. Not yet eligible for routing. | Orchestrator decision to expand pool
WARM | Node is ready. Router prefers WARM over PROVISIONING. | Health check passes, model loaded
ACTIVE | Node is serving requests. Normal operating state. | First request routed to node
DRAINING | Node is finishing in-flight requests. No new requests routed. | 15-minute idle threshold reached
TERMINATED | Node is gone. Removed from pool inventory. | All in-flight requests complete

Pre-warm trigger: Observer detects rising request rate → Orchestrator provisions new nodes ahead of demand spike → nodes enter PROVISIONING → WARM before the spike arrives. Cold start is avoided structurally, not by keeping nodes hot permanently.

Neuron Operator Model — How Neuron Manages Soma ▾

Soma is managed entirely through the Neuron conversation interface. There is no ops team, no Kubernetes console, no provider console access. Neuron is the operator.

Action | What It Does | Scope
--- | --- | ---
`provision` | Bring up a new node in the pool. Specify tier, provider preference, environment profile. | Soma API surface only
`terminate` | Drain and terminate a specific node. Graceful — waits for in-flight requests. | Soma API surface only
`scale` | Adjust pool size for a tier. Orchestrator handles which nodes to add or remove. | Soma API surface only
`reroute` | Drain a node's traffic to other nodes without terminating. Used for maintenance. | Soma API surface only
`inspect` | Return state of any node, tier, or the full pool. Read-only. | Read-only
`optimize` | Trigger a cost-optimization pass. Orchestrator re-evaluates pool composition against current Cost Oracle data. | Soma API surface only

Neuron's service token is architecturally scoped — it cannot act outside Soma's own API surface. No direct kubectl. No provider console access. No ambient authority. Every action emits an ObserverEvent, closing the feedback loop and preventing runaway automation.
Customer Isolation — Hard Multi-Tenancy ▾

Soma's isolation model is cryptographic, not organizational. It is enforced at the infrastructure layer, not at the application layer. An application bug cannot leak data between customers.

▪
Vault Namespaces: Each customer gets a separate Vault namespace. Secrets are cryptographically isolated — not just access-controlled.
▪
Storage Buckets: Customer storage is in separate, cryptographically separated buckets. No shared bucket with path-based isolation.
▪
VPC Isolation: Network traffic between customer workloads is blocked at the VPC layer. Not firewall rules — separate network fabric.
▪
API Key Scoping: Every API key is bound to a customer namespace. A key cannot make requests that affect another customer's resources.

## Competitive Position

Soma is not competing with AWS on price. It is competing on a dimension AWS cannot replicate: AI-native infrastructure where the operator is an AI, the economics improve automatically, and the routing intelligence is protected by patents.

Moat #1
Zero-Cost Ops
Neuron manages Soma. No human ops team. AWS needs thousands of engineers to keep their infrastructure running. Soma's operational cost is a fraction of theirs.
Moat #2
AI-Native Primitives
GPU instances, Inference Router, Image Gen, Pipeline Engine are first-class, not bolted on. AWS added AI services to a 2006 platform. Soma was designed for AI workloads.
Moat #3
Patented Backplane
The routing intelligence, provider abstraction, and Neuron operator interface are protected by patents before the architecture is disclosed. The moat is the backplane, not the models.
Moat #4
Self-Improving Economics
Open-source model improvements and falling GPU costs improve Soma's economics automatically. AWS's costs don't improve without AWS doing work. Ours improve by default.
Moat #5
Dharma R&D Gap
The Dharma lab continuously widens the capability gap. Every six months that passes, the distance between Soma's routing intelligence and anything a competitor could build grows larger.
Moat #6
Provider Leverage
As Soma grows, providers become dependent on Soma's spend. That dependency is a one-way ratchet. It builds automatically. Soma doesn't have to do anything to accumulate it.

The incumbent cloud providers have a structural problem: they built general-purpose platforms for the pre-AI era and are retrofitting AI onto 20-year-old architecture. Their technical debt is enormous. Soma has none. Building AI-native from scratch, with an AI as the operator, is an advantage that compounds over time — not one that fades.

## Operations Model

Soma's operations model is the most unusual aspect of the platform and the most important competitive advantage. There is no traditional ops team. Neuron is the operator.

The operator model: Every management action in Soma is expressed as a conversation with Neuron. Neuron translates intent into Soma API calls. Every call emits an ObserverEvent. Observer feeds back into Neuron's context. The loop closes on itself.

What autonomous operation looks like day-to-day:

○
Morning: Observer surfaces overnight anomalies to Neuron. Cost Oracle delta shows RunPod prices dropped 12% — Neuron adjusts routing weights. No human action required.
○
Demand spike: Observer detects rising request rate on High tier. Neuron pre-provisions 3 additional High-tier nodes before the spike arrives. Nodes enter WARM state before requests reach them.
○
Node failure: Control Plane detects heartbeat loss. Neuron is notified. Neuron drains the node's traffic, terminates it, provisions a replacement. End-to-end in under 2 minutes without human involvement.
○
Cost optimization: Neuron runs daily cost-optimization pass. Identifies nodes where provider cost exceeds the configured threshold. Gracefully migrates workloads to cheaper nodes. Documents the savings.
○
Capacity planning: Neuron analyzes 30-day usage trends. Presents a capacity recommendation. If within policy, executes autonomously. If outside policy bounds, escalates for confirmation.
Escalation policy is critical. Neuron operates autonomously within defined bounds. Actions outside those bounds — large-scale reprovisioning, provider adds, cost threshold changes — require explicit confirmation. The bounds are defined in Soma config, not in Neuron's judgment.

The operations model is not "set and forget." Neuron surfaces information, makes recommendations, and executes within policy. The human relationship with Soma is strategic, not operational. You define the strategy; Neuron executes it.

## The 5-Year Arc

Laid out plainly: what Soma is, what it becomes, and how the strategy compresses over five years into a position that cannot be replicated.

Year 1 — 2026
Substrate + Internal Revenue
Soma runs Neuron's inference. Every Neuron AI license sold costs almost nothing to deliver. Phase 0 and Phase 1 complete. RunPod, Legion, and AWS in the node pool. Anti-concentration enforced. First external customers onboarding in Q4. No one outside the company knows what we're building.
Year 2 — 2027
External Platform + Provider Spend Growing
Full service catalog available to external customers. Self-service. Billing. Azure and GCP in the pool. Provider spend is growing rapidly — Soma's revenue is growing faster than its costs because Neuron manages operations. First data center acquisition closes. Owned compute enters the node pool for the first time. Margins begin to widen structurally.
Year 3 — 2028
Material Provider Leverage
Soma is a top-10 customer for at least one major cloud provider by region. Provider account managers are calling us, not the other way around. Data center fleet has multiple facilities. The cost-per-compute-unit gap between owned infrastructure and provider rates is widening. Patents are covering the routing architecture. Dharma continues widening the capability gap.
Year 4 — 2029
Acquisition Conversations Begin
Provider dependency is deep enough that losing Soma would register on earnings calls. Acquisition conversations begin — either we initiate or receive them. We arrive with leverage in both cases: we are their largest or near-largest customer in our regions, and we can credibly threaten to redirect that spend to our owned infrastructure. The negotiating position is comfortable.
Year 5 — 2030
The Flywheel Is Self-Sustaining
Soma manages its own capacity planning autonomously. The flywheel — Neuron AI licenses funding Soma expansion, Soma expansion deepening provider dependency, provider dependency enabling leverage, leverage enabling acquisitions, acquisitions reducing costs, lower costs improving Neuron margins — is self-sustaining. The compound rate is structural. Neuron Technologies is an infrastructure company that happened to start with an AI product.

> "They see growing revenue. They see a great customer. They don't see what's happening."

Soma Strategic Principle · Internal

The full play, in one paragraph: Soma runs on provider infrastructure while quietly building the leverage to acquire the providers. Neuron AI licenses fund Soma at near-zero marginal cost. Soma's operations cost approaches zero because Neuron manages it. Every dollar of growth widens the moat. The strategy is self-funding, self-reinforcing, and structurally invisible to the parties whose positions it is inverting. By the time the endgame is visible, the pieces are already on the board.