Administration SaaS From Cursor prototype to SaaS in 6 weeks: how a solo founder launched his AI-built app
Next.js TypeScript Supabase +7
Automate your processes with AI, built to stay reliable
Want to automate your business processes with AI, or have an AI agent built that you can actually trust? We build automations and agents with access to your real systems that stay reliable as the models underneath them change. Our senior engineers build the layer around it: the harness, the evals, the monitoring and the connections to your existing software.
The system around the model
The harness around it decides what the agent is allowed to do, which tools it has, and which evals warn you when a model update breaks something. That's where the real work is.
Self-optimizing systems
Systems that measure what works and adjust themselves, under human oversight. The agent does the volume, the human decides.
Legacy adapter layer
A clean layer between AI and your old systems that have no modern API. We connect what wasn't connectable.
Build on what you have
Already have an n8n flow, Make scenario, or custom script? We don't throw it away. We make it production-ready: tests, error handling, monitoring.
Our Skills and Technologies
Anthropic Claude
RAG
Vector databases
Evals
Observability
API Integration
Webhook Management
Legacy Integration
Real-world projects where we applied AI automation to deliver results.
Administration SaaS 
010 Coding Collective Most websites get launched and then forgotten — so we built Growthdesk
AI LLMs AI Agents +5
B2B Mobility Scale-up The Make flow that worked 80%: how a scale-up made their automation production-ready
n8n Make.com Python +8
Tech Recruitment Agency How a recruitment agency used AI for CV screening without falling into the bias trap
AI LLMs Python +8
Utilitarian When circularity meets agility
LLMs React Next.js +7
Automating your business processes with AI, having an AI agent built, or making an existing n8n or Make flow production-ready: the pattern is always the same. The demo is easy to build, the reliability underneath is the real work. We’re the Rotterdam engineers who build it.
Does this sound familiar?
- Your demo worked perfectly, until you let real users and real data loose on it and it quietly fell over
- ChatGPT does 80% of the task, but that last 20% (reliability, edge cases, error handling) has cost you weeks by now
- You have an n8n or Make flow that runs, but you don’t dare lean on it blindly: no logging, no tests, and it stalls the moment something changes
- You’d like to give an agent write access to your CRM or admin, but you don’t dare, and rightly so
- Your AI needs to talk to an old system that has no proper API, and nobody knows how to connect it safely
- It worked last month, but since the model update it behaves differently, and you only noticed when a customer complained
If you’re nodding: the tool is rarely the problem. What’s missing is the layer around it.
The model is the easy part
Anyone can call a model. A fetch to the OpenAI API is five lines of code. That’s why the demo feels so close to production. And that’s why almost everyone falls into the same gap.
Because the real work only starts after the demo. This is what knocks most AI projects over in production:
📉
The demo-to-production gap
The model does the first 80% almost for free. The last 20% (edge cases, error handling, retries, what happens when the model returns something unexpected) is the real engineering work, and exactly what a demo never shows.
✍️
Every write action is a risk
An agent that only reads is low risk. An agent allowed to write, send an email, change a record, start a payment, can also genuinely break something. That's where most of the attention should go, and where most demos skip right past.
🔄
Models change under your feet
The provider updates the model and your agent behaves differently. Subtly, but enough to break something. Without evals checking every version, you only find out when a user complains. An AI system without evals is a system you can't trust.
🔍
No logging means flying blind
If you can't see what the agent decided and why, you can't debug, can't improve, and can't explain what went wrong. Observability turns an agent from a black box into a system you can trust.
🧩
No-code tools scale until they don't
n8n and Make are fantastic for getting started fast. But once it gets serious you hit the limits: no version control, no tests, error handling you don't control, and lock-in you didn't plan for. Fine to prove something can work, shaky as a foundation to run your business on.
🔌
Legacy systems don't just talk along
Plenty of business software has no modern API. Want to connect AI to it, and you need an adapter layer that cleanly exposes the old system without rebuilding it. That's invisible work no demo ever touches, and exactly where integrations stall in practice.
Our take on AI automation
We build the systems around your AI that make it reliable. What separates an impressive demo from something you’d run your business on is almost always the engineering around it, and rarely the model itself.
Anyone can call a model. The real work is the system around it: the harness that decides what the agent is allowed to do, the evals that warn you when an update breaks something, the logging that lets you see what’s happening. That’s software engineering. That’s where our strength is, in building that layer instead of wiring together yet another tool.
Jeroen , 010 Coding Collective
How you build such a trustworthy agent layer by layer, we wrote up in our deep-dive on building an AI agent you can actually trust: from permissions and tools to evals and observability. Still figuring out what an agent even is and when to use one? Start with what are AI agents.
What we build
The layer around the model that decides whether you dare trust an agent.
A clear split between reading and writing, every write action deliberate and bounded
The right tools and MCP connections, no more than needed
Evals that check every model version before it goes live
Logging and observability so you see what the agent did and why
Systems that measure what works and adjust themselves, under human oversight. The agent does the volume, the human decides.
Continuous measuring and adjusting instead of a one-off delivery
AI does the tireless work, a human makes the calls
Built to get better week after week, not to stall after launch
Works across many processes at once without the attention thinning out
A clean layer between AI and your old systems that have no modern API. We connect what wasn't connectable.
Exposing legacy software without rebuilding it
A stable API layer that AI and modern tools can actually build on
Safely reading from and writing to systems never designed for it
The integration that stalls every project in practice
Already have an n8n flow or Make scenario? We don't throw it away. We make it robust enough to lean on.
Your existing flow as a starting point to build on
The tests, error handling and retries you're missing now
Monitoring and alerting so you know before your customer does
Replaced where needed with code you actually control
This isn’t theory. A Make flow that worked 80% we made production-ready. The whole story is in The Make flow that worked 80%. And the most meta proof: the site you’re reading now runs on a self-optimizing system like this itself.
How we build AI systems
Free
Free consultation
A process eating your time, a flow you don't trust, or an agent you want to deploy? We walk through your situation and tell you honestly what production-ready means for you.
Includes
- 1.5 hours with senior developer(s)
- Review of your current setup or flow
- Written summary afterwards
- Concrete next steps
Best for: anyone with an AI idea or a flow that needs to be better
On request
Proof of Concept
In 2-4 weeks we build a working prototype on your real data and systems, so you know whether it works before you invest big.
Includes
- Getting requirements and scope sharp
- Working prototype in 2-4 weeks
- Tested on your own data, not a demo set
- Integration with one existing system
- Honest go/no-go advice for further rollout
Possible activities
AI agent MCP connection RAG over your own documents Chatbot with handoff Document processing n8n/Make flow CRM integration Webhook triggers
Best for: teams wanting to validate whether AI works for their case
On request
Build & operate
We build the full system (harness, evals, monitoring and integrations) and keep operating it as models and your business change.
Includes
- Production system with the harness around it
- Evals that catch model updates before they break anything
- Logging and observability from day one
- Integration with your existing and legacy systems
- Monitoring, alerting and ongoing maintenance
- A human in the loop where it matters
Possible activities
Agent harness Evals & monitoring RAG & vector search Legacy adapter layer API development Self-optimizing loops Observability Ongoing operation
Best for: organizations that want to run AI reliably in production
* Pricing is indicative and depends on specific project requirements and scope.
How does it work?
We always start with a free consultation. In ninety minutes we look at your process or your existing flow, and discuss honestly what it takes to make it production-ready. Then we determine the best next step together. No obligations.
Possible next steps:
- Proof of Concept: a working prototype on your own data in 2-4 weeks
- Build & operate: the full system, built and maintained
- Ongoing support: as an extension of your team (see software development support)
Not sure your vibe-coded prototype can even be the foundation? Start with a vibe coding audit, then you know what holds up before you build further.
What is AI automation?
AI automation is automating tasks and processes with AI models that can handle text, data and decisions, instead of only fixed if-this-then-that rules. Think of handling emails, processing documents, or an agent that takes actions in your systems itself. What makes it powerful is that AI can also cope with messy input and context. The work is in making it reliable: the harness, the evals and the monitoring around it.
What's the difference between AI automation and regular automation?
Regular automation follows fixed rules: if this happens, do that. That works as long as the input is predictable. AI automation can also handle messy or unstructured input, interpret context and choose the right action itself. That makes it more broadly useful, but also less predictable, which is exactly why we build evals and monitoring around it so you can rely on it.
What does AI automation cost?
It depends on what you're automating and how critical it is. We always start with a free consultation to get the scope sharp. A proof of concept on your own data usually takes 2 to 4 weeks; a full system with operation is bespoke. You get an honest estimate up front, with no surprises afterwards.
What's the difference between an AI demo and a production AI system?
A demo shows that something can work, usually on a clean dataset and with someone who knows how to operate it. A production system also works when the input is messy, the model returns something unexpected, or a hundred people use it at once. The difference is in the layer around it: error handling, evals, logging and monitoring. That last 20% is the bulk of the work and exactly what a demo never shows.
Can I give an AI agent write access to my systems?
Yes, but deliberately and bounded. An agent that only reads is low risk; an agent allowed to write can genuinely break something. We build the harness so every write action is explicit, bounded and logged, and so a human decides where that matters. That way you get the convenience without trusting the system blindly.
My n8n or Make flow already works, why put more into it?
Because 'works now' is different from 'keeps working'. No-code flows usually lack version control, tests, proper error handling and monitoring, and they're tied to the tool. Fine as a starting point to prove something can work. Once you start leaning on it, we make it production-ready: sometimes by strengthening the flow, sometimes by replacing the critical part with code you actually control.
Does AI work with my old or legacy system?
Often yes, even without a modern API. We build an adapter layer that cleanly exposes your legacy system without you having to rebuild it, so AI and modern tools can connect to it safely. That connection is exactly where integration projects stall in practice, and where we're good.
What happens when the AI model is updated?
That's exactly why we build evals. A model update can change behavior subtly, enough to break something. With a set of evals we automatically check every new version against the cases that matter to you, so you see a problem before your users do. Without evals, an AI system can't be trusted.
Do you also build on what I already have?
Almost always. An n8n flow, a vibe-coded prototype or a half-finished script: we rarely throw anything away. We look at what holds up, what has to go, and the fastest route to reliable. A Make flow that already worked 80%, for instance, is one we took all the way to production.
Our team has extensive experience with the technologies behind AI automation. Discover which team members are specialized in this area.
-
Jeroen Marchand
-
Kevin Schenkers
-
Maikel Hofman
-
Marcel Fleuren
-
Jur Ligteringen
-
Kevin Land
-
Eward Bartlema
From AI prototypes that need to be production-ready to strategic advice, code audits, or ongoing development support. We're happy to think along about the best approach, no strings attached.
free
Free Consultation
In 1.5 hours we discuss your project, challenges and goals. Honest advice from senior developers, no sales pitch.
1.5 hours with senior developer(s)
Analysis of your current situation
Written summary afterwards
Concrete next steps