Tembo: The Background Coding Agents Company

CV Deep Dive

Today, we’re talking with Darren Baldwin, Co-founder and CTO of Tembo, and Benjamin Akar, co-founder and CPO of Tembo.

Tembo is a background coding agents platform built to run agents in parallel and keep them working continuously. Founded in 2022 by Darren Baldwin, Benjamin Akar, and Ry Walker (co-founder of Astronomer), Tembo originally started as a managed Postgres service focused on extensions before pivoting into the AI coding agent space early. Today, Tembo is model-agnostic and designed to operate inside the tools engineers already use, with automations triggered by signals from integrations or on a schedule, and support for manually delegating work from tools like Linear.

Today, teams use Tembo for configurable PR reviews, recurring automations like changelog generation and security scans, and end-to-end task delegation that can result in merged PRs, new tickets, research, or Slack updates. Under the hood, Tembo spins up full VM sandboxes with repo access so agents can do real reviews, not just diff checks, and it supports tighter control over dependency versions to avoid noisy lockfile churn. Tembo raised a $6,500,000 seed round and later a $15,000,000 Series A, and the team has intentionally stayed small to move fast.

In this conversation, Darren and Benjamin share how Tembo was founded, why they pivoted, what they’re seeing from always-on agent automations, and their vision for where background agents are headed over the next 6 to 12 months.

Let’s dive in ⚡️

Read time: 8 mins

Our Chat with Darren and Benjamin 💬

Benjamin Akar and Darren Baldwin, introduce yourself and give us a bit of background on you and Tembo. What led you guys to starting Tembo?

My name is Darren Baldwin. I’m the co-founder and CTO of Tembo. I’ve worked at early-stage startups my entire career. I started Tembo with Ry Walker back in 2022. We began as a managed Postgres service centered around Postgres extensions, had solid traction, raised a $6,500,000 seed round, then a $15,000,000 Series A about a year and a half ago, and eventually decided to pivot into the AI coding agent space. We were early, before Claude Code even existed. At the time we built the initial Tembo cloud product, the only coding agent that existed was something called “Aider” and it had just come out. Now we’ve been full force on the AI coding agents product for about eight or nine months, and it’s going well so far.

My name is Benjamin Akar. I’m the co-founder and CPO of Tembo. I started early, around 12 or 13, and taught myself both coding and design through streaming on Twitch and a lot of iteration. I never took a traditional path. I was hired as the youngest developer ever at the largest classifieds company in Scandinavia, working on frontend infrastructure and internal tooling, and later joined Sanity to work on their ecosystem team building developer tooling. After spending time in both corporate and startup environments, I realized I’m most effective in product-focused teams where you can move quickly and stay close to the work. When Darren reached out and pitched the new pivot for Tembo, it immediately clicked. I joined to help make it happen, and I’ve been building Tembo as a co-founder for the past year.

How would you describe Tembo to the uninitiated developer or AI team?

Tembo is the best way to run coding agents in the background. You can delegate work manually or set up automations that react to your codebase or signals from integrations, like generating changelogs from recent commits or reviewing pull requests based on your own instructions. Tembo can pull in context from your integrations like GitHub, Sentry, Notion, and more, so it can reason over real production data. You can scope automations to specific teams or run them globally across your org. Tembo is the orchestration layer for background agents. We’re fully agent- and model-agnostic, supporting all major models.

Tell us about your key users today. Who would you say is finding the most value in what you're building with Tembo? 

Our key users today are engineers and teams who want agents working for them in parallel and in the background at all times. People are realizing that if you’re not running agents continuously, you’re leaving a lot of leverage on the table. Last week was our biggest week ever, roughly 2x our previous best, and that momentum is coming from teams adopting always-on agents. Tembo is built for this. We like to say we’re the background coding agents company. 

Our most active users love that they can orchestrate always-on automations and keep agents running without babysitting them. We also have the “Ralph Wiggum” pattern built in as a first-class feature, where you can keep an agent running and re-prompt it until it reaches a goal. It all runs in the cloud, with very little setup.

Recently, a lot of people have been excited about our Linear integration. Tembo is built to be wherever you already do work. Software engineers are dramatically more effective when agents have access to the same tools they do. If you want an agent to debug an issue, it helps if it can see Sentry or Grafana. If you want to assign work, it needs to live inside tools like Linear, Jira, or GitHub Issues. With Tembo, you can take a one-off issue, assign it to an agent, and get a PR back in minutes. We were also the first to build a coding agent integration inside Linear about a year ago, and we’re now featured on the Linear for Agents homepage after they added first-party support for agents.

Talk to us about some existing use-cases for Tembo. Any interesting customer stories you’d like to highlight? 

Where Tembo really shines is in custom workflows. Teams can set up automations that match how they already work instead of changing their process to fit a tool. For example, we have customers running weekly security scans, automatically creating Linear tickets, triggering follow-up automations when new issues are created to plan and scope the work, and then handing it off to Tembo to resolve. Every company works differently, so we focused on building powerful primitives that let teams compose their own workflows.

Our PR review workflow is a good example of this. It’s fully configurable. You can customize the prompt, scope it per developer or per team, and enforce different rules for different parts of the org. A backend team might check for specific performance or safety patterns, while a frontend team might care more about design systems and conventions. As we move into a world of background agents, a lot of the value is in automating the repetitive work that humans still spend time on today.

We spoke this morning with one of the largest ads vendors in the world. They use Bitbucket and Jira at massive scale, and their CTO described a workflow where any time a ticket is opened in a specific board, Tembo would automatically take action. He had a long list of things he’d want it to do. That’s not something you can support with a single hard-coded feature. You need a system that lets customers define their own workflows using building blocks. With Tembo, they can set up a Jira trigger, spin up a VM, run Claude Code with Opus 4.5, pull in context via MCP tools and CLIs, and execute whatever workflow they need. That combination of VM, agent, prompt, and tools is what makes this powerful. It’s not one use case. It’s a platform. And we’ve only scratched the surface so far.

Walk us through Tembo’s platform. Which use-cases should new customers experiment with first, and how easy is it for them to get started? 

You can start with manual tasks or set up triggered automations. A great first workflow is PR reviews, since no matter how you write code, everyone benefits from better reviews. You install Tembo, connect your repo, and clone the PR review automation from our library. From there, you can keep it as-is or customize it per team or globally, and Tembo runs it automatically in the background every time a pull request is opened. If your team uses Linear, another high-leverage use case is assigning a one-off issue to an agent and getting a PR back quickly.

Getting started is straightforward since everything runs in the cloud and there’s very little setup.

How are you measuring the impact and/or results that you’re creating for your key customers? What are you most heavily focused on metrics-wise? 

Our primary metric has always been merged PRs. Early on, Tembo only opened PRs, so the signal was simple: if the PR wasn’t merged, it probably wasn’t useful. That’s still our most important metric today. A merged PR means Tembo did real work and that work shipped to production.

As we’ve expanded beyond just code changes, we now also track tasks delegated to Tembo. A task might open a PR, create a Linear ticket, analyze a codebase, do research, or respond in a Slack thread. Tasks can be delegated directly by a human or triggered by an automation they’ve set up. It gives us a clear picture of how much real work Tembo is taking off people’s plates.

We also send a weekly usage email that’s written as if the agent is talking to you. It lists the work it did that week, like merged PRs and created tickets. The goal is to make Tembo feel less like a tool and more like a teammate that’s always working in the background.

There are a number of companies working on PR Reviews. What sets Tembo apart from a product or technical perspective? 

What sets Tembo apart is that it’s fully configurable and deeply customizable. Tembo doesn’t just review a PR diff. It has full access to your integrations and any connected MCP tools. When Tembo reviews a PR, it spins up a full VM sandbox with access to the entire filesystem, can search through the codebase, run commands, and use the agent to reason about the change. You can choose which agent and model to use, whether that’s Codex, Claude Code, Gemini, or others.

Tembo is the orchestration layer that lets you do all of this through our automation system. PR review is just one use case. You can review PRs, run security scans across the codebase, or automate routine workflows, like sending a Slack summary every Monday of everything that happened in Linear. It’s not just review, it’s everything around the work.

Code output is increasing exponentially. Right now we have around 55 open PRs, and almost all of them were written by humans using agents. We also have PRs opened directly by agents. The real bottleneck is review, making sure the code is correct and actually works. A real review isn’t just reading a diff. It’s cloning the repo, installing dependencies, running the app, running tests, and then reviewing. Some teams have preview links, but not all do. Tembo does all of that. It clones the repo, installs dependencies, runs tests, reasons about the change, and then leaves a review. It can also pull in context from tools like Sentry or Linear, for example tracing a Sentry issue to the relevant file, the same way a real engineer would.

Could you share a little bit about how Tembo’s platform actually works under the hood? What’s the reasoning behind some of the architectural decisions you made?

Early on, we made a deliberate decision to build Tembo with as few external dependencies as possible. It’s an unusual choice, especially when speed matters, but it makes Tembo much easier to self-host and operate. You can run it with a single Dockerfile or Docker Compose, which is important for larger companies with stricter infrastructure requirements.

We also built our own sandboxing infrastructure. One of the biggest challenges is that every repo is different. They use different Node versions, Bun versions, package managers, and toolchains. If the environment in the sandbox doesn’t match what’s pinned in the repo, something as simple as running npm install can change the lockfile and create noisy diffs. You see this all the time with tools like Devin, Codex Web, and others. We solved this by letting users define an explicit config file with the exact versions they want, and then applying that configuration directly to the VM running in our sandbox. That way the environment always matches the repo. To our knowledge, no other product offers that level of version control. Most tools rely on setup scripts or a curated list of “popular” versions. With Tembo, you can use any version you need.

The SaaS itself runs entirely on AWS, with the frontend deployed on Vercel. Our sandboxes run on AWS EC2 bare metal today, but they’re designed to be portable and can run on other providers as well. We’ve already looked at options like Hetzner, and the architecture supports that flexibility.

What has been the hardest technical challenge around building Tembo into the platform it is today?

The hardest technical challenge has been building the sandboxing infrastructure. There are entire startups focused only on that. You often hear “don’t build something that isn’t your product,” but if you’re building an AI software engineer, you need full control over the environment. The sandboxing space is still too young for us to pick a provider and bet the company on it, so we built it ourselves.

Another major challenge is building a unified interface across every coding agent. The space is moving quickly, the APIs and capabilities are changing, and you’re often at the mercy of other companies’ docs and product decisions. Keeping that abstraction clean and stable has been non-trivial.

The third big challenge is being truly model-agnostic. That means reliable capacity across providers like Anthropic, OpenAI, Cerebras, Groq, AWS Bedrock, Azure, and GCP. We’ve spent the past year building relationships, capacity planning, and fallbacks so that if one provider is down, Tembo isn’t.

2026 is the year of the AI Agent. How does this concept factor into your product vision or internal process at Tembo, if at all? 

We’ve been building toward this for a while. Last year, we were probably early. This year, it feels like people are finally realizing how much work can happen in the background. Not just routine work, but real tasks. If you have a big goal like “add this feature,” Tembo can break it into smaller pieces and spin up multiple specialized agents to work on them in parallel.

We think 2026 is the year people start thinking in terms of tasks, not code. That’s shaping both our product and our internal roadmap. We’re focused on making it easy to plan work with high confidence, and then hand it off to run in the background. You can guide and refine tasks up front, and if something goes off track, you can step in and re-direct it. It’s about keeping humans in the loop without pulling work back into the foreground.

I’ve been programming for over a decade, and this is the first time the space has felt this fast and unpredictable. Nobody knows what things will look like in three months. You have to earn product-market fit over and over again as the market shifts. That’s what makes it challenging, and that’s what makes it exciting.

How do you foresee Tembo evolving over the next 6-12 months? Any product developments that your key users should be most excited about? 

Over the next six to twelve months, our biggest focus is planning and chat mode. People plan work in a lot of different ways today, and we’re building that directly into Tembo so you can reason about a problem, sketch an approach, and break it down into tasks before handing it off to run in the background. The goal is to treat planning as a core part of the workflow, not something you do in a separate tool.

We’re also expanding our integrations and trigger system, which lets workflows compound over time. As we add more integrations, the number of things you can automate keeps growing.

In parallel, we’re continuing to add support for more agents and models and investing heavily in the core platform to make sure Tembo remains the best place to run background agents.

Lastly, tell us a bit about the team at Tembo. How would you describe your culture, and are you hiring? What do you look for in prospective team members joining the company? 

We’re very small right now, seven full-time people, with a new engineer who joined last week. At our peak, when we were still focused on Postgres, we were around 28. We intentionally keep the team small. With the tools available today, small teams can move incredibly fast, and you don’t need a massive org to build something ambitious.

Culturally, this is an incredible time to be building. We’re operating in one of the fastest moving spaces in software, and there’s a lot of noise, so we stay extremely focused. We work in short cycles, shift priorities quickly, and rely heavily on autonomy and trust. Everyone on the team needs to be able to pick things up and run with them without a lot of management overhead.

We are hiring, but opportunistically. If we meet someone we can’t pass up, we’ll move. We look for people with strong product sense, solid technical fundamentals, and the ability to operate across more than one area. We value generalists who can go deep when needed. Taste matters a lot to us, especially product taste. Good judgment about what to build and how it should feel. We think that will only become more important as the space gets noisier.

Anything else you'd like our readers to know about the work you’re doing at Tembo?

Tembo is completely free to get started. You can sign up and try it today. If something doesn’t click, tell us why. We’re building this in the open and that feedback genuinely shapes the product.

Conclusion

Stay up to date on the latest with Tembo, follow them here.

Read our past few Deep Dives below:

• OpenAI’s Codex Lets One Engineer Ship Like a Team of Ten ⚡

• Redis is much more than a database 🛢

• Augment Code is Your AI Coding Agent for Real-World Codebases ⚙️

• Nebius is Your Full-Stack AI Cloud and Inference Platform ⚡️🧩

• Zo Computer is Your Personal AI Cloud Computer 💻⚡

If you would like us to ‘Deep Dive’ a founder, team or product launch, please DM our chatbot here.

CV • Instagram • X • All Events