The unfinished piece of the AI stack isn't the model. It isn't the chat interface. It's the application fabric — the layer where applications talk to each other, where intelligence flows in from wherever it lives, where a human and an agent share the same view of the work.
That fabric does not exist as a sovereign product today. The closest thing is whatever your model vendor decided to ship in their console: a chatbox, a sidebar, and a billing page. Useful, but not a stack. And certainly not yours.
Sozenta is building the sovereign version. Three layers, one argument.
Layer one: Veya, the application fabric
Veya is the surface humans touch. A workspace that renders views, takes edits, dispatches agents, runs searches and research, and automates work — for humans and for the machines they put to work alongside them. Voice and prompt are first-class. You can say what you want or you can type it; the workspace assembles the right surface either way. A doc canvas when you're drafting, a research grid when you're investigating, a triage view when you're catching up. The interface is a render target of the task graph, not a fixed shell that the work has to be bent into.
Veya is the entry into the sovereign fabric — the piece you touch first, the place where the human shows up and the agent answers. Two pieces inside Veya carry most of the weight:
- DynaView is how Veya renders. Generative UI that composes itself around the task in front of you. The same task graph produces a different surface depending on whether you're drafting, comparing, deciding, or reviewing — because that's how humans actually work.
- DynaForge is how Veya acts. Voice commands flow into the same task graph as prompts. The workspace edits with you, not for you — every model-initiated change surfaces an accept/reject/edit affordance before it touches your data.
And the part that makes the rest of the stack possible: anything that runs inside Veya relies on intelligence, and that intelligence can come from anywhere. Frontier API in the cloud. A local model on your laptop. An enterprise endpoint inside your VPC. Veya is the fabric; the source of intelligence is a policy decision, not an architecture decision.
That single property is what separates a fabric from a wrapper.
Layer two: Vera, the intelligence hub
Vera is where the policy decision gets made. A model-routing layer that sits between Veya — and any other application that wants to plug in — and whatever intelligence you've decided to use.
It can be your local intelligence: Ollama, llama.cpp, a model on the box, sovereign by default. It can be your enterprise intelligence: your team's shared endpoint, your fine-tune, your provider contract, whatever the policy says is allowed for the work in front of you. It is not a tie-in to any model vendor, ours included.
The defining property of Vera is what it does around the routing:
- Private by construction — the application never sees an API key; the routing decision is opaque to the caller.
- Safe by enforcement — policy decides which prompts can reach which models, before the call goes out.
- Logged by default — every request, every response, every routing decision, auditable.
- QoS-aware — capacity, latency, and cost are first-class signals, not best-effort.
- Enterprise-ready from day one — not "we'll add SSO in Q3," not "you'll need a custom plan."
Vera works with you. It infers what you need, routes the work, returns the answer. And it does the second thing nobody else is doing: it safeguards your data. The application doesn't decide where the prompt goes — Vera does, and Vera answers to the policy the operator set, not to whoever shipped the application sitting on top.
Layer three: open-weight models, written for the work
The third layer is the one that finishes the sovereignty argument. If Vera can route to anything, but the only things worth routing to are frontier APIs in someone else's cloud, then "sovereign" was a wrapper around someone else's infrastructure — not a stack.
So Sozenta is building open-weight models written for use cases. Small. Capable. Cheap to run. Designed for the slices of work where a 70B-parameter frontier model is overkill and a generic 7B is undercooked. The point is not to compete with the frontier on general intelligence. The point is to make sure the useful work — the routine inference that the vast majority of an application's calls actually need — can happen inside the perimeter you control.
A small model written for the right job beats a giant model called from someone else's data center on every axis that matters: cost, latency, control, and the fact that the prompt never leaves your network.
Why these three, in this order
Veya without Vera is another wrapper around someone else's API. Vera without open-weight models is a polite proxy to the frontier. Open-weight models without an application fabric on top of them are a research project.
The three layers are the same argument said three times:
- The interface belongs to the user, not the model vendor.
- The routing belongs to the operator, not the model vendor.
- The weights belong in your perimeter when the work calls for it.
That is what "sovereign AI fabric" means. Not a single product. A stack with three layers, each independently useful, that compose into something the public cloud has every reason not to ship.
What's shipping, what's next
Veya's Edge Release is out across macOS, Windows, and Linux — the application fabric is the first piece in your hands. Vera's gateway is next; the open-weight models follow. Each layer ships when it's ready, on its own cadence, with parity across platforms from day one.
More on each layer in the posts to come.