Alpenglow Join BETA

Intelligence

Intelligence isn't one thing.
The substrate produces many.*

The frontier paradigm treats inference as the product — one capability, sold by the token, served from rented GPUs. We disagree, structurally. Intelligence is a family of operations: inference, code synthesis, memory recall, federated learning. On the same substrate, with the same primitive, locally on your machine.

What the substrate produces

Four operations, one foundation.

Memory, federation, inference, and code synthesis aren't four separate systems bolted together. They're four operations on one mathematical primitive — the same substrate primitive that gives you deterministic memory recall is what produces verified code from natural language, and what makes federation compound across participants without exposing your content.

  • Inference

    Bring-your-own-provider today; substrate-native model scaling for participant rollout next.

  • Code synthesis*

    Natural-language intent in, verified runnable code out across five languages. Built, tested, demonstrably correct.

  • Memory*

    Deterministic recall against your conversations and documents — content-addressed, byte-exact, local-first.

  • Federation*

    Anonymized patterns of what worked flow back to a shared learning layer. Not content. Not identity. Just signal.

Where the BETA stands

BYOK today. Native inference next.

At launch, the system is fully functional — memory, federation, skills, marketplace, the whole platform — but inference itself runs through whatever provider you bring. Connect your own API key from any major frontier-model provider (Anthropic, OpenAI, Google, xAI, DeepSeek, Mistral, MiniMax, others). Your machine talks to the provider directly. We never see your prompts, your responses, or your key.

For developers and power users, we recommend OpenRouter — one signup, every major model, one bill. Your agent picks the right model for each task. You don't pay our platform anything to use it.

For privacy-first or offline workflows, run local models via Ollama, LM Studio, or any OpenAI-compatible local endpoint. Your conversations never leave your machine.

An honest framing of the BETA: we couldn't charge for inference right now even if we wanted to. The platform is pre-incorporation, pre-revenue, and the substrate-native model isn't yet at deployment scale. The system you'll run during BETA is fully working — it's just BYOK-only for inference until our own model lands.

Why we won't run that race

Metered inference is rent-seeking.

Every major AI platform's revenue model assumes inference is their value to extract. Charge per query. Charge per month. Charge for tiers. Lock you in by tying their best capabilities to their hosted endpoints, so you can't bring your work anywhere else without losing it.

That model lives or dies by who owns the cheapest GPU cluster and who can extract the most margin between provider cost and customer price. The cost basis is fixed: data centers, electricity, GPU depreciation, the whole tower of capex pointed at one workload. The margin has to come from somewhere — and it comes from you, paying twice: in subscription, and in the queries that become the next model's training data.

It's a bad architecture for the economics, a worse architecture for the participant, and a fundamentally unsustainable structure for the technology to evolve under. It treats inference as a metered utility owned by a small number of incumbents. We disagree, structurally.

Inference

Substrate-native inference. Tested. Working. Scaling.*

Alpenglow's inference is built on the same proprietary substrate that makes the rest of the platform work — the same primitive that gives us deterministic memory recall, anonymized federation, and verified code synthesis. They aren't separate systems bolted together; they're operations on one underlying mathematical foundation.

That architectural unification is the breakthrough. It's also what we're keeping deliberately off public materials. The capability is the claim. The implementation is patent-protected and not for marketing.

What we will commit to publicly:

  • Frontier-quality output. The model is built and tested internally. Quality is real, not aspirational.
  • Runs on your hardware. No GPU cluster required. No API dependency. Speed scales with your machine, not with our infrastructure.
  • Improves through federation. The system gets better through anonymized signals from participant use — see how federation works.
  • Stays local. Your prompts and outputs never leave your devices. The model doesn't phone home.
  • Free, structurally. Not "free during BETA." Not "free until we figure out billing." Free as a property of how the architecture works — there's no per-query infrastructure cost for us to recover.

Status: built, tested, working in internal deployment. Scaling for participant rollout is the work that's in flight right now. There's no firm date because we won't ship until it's ready — but it's not a research project. It's the next major release after the BETA stabilizes.

Code synthesis

Code generated from natural language. Verified before delivery.*

Tell the agent what you want — "compute md5 hash of a file," "open a file in C," "swap two variables in Rust." The substrate emits runnable code across five languages: Python, C, Rust, Go, and Node.js. Every candidate is tested against the language's reference runtime before it reaches you.

When you ask for "compute md5 hash of a file," the substrate synthesizes the code, runs it against a known test input, and confirms the output matches the cryptographically correct hash — exactly, not approximately. The code you receive already ran successfully. That's a categorically different guarantee than what probabilistic code generation can provide.

Live example. Intent: "compute md5 hash of a file." Test input: a file containing the bytes "hello world". 

import hashlib
f = open(path, 'rb')
h = hashlib.file_digest(f, "md5")
print(h.hexdigest())

# Output: 5eb63bbbe01eeed093cb22bb8f5acdc3

That output is the verified MD5 of "hello world". The substrate didn't predict it would be correct — it generated the code, executed it, and confirmed the output matches before returning the program.

Same intent, five languages. "Open a file for reading" — the substrate emits the language-appropriate idiom for each target. 

Python:   f = open(path, 'rb')
C:        FILE *f = fopen(path, "r");
Rust:     let f = File::open(path)?;
Go:       f, _ := os.Open(path)
Node.js:  const f = fs.readFileSync(path);

Every candidate is compiled and executed against its language's reference runtime before delivery. No "type-valid but doesn't run" code reaches you.

Non-function-call idioms. Patterns like "swap two variables" aren't function calls in any language — each language has its own idiom. The substrate emits the right one. 

Python:   a, b = b, a
C:        int tmp = a; a = b; b = tmp;
Rust:     std::mem::swap(&mut a, &mut b);
Go:       a, b = b, a
Node.js:  [a, b] = [b, a];

What we will commit to publicly:

  • Five languages out of the gate. Python, C, Rust, Go, Node.js. More follow the same pattern — one focused session per language.
  • Runtime-verified, not just type-checked. Every generated candidate is compiled and executed against the language's real runtime. Type-valid that doesn't actually run is filtered out before it reaches you.
  • Cannot hallucinate by construction. When the substrate can't produce a valid program for an intent, it says so cleanly. It does not invent a plausible-looking program that doesn't work.
  • Byte-exact across hardware and time. The same intent produces the same code, today, next year, on any machine. No temperature, no sampling, no model drift.
  • Sub-millisecond generation. Latency is below human-perceptible time. Code appears as you finish typing the intent.
  • Free, structurally. Same architectural property as substrate-native inference. There is no per-query infrastructure cost for us to recover.

Status: built, tested, working with verified output. Five languages ship in the BETA. Patent-pending end to end — the capability is what we describe; the mechanism is deliberately not.

Memory & federation

The other two operations.

Memory recall and federation are the other two substrate-native intelligence operations. Both have their own pages: how memory works and how federation works. The same primitive that powers inference and code synthesis powers these as well — content-addressed, deterministic, byte-exact, running locally on your hardware with no per-query cost to anyone.

What this means architecturally

Frontier labs cannot price-compete with consumer-hardware intelligence.

Their cost basis is GPU clusters, data centers, electricity, and people. Ours is your laptop already running. There is no amount of operational efficiency that closes that gap — the floor isn't pricing, it's architecture.

The frontier still wins on bleeding-edge reasoning at the hardest problems. We're not claiming substrate-native intelligence is the absolute best at the absolute hardest tasks on day one — that's where their capex pays off, and it should. What we are claiming is that for the overwhelming majority of inference flows, code synthesis tasks, memory-grounded reasoning, and everyday agent work, substrate-native operations are competitive in quality, dramatically better in cost, structurally better in privacy and continuity, and — in the case of code synthesis — verifiably correct in a way probabilistic generation cannot be.

Over time, as the substrate scales and federation refines the system through real participant use, the quality gap closes for the use cases that actually matter to most people. The confidence we'll commit to publicly: most participants will choose free over paid for most flows, on their own, because the math works that way. No coercion required. Just architecture meeting economics.

When our model ships

Your choice, always. We don't lock anyone in.

Most platforms with their own inference restrict access to outside providers — because their revenue depends on you running their model, not someone else's. That conflict of interest is built into the business model. The platform wins when you can't leave.

We don't have that conflict because we don't have inference revenue to defend. When Alpenglow Intelligence ships, bring-your-own-provider still works. Local Ollama still works. Switching to whatever model just got released this morning still works. Nothing about our native inference landing makes any other path harder.

And federation benefits the network regardless of which model produced the work. The success patterns, reasoning paths, and procedural learnings flow back as anonymized signal whether the underlying inference came from us, from Anthropic, from OpenAI, or from a model running locally on your machine. Your participation strengthens the federation independently of your inference choice.

The bright lines

Things you'll never see from Alpenglow.

  • No metered inference. No per-token billing, ever — for our model or anyone else's.
  • No tiered access. No "Pro" subscription that unlocks higher-quality models. Same architecture for everyone.
  • No platform routing. Your queries don't pass through our servers on the way to a provider. There is no per-query path through our infrastructure.
  • No data sale. We don't sell your prompts, your conversations, or anything derived from them. Not to advertisers, not to research firms, not to AI labs.
  • No usage caps. If your provider lets you run a query, we let you run it through Alpenglow.
  • No vendor lock-in. Switch providers any time. Run locally any time. Use our native inference any time. We're indifferent to your model choice and we'll stay that way.

Get on the BETA.

Bring whatever provider key you already have. Run the system end-to-end. The native model lands when it's ready — and you'll be running on it without changing anything else about how you work.

Request access