Auralis is Prestanda Consulting's sovereign AI platform: AI agents, grounded retrieval and language models that run entirely on infrastructure the customer owns. This article explains how the architecture fits together — and why the most important design decision is keeping deterministic orchestration wrapped around probabilistic agents.
What "sovereign" means in practice
Sovereign AI is not a euphemism for "we have a privacy policy." It means the models, the data, the embeddings and the automation all live on hardware you control. No prompt, document or embedding is ever sent to an outside AI provider. Open-weight models have made this practical: serious summarization, retrieval and analysis now run well on servers — including Apple Silicon machines — that a mid-size company can simply buy.
Five responsibilities, kept separate
The platform separates five concerns that most AI projects tangle together: data ingestion (normalizing source systems into a clean record), evidence retrieval (finding and citing what's relevant), domain analysis (agents that interpret evidence for a specific job), inference (running language models), and orchestration (schedules, retries, sequencing). Each can be tested, deployed and monitored on its own. The alternative — one monolithic agent that does everything — is impossible to debug and impossible to trust.
Deterministic shell, probabilistic core
Language models are probabilistic; business operations should not be. So Auralis never lets agents orchestrate themselves. Windmill, a deterministic workflow engine, owns every schedule, retry, failure policy and run history. Workflow scripts are thin wrappers around versioned Python packages, which own all business logic — developed, tested and version-controlled like any other software. When an agent investigates something complex, it does so inside a LangGraph multi-agent graph with typed tools — and that graph is itself invoked as a deterministic workflow step.
One system of record
Supabase PostgreSQL is the platform's single source of truth. Source messages are ingested once, normalized and deduplicated; every agent reads from the same records rather than hitting upstream APIs. Agent outputs, run history, audit logs and retrieval indexes — including pgvector embeddings — live in the same database. Analysis becomes repeatable, and every result can be traced to the records that produced it.
Local inference with Ollama
All generation and embedding runs through Ollama serving open-weight models, currently from the Qwen 3 family. Models are deliberately swappable: as open-weight releases improve, the platform upgrades in place with no architectural change and no new data-sharing agreement to negotiate.
One front door
Users shouldn't need to know which agent does what. A semantic router classifies each request and dispatches it to the right capability — grounded knowledge retrieval, a domain analysis, or general local chat. Because the router speaks the OpenAI-compatible API, standard chat interfaces like Open WebUI work out of the box, and internal tools can integrate with one line of configuration.
If you can't audit it, it didn't happen
Every query, answer, agent run and model call is logged: telemetry on model usage, an audit trail for retrieval, user feedback capture, and Sentry monitoring across workflows. For a platform whose whole promise is trustworthiness, observability isn't an add-on — it's the product.
Key takeaways
- Sovereign AI means models, data and automation on hardware you own — with zero data egress to AI providers.
- Separate ingestion, retrieval, analysis, inference and orchestration; never build the monolithic agent.
- Wrap probabilistic agents in deterministic orchestration — schedules, retries and approvals belong to code, not to the model.
- Keep one auditable system of record that agents read from and write to.
- An OpenAI-compatible front door means sovereign AI works with the chat tools teams already use.
Frequently asked questions
Do local models perform well enough for enterprise work?
For summarization, retrieval-grounded answering and structured analysis — the bulk of enterprise agent work — current open-weight models perform very well, and they improve with every release. Because Auralis treats models as swappable components, upgrades require no architectural change.
Why use a workflow engine instead of letting agents schedule themselves?
Because schedules, retries and failure handling must be predictable and auditable. A workflow engine gives you run history, reruns and guaranteed sequencing. Agents that orchestrate themselves produce systems nobody can debug or certify.
What hardware does a sovereign AI platform need?
Less than most people expect. Auralis runs production workloads on high-memory Apple Silicon and comparable on-premise servers. The right sizing depends on data volume and concurrency, which is part of what a deployment engagement establishes.
Originally published by Prestanda Consulting. Auralis is Prestanda's sovereign AI platform — explore the platform.