One stack: Czar, Substrate, Agency

E31 Consulting does not choose a stack per engagement. There is one, and every use case the practice builds runs on it. Knowing the three layers helps a customer understand what the engineers are doing, what the site team will be working in afterward, and why one engineer can carry an engagement from scope to handoff.

The layers are Czar, Substrate, and Agency. Appliance, platform, agent layer.

Czar: the appliance

Czar is Element 31's sealed inference appliance. It sits in the customer's rack, inside the customer's segment, in the customer's posture. Everything the use case does runs on it.

Several Czars working together are a Czar Grid. It is still Czar, sharing a larger workload across more than one appliance, not a different product. When the result should ship under the customer's own name, Czar Chassis is the path, and that too is Czar, used a particular way. The practice builds on one machine, whichever of these shapes the customer has.

For a customer, Czar is the thing they can point to in the rack and say: the use case lives there. The engineers build on it, the version is published on it, the record is kept on it, and nothing about the use case lives anywhere else. More about the appliance itself is at e31.io/czar.

Substrate: the platform

Substrate is the platform on Czar, and it is where most of the engineering happens. It provides inference on the appliance, so the use case does not reach outside to run a model. It provides retrieval over the site's documents, which is how a corpus people can question is built: the documents are indexed on the appliance and the version retrieves from them and cites them.

It provides memory, so a use case can carry context across runs where the scope allows. It provides adaptation, so a model can be tuned on the site's own material, with the adapters staying on the appliance. It provides evaluation, so a version can be checked against the site's material before it is published rather than after. It provides integrity verification, so the site can confirm what is running is what was published.

And it provides declared routes to on-premise systems. A route is named in the scope, set in the version, and reaches one system for one purpose. The use case makes no call that is not a declared route. On a connected site the routes reach systems the customer already secures; on an air-gapped site they reach only inside the building.

Agency: the agent layer

Agency is where a use case becomes something the site team can run and change. Agents are composed in Agency Studio. Bounds are set that encode what the use case never does. The approving role is assigned, so the version waits for a named person before an action lands. Versions are published, each with an identity, and the previous version is kept to roll back to. The run record captures every run, approval, and action under each version.

This is the layer the site team will live in after the engineers leave. The operating picture, meaning who may publish, which model the version uses, where a person has to approve, and which systems it may call, is a set of properties of the version in Agency. The team reads it there and changes it there. More about the agent platform is at e31.agency.

Why one stack matters for the practice

One engineer can work across all three layers. An E31-certified engineer indexes the corpus in Substrate, adapts on the site's material in Substrate, composes the agent in Agency Studio, sets its bounds and approving role, evaluates the version, publishes it, and reads the record. There is no handoff between specialists in the middle of the engagement.

That is what makes forward-deployed work practical. The engineer sitting with the desk is the same engineer building the version, so what the desk teaches goes straight into the build. It is also what makes a project's handoff clean, because the version comes back as one coherent thing on one appliance rather than pieces from different teams.

And it is what makes the site team's job tractable afterward. They are not maintaining an integration of several products. They are changing a version on an appliance they own, in a layer built for that.

What the customer holds across the stack

Everything on it. The corpus, the adapters, the memory, the versions, the bounds, the record, the documentation. All on the Czar in their rack, all theirs, none of it held by the practice or dependent on anything outside. What E31-certified means describes how engineers are prepared for the whole stack, and the practice page at /practice covers how the practice uses it.