Every team building with AI today assembles the same five-vendor stack: object storage for the raw files, a vector database for embeddings, a warehouse for the structured truth, a model gateway for inference, and serverless compute to run it. Five products, five bills, five auth models — and a sprawl of glue code that is the actual engineering. We think that's a historical accident, and we're building the thing that replaces it. Here's the thesis, and why the moment is now.
The problem: the stack is breaking under AI scale
The uncomfortable truth of the "modern data stack" is that API connectivity is not system cohesion. Teams wire ingestion, a vector DB, orchestration, monitoring, and serving together and assume the seams hold — and then, as one analysis of AI failures put it, "most AI systems collapse because of architectural fragmentation." The incidents don't come from the model; they come from the storage layer — slow retrieval, unstable write latency, fragmented memory tiers, governance you can't enforce because the data lives in four systems with four access models.
The industry already senses the fix. The "multimodal lakehouse" is converging object + vector +
structured data into one substrate; teams are ripping out Pinecone + Postgres and collapsing to a
single engine to kill the glue. The direction is clear. What's missing is a platform that finishes the
job — and is built for how software actually gets written now.
Why now: three curves crossing
A thesis is only as good as its timing. Three independent curves are crossing in 2026, and the intersection is exactly where we sit.
1. The stack hit its complexity ceiling. AI workloads made the fragmentation unaffordable — in latency, in governance, in engineer-hours. The market is actively consolidating toward unified, multimodal substrates. The pain is now acute enough that people will switch.
2. Agents became the primary builder. The Model Context Protocol went from an Anthropic proposal to the universal standard — governed by the Linux Foundation, 18,000+ servers, native in ChatGPT and the OpenAI API, called the "USB-C for AI agents." But the reported bottleneck is telling: connectivity and security — over half of internet-exposed MCP servers run with no meaningful access control. The world standardized on the protocol before anyone built infrastructure that's natively, securely agent-operable. That's a gap.
3. Sovereignty went from preference to procurement gate — in Europe especially. European sovereign cloud IaaS spend is projected to roughly double from $6.9B (2025) to $12.6B (2026), approaching $23.1B by 2027; Europe's 2026 tech spend tops €1.5 trillion, explicitly driven by AI, cloud, and sovereignty. With the EU AI Act's high-risk rules landing August 2, 2026, and NIS2/DORA/the Data Act stacking on top, EU data residency is now "non-negotiable" in a third of procurement decisions, and 61% of Western European CIOs are prioritizing local providers. "Where does my data — and my inference — physically run?" is now a buying question, not a footnote.
Unification is happening. Agent-native is mandatory. Sovereign is a market. We built for all three at once — which is the part that's hard to copy, because most players are strong on exactly one.
The thesis: one bucket, three planes, agent-native, on our own hardware
DODIL collapses the five-vendor stack into one bucket exposing three planes:
- DataK3 — the data plane. Objects (S3) plus one HTAP tables engine serving three pillars over the
same rows — SQL, Vector, and Graph — in one bucket, one auth context.
SQL narrows, Vector ranks, Graph relates, S3 quotes— one engine, not four systems glued by an indexer. - Ignite — compute. Serverless functions that scale 0→N and back to zero, plus managed inference behind one OpenAI-compatible endpoint.
- Models — inference. A directory of models you swap with a string, billed on one invoice, so you route bulk work to low-cost inference and reserve frontier models for what moves the needle.
Two properties make it more than a bundle. It's agent-native: every operation is a typed MCP tool, so an agent doesn't scrape a UI — it operates the platform directly. (We know, because agents wrote most of the pipelines on this blog by prompting that MCP.) And it runs on our own hardware and network, in the EMEA sovereign envelope — the data and the inference never leave.
| The fragmented stack | DODIL |
|---|---|
| S3 + Pinecone + Snowflake + a gateway + Lambda | One bucket, three planes, one bill, one auth |
| Glue code is the system | A recipe install stands up the pipeline |
| Bolt an MCP shim onto each service | Every operation is already a typed agent tool |
| Data residency you assemble and hope | Sovereign EMEA hardware by construction |
What actually ships today (not a roadmap)
Theses are cheap; here's the inventory, live in the product right now:
- 8 one-command recipes —
document-rag,code-rag,image-rag, invoice intake, transcription, summarize-then-RAG, and more — each standing up store + collection + index + ingest rule in a line. - 15 warehouse-compatible table templates — classification, document triage, entity/PII extraction, invoice parsing, OCR, sentiment/intent, summarization, translation, code intelligence, object detection, even video surveillance — tagged for finance, healthcare, compliance, government, and defense verticals. The sovereignty thesis is in the product surface, not just the pitch.
- 25+ models behind one endpoint — Kimi K2 and Moonshot for reasoning, Seed-X for translation, Whisper for speech, GLiNER/PaddleOCR/YOLO for extraction, EmbeddingGemma/Jina for vectors — swap by string, one bill.
- The MCP, secured and org-scoped, so any agent — Claude Code, Cursor, ChatGPT — builds on all of the above through typed tools with service-account auth.
Where the moat is — and where it isn't
We'll say the honest part out loud, because engineers can smell the alternative. Best-of-breed will out-depth us on any single plane — Pinecone on pure vector, Snowflake on pure warehouse. Our bet is that the seams cost more than the depth for the vast majority of teams, and that three things compound into a real moat: agent-native cohesion (the platform is the toolset), sovereign-by-construction (own hardware and network, not a residency checkbox you assemble), and ergonomics that accrue (every recipe and template makes the next pipeline cheaper to build). None of those is a feature a competitor ships in a sprint.
We're early, and we act like it — some planes are harder-edged than others, and we're hardening them in the open. But the shape is right, and the timing is rare: the exact moment the stack is consolidating, agents became the builders, and Europe decided sovereignty is non-negotiable.
That intersection is the whole company. That's why now.
Build on it:
- The two-minute setup — register, CLI, and a connected agent.
- Inside the DODIL AI Cloud — one bucket, three planes, in depth.
- Tutorials — the thesis, made concrete: leads, trading signals, a code KB, a semantic cache.
Sources: The data stack is breaking under AI scale (VAST) · The rise of the multimodal lakehouse (Gradient Flow) · Europe's 2026 tech spend & sovereignty (Forrester) · EU data residency for AI infrastructure (Lyceum) · MCP ecosystem 2026 (ChatForest) · Agent interoperability protocols 2026 (Zylos)