What is Efficient Labs?

Efficient Labs builds sovereign AI infrastructure. StratosAgent runs on your own hardware and The Atmosphere meshes those nodes peer-to-peer across the world — content-addressed, capability-secured, and post-quantum — so you can build, run, remember, and scale AI without surrendering ownership.

What is StratosAgent?

StratosAgent is a local-first AI agent runtime that runs on hardware you control. It is owner-governed, keeps its state and memory across sessions, and connects to other nodes through The Atmosphere rather than a central cloud.

What is The Atmosphere?

The Atmosphere is a sovereign mesh that links AI nodes peer-to-peer. It is content-addressed, capability-secured, and post-quantum, so no central server is required to run, route, or remember — described as the sovereign internet for AI agents.

How is this different from cloud AI?

Your intelligence runs on infrastructure you own instead of a provider's cloud. There is no landlord and no per-use meter; your data and state stay on your hardware. Efficient Labs runs its own company on this system and publishes the operating layer's telemetry — operational proof before public proof.

The Atmosphere StratosAgent Architecture Pricing Enterprise Docs Status

Open OS Sign in Install now

The Atmosphere StratosAgent Architecture Pricing Enterprise Docs Status

Open OS Sign in Install now

StratosAgent

The agent that runs on hardware you own.

StratosAgent is the agent that lives on your node in the Atmosphere. Local-first by default: prompts resolve on your machine, and the frontier cloud is opt-in only — reached through your own key, gated by cost, never the silent default. This page is the in-depth version: the router, the skills, the receipts, and the guardrails that keep it yours.

Default: Local inference
Cloud: your own account · opt-in
Authority: Owner-gated
Channels: 5 adapters

01What StratosAgent does

An agent, not an API key with a chat box

StratosAgent takes a request, decides where it should run, pulls in the skills it needs, does the work inside a sandbox, and hands back a signed receipt of what it did. Every one of those steps is something you can inspect and control — because it all happens on infrastructure you hold.

Routes

Decides per-request whether work resolves locally or escalates to a frontier model through your own key.

Runs skills

Loads signed, content-addressed skills on demand and executes them in an isolated sandbox.

Receipts

Emits a sealed capability receipt for actions it takes, so the trail is auditable after the fact.

Answers everywhere

Reachable on Telegram, Discord, Slack, Matrix, and Signal — the same agent, many front doors.

02The router · local ⇄ your own cloud

Local first. Cloud only when it earns it.

The router is the heart of the agent's sovereignty. The default destination is your own machine. The frontier cloud is reached only through a key you supply, only when the work genuinely needs it, and only after passing a cost gate — so spend is a decision, never a surprise.

Prompt

Router

LOCAL-FIRST

Local inferenceDEFAULT

Frontier cloud YOUR KEY · OPT-IN

Request arrives

A prompt comes in from any of the five channels and is attributed to its sender.

Classify the work

Coding and routine tasks route local; genuinely complex reasoning is a candidate for the frontier.

Cost gate (your own AI accounts)

If escalation is warranted, the cost gate on /v1/chat/completions checks the spend handshake before any paid call leaves the node.

Resolve & receipt

Work runs at the chosen tier and returns with a sealed receipt of what happened.

Local ⇄ cloud language routing

Live

The router classifies each request and sends it to the cheapest tier that can actually do the job. Most work never leaves your machine.

Coding → local
Complex → proxy
The destination is chosen per request

Cost gate (your own AI accounts)

Live

Frontier AI requests run through your own account — your key, your bill. The single spend route is gated, so the cloud is opt-in by construction rather than the silent default.

Lives on /v1/chat/completions — the only spend route
Your key, your bill, your ceiling
No paid call without passing the gate

03Skills

Signed, content-addressed capabilities

A skill is a unit of capability the agent can load on demand. Skills are addressed by content hash and sealed with post-quantum signatures, so the agent will only run code whose provenance it can verify — and it runs it inside an isolated sandbox, stripped of your secrets.

Seal-verified on ingest

Wired

Before a skill is accepted off the mesh, its seal is verified. A skill that fails verification never makes it into the runtime.

verifySkillBlock runs in P2P sync
Provenance checked before acceptance
Unsigned or tampered skills rejected

Sandboxed execution

Wired

Skills execute in a WASI sandbox with empty preopens and no shell access — capability is granted explicitly, never inherited.

Exec + WASI sandbox
Empty preopens, no shell exec
Sanitized inputs only

Secret-guarded I/O

Live

Every adapter scrubs outbound text of anything that looks like a secret, and broker-scoped children run without your credentials in their environment.

Outbound text scrubbed of secret-shaped strings
Child + sidecars stripped of creds
No NODE_OPTIONS or proxy creds leak through

04Capability receipts

Every action leaves a sealed trail

When the agent does something consequential, it produces a capability receipt: a post-quantum signed record of what was done. Combined with the write-approval handshake, this means consequential actions are both authorised before they happen and auditable after.

Sealed receipts

Live

A receipt is signed with the same post-quantum scheme as skills, so the record of what the agent did can be verified later and can't be quietly rewritten.

ML-DSA-65 signatures on receipts
Tamper-evident record of actions
Verifiable against the post-quantum seal

Write-approval (402 loop)

Wired

Before a write or a spend, the agent runs a cost/approval handshake across every channel. The action only proceeds once it's approved — and then it's receipted.

Cost handshake wired into all five channels
Consequential writes ask before acting
Approval precedes the receipt

Owner-gating — fail-closed by default

Live

Authority is fail-closed: if no owner is set, the agent has no command authority. It will not act on instructions from an unestablished owner. Combined with sealed receipts and the write-approval loop, this means StratosAgent can be reached by many people across five channels while only ever taking consequential action for the operator who actually owns the node.

05Reach & evolution

Many front doors, one sovereign agent

StratosAgent meets people where they already are, and it can extend its own narrow set of skills under strict, sealed observation. Here's what's live, what needs configuration, and what's honestly still a placeholder.

Channel adapters

Config needed

Telegram, Discord, Slack, Matrix, and Signal adapters exist, but external tokens and real send/receive verification are still required before they count as live.

Self-evolution (narrow)

Live

A tightly-scoped class of integer-transform skills can be self-authored — sealed, observed, and never beyond that class.

Speech & vision

Mock

STT/TTS adapters currently return placeholders. They are scaffolded, not real — and labelled that way.

Agent-to-agent (ACP)

Mock

The agent-to-agent proxy returns scaffolded responses today. It is a stub on the honest roadmap, not a shipping feature.

How we label every capability

Full status matrix →

Live: Running in production, exercised by tests.
Wired: Built and connected into the daemon; hardening in progress.
Standalone: Built and tested in isolation; live wiring is supervised.
Mock: Scaffold / placeholder — explicitly NOT real yet.

Bring it online

Put StratosAgent on your metal.

Two commands and the agent is live on hardware you own — local-first, owner-gated, reachable across five channels. Read the layered architecture or install now.

Install StratosAgent See the architecture

Back to overview