This is an interview with Alexander De Ridder, Co-Founder & CTO, SmythOS.com
Can you tell us about your background and current role in the tech industry? What inspired you to focus on AI and startups?
I grew up taking things apart to see how they worked, then taught myself to code as a kid and never really stopped. Today I serve as Co-Founder and CTO at SmythOS, where we build an operating system for AI agents so teams can turn messy, cross-app work into reliable, auditable workflows. Before this, I co-founded companies in search and content tech, which gave me a front-row seat to how machine learning changes distribution, incentives, and what it really takes to ship at scale.
Why AI and startups? I like the mix of art and systems. AI lets you design behavior, not just software, and startups move fast enough to test ideas with real users and learn in days, not quarters. The moment that hooked me was watching small, specialized agents cooperate to solve problems no single model could handle cleanly. That felt like the internet growing a new layer. My focus now is making that power safe and useful for normal teams: right-sized models, strong guardrails, clear provenance, and results you can explain to a customer without hand-waving.
How did your journey in tech and AI evolve to where you are today? Were there any pivotal moments or decisions that shaped your career path?
I did not plan a straight line into AI. I started as a builder who loved search, ranking, and the mechanics of “why did this result show up.” The first pivot was saying no to a comfortable platform role to ship a scrappy product with real users and an on-call pager. Owning uptime changed me. You stop arguing theory when a customer is blocked at 2 a.m.
The next pivot was painful: a launch that dazzled in demo and fizzled in production. We had speed but no provenance, clever prompts but no rollback path. Support could not explain answers, so trust evaporated. I rewired my approach: retrieval before generation, evals as a habit, smaller models when they match accuracy, and humans in the loop until the numbers are boring.
A third moment was a hiring decision. We chose a “boring” stack and operators who cared about change management, least privilege, and audit trails. Velocity went up because risk went down. That is when it clicked: AI that works at scale is an operations problem wrapped in a product.
Those choices pulled me toward company building and, eventually, to focus on agent runtimes and guardrails. My work now is less about showing off a model and more about making outcomes predictable: clear sources of truth, short-lived credentials, receipts for every run, and vendor swapability. The through line is simple. Ship where it matters, measure what changes, and earn trust by design, not by promise.
You’ve mentioned the importance of mastering one AI platform rather than chasing every new tool. Can you share a specific example of how this approach has benefited a startup you’ve worked with?
A seed-stage startup I advised stopped chasing tools and picked one AI platform for six months. That single choice changed the slope. We built a tiny SDK, a shared prompt library, and a living eval set tied to real tickets. We named failure modes, wrote playbooks for each, and tuned once instead of everywhere. Shipping sped up because every new feature reused the same guardrails, logging, and rollback. Cost dropped because we could right-size models with evidence, not guesses.
The clearest win was their support copilot. Before, every new tool meant new bugs, new auth, and another security review. After focus, we put retrieval in front of generation, added citations, and tracked accuracy, latency, and deflection on one dashboard. Time from idea to production fell from about four weeks to one. Onboarding a new engineer went from two weeks to three days because the examples and tests lived in one place. Incidents trended down because fixes landed in the shared SDK and every team got them for free.
The lesson is simple. Depth beats breadth. Mastery compounds because you improve the system, not just a feature. Pick one stack, measure everything, and let boredom, not hype, tell you when it is time to add a second.
In your experience, what’s the most common misconception about AI that you see among startup founders, and how do you help them overcome it?
The most common misconception is that “the model is the product.” Founders chase bigger models and clever prompts, then wonder why demos don’t survive real users.
The product is the workflow: data in, decision out, with provenance, guardrails, and a cost you can defend. I fix this by forcing one narrow use case into the light. We write the before-and-after SOP, define success in three metrics (accuracy, latency, unit cost), and build a tiny eval set from real tickets. Retrieval goes in front of generation, small models win by default, and every run keeps a receipt (inputs, outputs, tools, version). A human stays in the loop until the numbers are boring for three sprints. The change is immediate: fewer surprises, faster ship cycles, and a business that scales on evidence instead of hype.
You’ve highlighted the growing trend of AI agents. Could you walk us through a real-world case where you’ve seen AI agents dramatically improve a startup’s operations or bottom line?
A seed-stage SaaS team I worked with was drowning in repetitive ops. Support triage, refund reviews, and weekly data pulls ate most of the day. We stood up a small set of agents with a simple rule: retrieve first, act only with proof, and leave a receipt.
The support agent sat in the help desk. It read the ticket, pulled context from the knowledge base and CRM, proposed a reply with citations, and tagged edge cases for a human. The billing agent checked subscription state, usage, and past concessions, then drafted a refund or credit with the policy paragraph attached. A data agent ran scheduled health checks, compared metrics to guardrails, and opened tickets when something drifted.
IT gave them a paved road: identity-based access, least privilege to each system, short-lived credentials, and full logging of inputs, tools called, and outcomes. Product owned the evals. We built a tiny test set from real tickets and tracked three numbers per agent: accuracy, latency, and unit cost. A human stayed in the loop until the metrics were boring for three sprints.
Results were not flashy, just compounding. Median first response time fell from hours to minutes on repeated questions. Agent-drafted replies were accepted as is about two-thirds of the time, which freed humans for escalations. Billing adjustments went from a 2-day backlog to same-day because evidence was attached up front. Ops cost per ticket dropped, but customer satisfaction rose because answers were linked to the exact policy line.
The bottom line change was focus. Engineers stopped context switching to pull ad hoc reports. Support stopped hunting for data in five tools. Leadership got a single page showing accuracy, latency, and deflection by scenario, so we knew where to tune next. The lesson: agents move the needle when they live inside the workflow, act with guardrails, and prove their work.
As someone who reads AI research papers for fun, what’s a recent development in AI that you believe could be a game-changer for startups, but isn’t getting enough attention yet?
Structured generation with hard constraints is the quiet game-changer. Instead of begging a model to “be accurate,” you force it to emit valid JSON that matches a contract, call only approved tools with typed arguments, and return citations that pass a checker. With constrained decoding, function signatures, and tiny verifiers, you turn vibes into systems: fewer hallucinations, lower latency, and clean handoffs to your backend. A startup I advised went from flaky refund bots to a reliable flow by enforcing a schema for decisions, requiring the exact policy clause as evidence, and rejecting outputs that did not validate; acceptance doubled and support time dropped without a bigger model. The lesson: stop chasing size and start tightening interfaces. If you can make the model speak your API precisely and prove its claims, you can ship automation that survives real customers.
You’ve emphasized the importance of adaptability in leadership. Can you share a personal story of when you had to rapidly adapt to a change in the AI landscape, and what lessons you learned from that experience?
A few months after we launched our first support copilot, the primary model changed behavior overnight. Same prompts, very different refusals and tone. Tickets that were easy yesterday started bouncing to humans. It was a gut punch. The lesson landed fast: If your vendor sneezes, your product should not catch a cold.
We paused new traffic, flipped to a smaller standby model, and ran our eval set to see what actually broke. The failure pattern was clear. The bot depended too much on style and too little on structure. We rewired the flow in two days. Retrieval first. A strict schema for outputs. Required citations that must match a source paragraph. Any miss failed fast to a human with context attached.
Then we made the system adaptable on purpose. Prompts, tools, and data live in separate repos. A tiny router picks between two approved models based on task and cost caps. Every run keeps a receipt with inputs, sources, output, and version. Canary tests run hourly so we see drift before users do. Feature flags let us roll back in one click.
What changed for the team was trust. Engineers stopped fearing model updates because swaps were boring. Support trusted answers because every claim is linked to policy. Leadership got one page with accuracy, latency, and unit cost by scenario, which turned opinions into tuning work.
My takeaway is simple: Build for change, not for a vendor. Own your evals, keep a second source ready, force the model to speak your API, and keep humans in the loop until the numbers are steady. Adaptability is not a slogan. It is an architectural choice you make while things are calm.
Given your insights on blending AI with human teams, what’s your advice for startup leaders on maintaining team morale and productivity while integrating AI into their workflows?
Tell the truth early. AI changes how work gets done, and people fill silence with fear. Write a one-page plan that names the first workflow, the success metrics, what will not change, and how decisions will be made. Share it in plain language. If a role will shift from doing to supervising, say it. If you do not know yet, say that too and set a date to revisit.
Make wins and guardrails visible. Pick one high-volume task, run a two-week pilot with a human in the loop, and track three numbers on a single page: accuracy, cycle time, and unit cost. Celebrate saved time by giving it back to the team as deep work hours or customer time, not more meetings. Add a simple quality ritual: every AI draft must show sources, pass a checklist, and be owned by a person.
Co-design the future job. Ask the people doing the work to map the 80 percent path, failure modes, and what “good” looks like. Turn that into standard work the AI supports, not replaces. Offer upskilling tied to the new tasks: tool operation, evaluation, exception handling, and customer recovery. Put a real budget behind certifications so growth is not a promise.
Protect trust with policy and architecture. Least privilege access, short-lived credentials, and a rule that sensitive data does not go into prompts without redaction. Keep prompts, tools, and data separate so vendor swaps are boring, and keep a receipt for every run. When something goes wrong, run a blameless review that lands in one fix to the system, not one finger to a person.
Most of all, let the numbers lead. If accuracy slips or deflection spikes, slow down. If the pilot’s metrics hold green for three sprints, scale it and pay the team in time: fewer interrupts, clearer ownership, and a smaller queue. Morale follows clarity. People back a plan they helped design and a tool they can trust.
Looking ahead, what do you see as the biggest opportunity for startups in the AI space over the next 2-3 years, and how should they position themselves to capitalize on it?
The biggest opportunity is trustworthy automation in narrow, high-value workflows. Not a general chatbot. A set of agents that retrieve from your sources, act inside your systems with guardrails, and leave receipts a customer or auditor can read. Think refunds with policy proof, onboarding with exact checklists, compliance reviews with citations. Startups that make this boring and reliable will win contracts while others demo.
Positioning is simple. Own the evaluation set and the data glue. Build a living test suite from real tickets, track accuracy, latency, and unit cost per scenario, and make swaps easy by separating prompts, tools, and data. Use small models when they match accuracy, larger ones only when they buy you something measurable. Force structured outputs that match your API, require evidence for claims, and fail fast to a human when confidence is low. Ship one closed-loop workflow, prove the numbers for three sprints, then expand sideways.
The go-to-market is hiding in plain sight. Sell into teams already drowning in repeat work and bound by rules: support, onboarding, finance ops, healthcare intake, claims, compliance. Integrate where they live, not in a new tab. Price on outcomes like deflection, cycle time, and measurable risk reduction. Keep a second-source model ready, publish your rollback plan, and talk about accuracy per dollar and per watt like a grown-up. In the next 2 to 3 years, the winners will not be the flashiest models. They will be the operators who turn AI into dependable work that ships every day.
Thanks for sharing your knowledge and expertise. Is there anything else you’d like to add?
One last thing: make your AI work auditable before you make it fancy. Own a small eval set from real tasks, keep a receipt for every run, and separate prompts, tools, and data so swaps are boring. Set three guardrails on each workflow: a target accuracy, a deadline, and a cost ceiling. Review them weekly like a scorecard, not a science project. Pay the team in time when you win back hours, not more meetings. Write down what you will never do with customer data and enforce it in code. Do these simple, unglamorous things, and trust will compound while the roadmap gets easier every month.
