Agentic AI
Assistants that use tools and take real actions, answers grounded in your own content, and evaluation that proves they hold up. On Claude, Gemini or GPT, or on open-weight models running on hardware you control.
Available for new projects
Software that survives contact with reality
Agentic AI, product engineering, and the infrastructure to run both.
digitalcosmos.io is an engineering practice in Haarlem that builds serious software and then keeps it running. AI systems that use tools and act rather than just chat, grounded in your own data and measured before a customer does it for you. Underneath: multi-tenant platforms, cloud environments defined entirely as code, and the unglamorous operational work that decides whether any of it holds up on a Monday morning.
Agentic AI and RAGEvaluation and guardrailsFull-stack product engineeringCloud, data and security
Our proving ground
An entire ecosystem, owned end to end
The sharpest way to judge an engineering partner is to look at something they own completely. Not a component they contributed to, but a living system they designed, built, shipped, and still answer for at three in the morning. Alongside client work we run exactly that: a multi-tenant platform of our own, spanning a web application, native mobile apps, AI services, four production databases, and the cloud estate beneath them.
Almost everything described here was proven there first. The AI is grounded and measured because ours had to survive real customers. Tenant isolation is enforced by the database because application-level checks were not enough. Deployments are boring because we are the ones woken when they are not. None of it is theory we read somewhere.
Client work stays confidential. This platform is ours, which is why we can describe it in this much detail.
- One shared codebase serving the web application and native Android and iPhone builds
- An AI assistant that answers from the product knowledge base and takes real actions through tools
- Self-hosted language models, so customer data never has to leave the estate
- Four production databases, with tenant isolation enforced by the database itself
- Four languages shipped in the product, with translation parity enforced in CI
- Cloud infrastructure defined as code across eight layers, released blue-green with instant rollback
- Subscription billing, transactional and campaign email, GDPR consent and a complete audit trail
AI on top of an engineering practice that can carry it
Most AI projects do not fail at the model. They fail at the retrieval, the data model, the permissions, the cost, or the fact that nobody owns the thing at 3am. We build the intelligence and the plumbing underneath it, so nothing gets handed off into a gap.
RAG and search
Retrieval that actually retrieves: hybrid vector and keyword search, rank fusion, language-scoped indexes, and chunk-level attribution so an answer can be traced back to its source.
Product engineering
Web platforms and internal tools built as long-lived products: typed end to end, tested where it matters, and structured so the tenth feature is as cheap to add as the first.
Mobile apps for Android and iPhone
Native Android and iOS apps built from one shared codebase alongside the web app, with platform sign-in, push notifications, camera and file access, and store releases handled as part of the ordinary delivery pipeline.
Cloud and DevOps
Reproducible environments defined as code, container pipelines, blue-green releases and rollbacks that are boring on purpose. Deployment stops being an event.
Data architecture
Schemas that stay sane at scale, strict tenant isolation, vector stores sized to the embedding model, migrations that never lock a production table, and backups that have actually been restored.
Security and AI governance
Single sign-on, granular access control and immutable audit trails, extended to the agent: tools that take identity from the verified session rather than from anything the model wrote.
Realtime and integrations
Websockets, message queues, event pipelines, payment and billing flows, transactional email and third-party APIs wired together so failures degrade instead of cascading.
Applied intelligence
AI you can actually put in front of customers
Large language models are easy to demo and hard to operate. The interesting work is everything around the model: grounding answers in your real data, giving the agent tools it can use safely, deciding what runs on a hosted API versus your own hardware, and measuring quality before a customer measures it for you.
Reliability here is an architecture problem, not a prompt problem. This is work we have already shipped and run in production, against real cost and latency targets rather than on a slide.
- Tool-using agents that take real actions, with strict tool contracts and bounded execution
- Retrieval-augmented generation over your own private content
- Hybrid retrieval: vector plus keyword search, combined with reciprocal rank fusion
- Golden-set evaluation in the pipeline, scored on Hit@k, MRR and nDCG
- LLM-as-judge faithfulness checks that catch answers the sources do not support
- Tools that take identity from the verified session, never from model output
- Model routing that sends cheap work to a cheap model and keeps the budget honest
- Hosted or self-hosted behind one interface, so changing provider is not a rewrite
Built on Anthropic Claude, Google Gemini and OpenAI GPT, plus self-hosted open-weight models
Small team, short feedback loops, no theatre
You talk to the person writing the code. There is no account layer to route questions through and no ceremony that exists only to be reported on.
Understand
We start with the constraint that actually hurts: the deadline, the cost, the audit, the process nobody wants to admit is manual. Technology choices come after that, never before.
Shape
An architecture you can read: data model, boundaries, hosting, failure modes and a realistic estimate, written down before anyone opens an editor.
Build
Short iterations with something demonstrable at the end of each one. Continuous integration from day one, so the deployable state is always the current state.
Operate
Monitoring, backups, patching and a documented recovery path. Software is not finished when it ships, it is finished when it runs unattended.
Engineering judgement, not just capacity
Anyone can add features. The value is in knowing which ones will cost you for the next five years.
Built to be maintained
Clear boundaries, typed interfaces, meaningful tests and documentation written for the person who inherits it. Including when that person is not us.
Operations included
We run what we build. That single fact changes every design decision, because there is nobody else to hand the consequences to.
Honest about trade-offs
You will hear when a simpler option is better, when a feature is not worth its complexity, and when the answer is to change a process rather than write code.
Independent by choice
No reseller quotas and no preferred vendor. Recommendations are based on what fits your budget and your team, and you own everything we produce.
Have something worth building?
Send a couple of paragraphs about the problem. You get a straight answer about whether it is a fit, a rough shape of the solution and an honest estimate, with no obligation attached.
Replies usually within one working day.