The settlement router, implemented in Python within our control plane, ensures accurate accounting of all compute usage. The system employs dual-signature cryptography—primary Ed25519 with embedded public key, secondary PQ-style derived from SHAKE-256—providing cryptographic verification that meets strict audit requirements.

Our TWAP (Time-Weighted Average Price) implementation ensures fair pricing, as shown in control_plane/settlement.py:

1
2
3
4
5
6
7
8
9
10
11
12
# From control_plane/settlement.py
total_minutes = sum(
    row["minutes_delta_scm_micro"]
    for row in slices
)
numerator = sum(
    row["minutes_delta_scm_micro"] *
    row["priceindex_micro_usd"]
    for row in slices
)
burn_micro_acu = math.ceil(
    numerator / self.mint_price_micro_usd
)

This efficient algorithm ensures providers can liquidate their compute contributions instantly, while consumers access resources without traditional enterprise contract overhead. The absence of lock-in periods provides flexibility and commitment to open access computing.

from alien.adapters.base import Adapter, ExecutionPlan, ResourceProfile
from alien.adapters.loader import register_adapter

class InferenceAdapter(Adapter):
    """Service-oriented execution with auto-scaling."""
    
    def prepare(self, job_spec: Dict[str, object]) -> tuple[ResourceProfile, ExecutionPlan]:
        profile = ResourceProfile(
            num_gpus=int(job_spec.get("num_gpus", 1)),
            min_vram_gb=int(job_spec.get("min_vram_gb", 16)),
            interconnect=tuple(job_spec.get("interconnect", ("pcie",))),
            scm_minutes=int(job_spec.get("scm_minutes", 60)),
            features=tuple(job_spec.get("features", ()))
        )
        
        plan = ExecutionPlan(
            image=job_spec.get("image", "ghcr.io/alien/inference:latest"),
            command=tuple(job_spec.get("command", ("python", "-m", "server"))),
            env={k: str(v) for k, v in job_spec.get("env", {}).items()},
            volumes={},
            strategy="service",
            rendezvous={"type": "none"},
            io={"mode": "stream"},
            replicas=int(job_spec.get("replicas", 1)),
            service_type="ClusterIP",
            readiness_probe={"httpGet": {"path": "/health", "port": 8080}},
            liveness_probe={"httpGet": {"path": "/health", "port": 8080}},
            autoscaling=job_spec.get("autoscaling"),
            restart_policy="Always"
        )
        return profile, plan
    
    def map_metrics(self, raw: Dict[str, object]) -> Dict[str, object]:
        return {"latency_p95_ms": raw.get("latency_p95_ms", 0),
                "throughput_qps": raw.get("qps", 0)}

# Register your adapter globally
register_adapter("my-inference", InferenceAdapter)

Built-in Adapters

• TrainingAdapter: DDP, multi-GPU
• InferenceAdapter: Service-oriented
• RenderingAdapter: NVENC, tiling
• QuantizationAdapter: PTQ/QAT
• Your custom adapter via registry

Advanced Capabilities

• Kubernetes orchestration
• Auto-scaling & health checks
• Custom metrics mapping
• Hardware feature detection
• Multi-region placement

Daily AVL Distribution Algorithm