Agents that are still running a year later
We build AI agents for the work your business actually runs on: internal operations, back-office workflows, the process that lives across six systems and one person’s head. The first ones we shipped are still running.
scoped builds · your stack · your keys · in production over a year
Start where the hours are going
The best first agent is rarely the most impressive one. It is the process your team quietly loses a day a week to.
The work that keeps operations moving
Intake, triage, reconciliation, research, reporting, and status coordination across five tools. Recurring processes that span teams, consume hours each week, and benefit from a clear owner.
The process that lives in six places
Your CRM, your database, your ticketing, your docs, and one person who knows how it all connects. Agents that read and write in those systems directly, through real APIs with scoped credentials.
Agents your customers touch
Agents inside a multi-tenant SaaS, with per-tenant budgets and monitoring from day one. Each customer gets bounded behavior and visible usage.
Built for month fourteen
Production agents need to handle provider outages, schema changes, and long gaps between human check-ins. Six foundations keep the work reliable over time.
Durable by default
Long-running work keeps its place through restarts, timeouts, and provider outages, with clear recovery paths and human controls.
Evals before launch
We build a set of cases from your actual work and hold the agent to them before launch. Every model upgrade has to pass those same cases before rollout.
Real integrations
Agents act through stable APIs and databases with scoped, revocable credentials.
Budgets and monitoring
Spend caps per workflow, readable logs, and alerts when behaviour drifts keep operations and cost visible day to day.
Permissions you can inspect and test
We examine retrieval boundaries, tool permissions, and approval controls, then test what happens when the agent encounters untrusted content. Useful access, with clear limits.
Explore agent security checks →Built for your team to own
It runs in your accounts, on your keys, in a repo you own, with documentation your team can use to change it directly. Ongoing support is available whenever it helps.
The first agents we built for customers have now been running in production for more than a year, doing the same job every day on the same production build.
That production record is the proof that matters.
Something real in weeks
Scoped builds with fixed quotes. You see an agent doing actual work early enough to change your mind about what it should be doing.
Find the workflow that pays
We look at what your team actually does and pick the one process where automation earns its keep first. We choose the simplest reliable implementation: an agent, scheduled job, webhook, or form.
Build thin, ship early
The smallest useful version goes live in weeks, doing one real job for real people. Scope grows from what works in practice and what users learn.
Instrument it
Evals, budgets, logging, alerting, and a rollback path. The agent gets the same operational treatment as any service you would page an engineer for at 2am.
Hand it off
Docs, a walkthrough with whoever owns it now, and the keys. Your team takes ownership, with support available for as long as it helps.
We run this infrastructure ourselves
Your agents run on the same platforms and libraries our own products do. When work reaches the runtime level, our team can fix the platform code directly.
Mobius
The coordination platform our internal-ops builds run on: sessions, tools, skills, memory, streaming, and long-running work, across all the major LLM providers.
Nvoken
The durable agent runtime behind product-embedded work: per-tenant budgeting and monitoring built in, with reliable recovery across provider and infrastructure failures.
Dive
Our open-source Go library for cross-provider LLM work and agent building. It exists because we needed it, and it lets your team switch providers as requirements change.
Curtis Myzie
Curtis is a software engineer and the founder of Deep Noodle: 20+ years building production systems, with stints as CTO, VP of Engineering, and VP of Product at venture-backed startups.
He builds Deep Noodle’s own agent platforms and maintains the open-source libraries this work runs on. Client agents ship on the same runtime as our products, which is why the unglamorous parts (durability, evals, budgets, credentials) get taken as seriously here as the model does.
Client agents running in production for over a year
Works with frontier AI models and agent tooling every day
Builds Mobius and Nvoken, our own agent platforms
Open-source maintainer (Dive, Risor, Wonton) with 1,000+ GitHub stars
CTO, VP Engineering, and VP Product at venture-backed startups
Common questions
// start with one valuable workflow
Tell us what eats your team’s week
Book a call and describe the process. We’ll tell you whether an agent is the right answer, what it would take, and what it would cost.