Your codebasethat governs
Foundry is the governed development environment for complex domain platforms. Turn your code and tests into a living, visualizable spec, eliminating drift and keeping your team in sync.
The codebase that never lies.
Starting is no longer
the hard part.
Constraints live in heads, not code.
The reason a resource is sensitive exists in one person's memory and nowhere else. When that person leaves, the constraint vanishes. Foundry makes constraints executable — they live in the spec-kit and the linter fires when they're violated.
Documentation drifts from reality.
The diagram drawn in week one describes a system that no longer exists. In Foundry, the system map is not inferred from code — it is the code. A lossless rendering generated from the same source the compiler validates. It cannot drift.
AI tools generate from training, not your domain.
The copilot doesn't know your invariants. Foundry's copilot is different — it reads your domain model live from the compiler, your ADRs, your compliance links, and your sensitivity classifications before proposing anything.
Change is invisible until production.
Nobody knew that modifying this action would break three downstream compliance obligations. Foundry proposes on a branch, classifies the change as :structural, :behavioral, or :compliance, and routes it to the right approver before anything merges.
One source of truth.
Everything derives from it.
1defmodule MyApp.Accounts.User do2 use Ash.Resource,3 domain: MyApp.Accounts,4 data_layer: AshPostgres.DataLayer56 # sensitivity: :pii is a compiler-enforced7 # constraint — not documentation8 @sensitivity :pii910 attributes do11 uuid_primary_key :id12 attribute :email, :ci_string, allow_nil?: false13 attribute :role, MyApp.Accounts.Role14 end1516 policies do17 policy action_type(:read) do18 authorize_if relates_to_actor_via(:self)19 end20 end21end
The infrastructure
decision you'll never
have to make.
The BEAM was built by Ericsson for telephone exchanges — systems that needed to run without failure under millions of concurrent connections. Foundry gives you this foundation from the first line you write.
AI adoption is rising.
So are bug rates.
Built for
complex domains.
The more regulated and complex your domain, the greater the advantage. This is where configuration-based tools break down.
Governed.
By construction.
Foundry is built for regulated domains — financial platforms, healthcare systems, enterprise internal tools. Compliance is not a layer you add. It is declared in the domain.
Ash policies, compiler-enforced
Authorization logic is declared in the resource, validated at compile time. No policy can silently vanish.
Sensitivity classification
Resources carry :pii, :financial, and :phi classifications that the linter enforces across every action and relationship.
Compliance links
ADRs reference regulation files. When a rule is violated, the linter fires with the exact ADR that motivated it.
Audit-ready by construction
Auditors read the system map. It is a lossless rendering of what is running — generated from the same source the compiler validates.
Full context.
Governed proposals.
The reason most AI coding tools degrade as systems grow is not model quality — it is context. Foundry's copilot reads your domain model live before proposing anything.
Live DSL introspection
Reads the compiler's output, not a cached index.
Structured spec-kit
ADRs, runbooks, and compliance as executable constraints.
Branch-first proposals
Copilot never touches your working tree.
Change classification
:structural, :behavioral, or :compliance — routed accordingly.
defmodule MyApp.Ledger.Transfer douse Ash.Resource,domain: MyApp.Ledger,data_layer: AshPostgres.DataLayer@sensitivity :financialattributes douuid_primary_key :idattribute :amount, :decimal, allow_nil?: falseattribute :state, MyApp.Ledger.State,default: :pendingendactions docreate :initiateupdate :approve dorequire_atomic? trueendupdate :rejectendpolicies dopolicy action(:approve) doauthorize_if actor_attribute_matches_record(:role, :domain_lead)endendend
"Six months in, the architect left. Foundry meant the constraints didn't leave with them. A new engineer read the domain map in twenty minutes and made their first PR safely."
Engineering Lead
Fintech Platform, Series B
Zero post-departure incidents
Built for regulated, complex, long-lived systems
Open source core.
Governed copilot.
The architecture is yours, regardless of plan. No proprietary runtime. No black box.
Every Foundry project compiles to a standard Elixir application. You own it entirely.
Open Source
The full Foundry, yours to own
- Own Ash + Phoenix + Oban stack
- Built-in spec driven methodology
- Governance linter
- System map generation and visualization
- Behavior test visual tracing
- Basic copilot agent
- Community support
Team
The governed copilot for teams building complex domains
- Everything in Open Source
- Extended governed AI copilot agent
- Cloud infractructure 1 instance
- Up to 1 CPU and 512 MB RAM + 1 GB PostgreSQL
- 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
If you are building
something complex.
Domain-heavy, long-lived, and regulated — and you want to build it in a way your team, your AI, and your auditors can all understand real system behavior years later.
Foundry is built with love.