Software
you can still understand
Generating code is the easy part now. Keeping it understandable, changeable, and correct as it grows is the part nobody solved. That's Foundry.
Open-source. Your codebase, reflected as a living graph that you and the agent can read, reason about, and never lie to.
Every AI builder gets you to the first 80%
Then you ask for the fifth feature, and the agent edits text it no longer understands. Invariants break silently. Nobody can say what a change touches.
That isn't an AI problem. It's a coherence problem. The agent has no model of what the system is — only the text of what it currently says.
Foundry gives it one.
Foundry's agent doesn't edit text
It edits a validated structure.
Other agents generate code and pray. Foundry's agent operates on a graph derived from your real codebase, constrained by structure, not by context window size.
- It cannot referencea resource that doesn't exist because the graph won't allow it.
- It cannot reinventthe same concept twice. The full compressed graph is in context.
- It cannot changewithout blast radius computed. Every edit is scoped before it lands.
- It cannot violatean invariant silently because the model rejects the change at the boundary.
Code and tests as a living map
Ten minutes to feature, end to end — because every step operates on a structure, not on a wall of generated text.
One system.
Every perspective.
For the new engineer
Understand the system in an afternoon, not a fortnight.
Open the graph, follow the domain by meaning, watch a scenario test execute step by step. No tribal knowledge required.
For the developer
Stop reading code to understand systems.
Navigate by meaning, not by filename. Refactor with blast radius shown, not guessed.
For the staff engineer
Architecture decisions that survive contact with the codebase.
Pin ADRs to nodes. Foundry tells you when a decision has been silently violated.
For the engineering manager
See your system's health the way you see your business metrics.
Bus-factor, drift, fragility — derived from real artifacts, not self-reported sprint data.
For the product manager
Finally looking at the same picture as your engineers.
The domain layer, in business language. Click :upgrade_subscription, read what it actually does.
For the auditor
Your authorization model is the documentation auditors want.
Policies, data flows, retention, separation of duties — declared, enforced, exportable as audit evidence. Trace where sensitive data moves, prove which paths are policed, generate the access matrix for any resource at any commit.
This is a deliberate stack bet
And it's the reason Foundry is hard to copy.
LLMs write Elixir unusually well — and there's a measured reason. Tencent's AutoCodeBench — 3,920 problems across 20 languages, generated and verified in sandboxes rather than hand-picked — found Elixir had the highest completion rate across models. Immutability enables local reasoning, documentation quality gives clean training signal, and language stability means that signal stays correct over time.
Ash makes it better still. Generated JavaScript rots because nothing enforces structure. Ash is declarative and introspectable: invalid DSL doesn't compile, structure is uniform, and many runtime failures become compile-time errors. An AI generating Ash cannot produce the unmaintainable sprawl it produces in a typical Next.js app — the framework won't let it.
The BEAM is the cheapest serious runtime at scale. One Elixir node handles what would otherwise be ten services. Per-process heaps, preemptive scheduling, supervision trees — you get concurrency, soft real-time, and fault tolerance without standing up Redis, Kafka, etcd, and a workflow engine on day one.
In practice, the layers compound. Phoenix LiveView collapses frontend component, state manager, REST endpoint, and DTO validation into one module. Pattern matching replaces blocks of nil-checks and type guards. GenServer replaces Redis plus connection pools plus a job processor. Teams migrating from TypeScript or Go cut backend LOC by 30–50% before counting the frontend delta.
The AI generates tests that pass on the first run, because pure functions need no mocks and ExUnit assertions match data shapes directly.
You don't need to be an Elixir expert to use Foundry. But the floor is high because the substrate is good.
These are not benchmarks.
They are infrastructure bills.
Phoenix
2M WebSocket connections
one EC2 instance, 2ms latency, ~1KB per connection, no GC pauses
Before this benchmark existed, the assumption was that real-time at this scale required purpose-built infrastructure. One EC2 instance proved the assumption wrong.
Bleacher Report
150 servers → 5
equivalent peak traffic after moving to Elixir
Rails across 150 servers, aggressively horizontally scaled to compensate for per-request threading overhead. After moving to Phoenix, the same spike traffic ran on five. The infrastructure cost reduction was approximately 95%.
200 Python servers → 4 Elixir nodes
saving over $2M/year
Pinterest was running 200 Python nodes to serve notification and activity systems. Four Elixir nodes replaced them. The BEAM process model handled the concurrency that required 200 servers of horizontal scale.
Discord
Go → Elixir, same load
read states service rewrite — fan-out problem eliminated
The Go service degraded under pressure and required constant operational intervention. Fan-out on high-follower users caused latency spikes across the service. The Elixir rewrite handled the same load with dramatically simpler operations — the supervision tree handled failures that previously required manual intervention.
2M connections/server
~50 engineers, 450M users — on Erlang (BEAM's predecessor)
Roughly 40 million users per engineer. The ratio isn't a fluke — it's what the process model makes possible. The most extreme case on record, and it illustrates the fundamental property of the runtime.
highscalability.com
Bet365
Millions of users per node
22M+ customers, migrated from Java to Erlang — world's largest online bookmaker
A single node now serves what previously required a fleet, under the consistency and audit constraints a regulated financial domain demands. The properties BEAM was designed for are exactly the properties the domain requires.
Erlang Solutions case study
The same graph
projected for whoever needs it.
- Developers model and refactor.
- Architects review structure and orchestrate change.
- Compliance traces policies, data flows, and provenance.
- Product reads the domain in business terms.
The platform is open source and local-first.
Systems understood only by whoever first wrote them — until now.
Foundry earns its place where the domain is complex and the cost of losing comprehension is highest.
Business process platforms
Approvals, escalations, parallel branches, exception handling — declared as deterministic workflows, visualizable at every step, evolvable without breaking what runs.
Financial platforms
Ledger integrity, transfer governance, regulatory compliance, audit trails, dual-approval on sensitive changes.
Healthcare and clinical systems
PHI governance, protocol enforcement, human-in-the-loop gates on decisions that cannot be autonomous, audit-ready records.
Enterprise internal platforms
The most underserved category in software. Internal tools built badly, maintained expensively, understood only by whoever first wrote them.
Also: logistics and supply chain, multi-sided marketplaces, insurance and claims, govtech — anywhere the rules are dense, the audit trail matters, and the system has to outlive the people who built it.
What Foundry is.
Free to own.
Paid to run.
Open Source
The full Foundry, yours to own.
- —Own Ash + Phoenix + Oban stack
- —Spec-driven methodology
- —Governance linter
- —System map generation
- —Behavior test visual tracing
- —Basic copilot agent
- —Community support
Team
Managed infra and an extended copilot for teams shipping real domains.
- —Everything in Open Source
- —Extended governed AI copilot
- —Cloud infrastructure — 1 instance
- —1 CPU, 512 MB RAM, 1 GB Postgres
- —Priority support
Enterprise
For regulated platforms and complex organisations.
- —Everything in Team
- —Dedicated domain architect
- —Branch-first proposals
- —On-premise deployment
- —SLA guarantee
- —Custom contracts
The system of record for software that AI helped build.
That's the whole promise.