Blog
Let's Move Beyond Agent Builders
Reimagining How Software Thinks, Collaborates, and Works With Us.
(OR Why We're Not Afraid of The Big Bad Agent Builders)
October 9, 2025
Ben Stein
CEO, Teammates
For the past year and a half, every month has brought a new “agent platform” promising the dawn of autonomous software. I’ll be honest: being a startup founder whose product is reductively labeled an Agent Builder is a branding nightmare. How do you differentiate what you’ve built from AgentForce, AgentSpace, ServiceNow Agent Studio
This month brought two of the biggest “AI agent builder” announcements yet: OpenAI’s Agent Kit and Anthropic’s Agent SDK, each paired with new chat experiences.
As a founder in this space, you can imagine how many times I’ve been asked: “So how does Teammates compare to these?” Spoiler alert: we’re not in the agent-builder business. We’re in the teammate-building business. Our focus isn’t spinning up individual agents or automating specific workflows. Our focus is creating AI colleagues who understand you, your business, collaborate across systems, and contribute like real members of a team.
This distinction is to claim but hard to explain, I'm going to start first with what we mean by AI agent, how other players fit into this definition (or not), and finally why referring to a Teammate as an AI agent is missing the point entirely.
Let’s start with a shared language, lest we talk past one another.
Rather than make something up, I’m going to quote the indefatigable (and much smarter than me) Simon Willison and his agent definition:
An LLM agent runs tools in a loop to achieve a goal.
Let’s break down the key parts of that definition:
By contrast, an agent isn’t a flowchart, a script, or a chatbot. Those have their uses, but they’re not “AI agents.” This distinction matters. Marketing teams have flooded the term “agent” to keep their companies relevant. It can mean anything from low-code automation tools to chatbots helping you reset your bank password to a back office reasoning system. The vocabulary’s been muddied and the nuance lost. So let’s reset.
Workflows are structured automation: visualized as flowcharts or node graphs. They shine when the path is known: if X, then Y, else Z. Lovely.
Zapier, n8n, Pipedream, Lindy, and now OpenAI’s Agent Builder all live in this space. They’re smarter than yesterday’s low-code builders for sure. You can sprinkle in some LLM logic for if/else branching and content generation and MCP for faster tool integration, but at the end of the day, low-code flowcharts really haven’t changed all that much in a decade. Useful but static.
Now to be clear, they have their place. Workflows are fantastic for repeatable tasks and empowering technical and nontechnical folks also. (They’re also a nightmare to maintain, hard to test, opaque to debug, and terrible for observability. But that’s a rant for another day. I built Twilio Studio, one of the highest-throughput workflow engines ever, so yes, I’ve earned my scars here.)
The key difference: Workflows can’t handle ambiguity, plan dynamically, adjust on the fly, or iteratively reason toward a goal. A workflow doesn’t loop and work until it’s done. It reacts to a trigger and runs a predetermined path or paths. In other words: it’s not a @#$% agent!
This is a trickier knot to unravel but just as important. A chatbot is interactive, not agentic. It responds. Sometimes it calls a backend tool to help, but it’s still reactive. This is made trickier by the fact that businesses all tend to pull from the same 1990s-era lexicon when thinking about their employees (virtual or human). Our agents are standing by. Please hold for the next available agent.
“Customer service agent” is a linguistic accident, not an architectural truth.
When most people say “agent” in 2025, they’re usually talking about a chatbot.
Some hybrids exist—chatbots that quietly run agentic loops behind the scenes—but most are still turn-based conversation engines, not autonomous actors.
OpenAI’s Agent Kit is an impressive evolution of the workflow model. It lets developers connect actions, tools, and triggers — effectively building intelligent pipelines. For known, bounded processes, it’s great. For emergent, messy, undefined ones (you know, like most of work), not so much
The confusion is compounded by ChatKit, which powers interactive experiences on top of those workflows. A “chat agent” might use a workflow built with AgentKit, but it’s not agentic in the sense of using tools in a loop towards a goal..
That’s not a flaw nor criticism on its face. It’s a design choice and a different product. OpenAI’s system is built for more determinism and upfront clarity, not autonomy, intuition, or the ability to handle novel inputs and interactions.
Anthropic’s Claude Code and its companion Agent SDK are much closer to true agentic behavior. They’re programmable reasoning environments, not flowcharts. Agents here can think for extended periods, use multiple tools, and pursue loosely defined goals.
This aligns far better with Willison’s definition: an LLM agent running tools in a loop to achieve a goal.
Claude Code, optimized for software development, becomes formidable when paired with command-line tools and MCP integrations to GitHub or Linear. It can absolutely be used beyond software—but let’s be real, the current UX (a terminal interface) still screams “muggles beware.”
Now imagine building on that agentic foundation but grounding it in identity, collaboration, and organizational context.
A Teammate isn’t a workflow or a chat proxy. It’s a persistent, digital colleague with memory, preferences, authorization, personality, and responsibilities. It represents a role on your team. It has access to the right systems, follows the right runbooks, and speaks in the right tone of voice.
Each Teammate operates autonomously and socially: it can work alone or with humans (or other Teammates!) in real time. Multiple agents can coordinate within the same workspace (e.g. Slack), not as parallel threads, but as colleagues in a shared environment. This is huge. I’d wager that every chat or workflow you’ve used to date is “single player”. There is no team collaboration with a flowchart. You’re not in Claude Code command line with your friends. There’s a world of difference between @-messaging a Slack bot vs popping into #sales and saying “Hey Ramona, can you get the sales numbers and DM them to Kenny”.
That’s the leap. Everyone else is building tools for a single agent. We’re building collaborative teams.
If you’ve spent any time looking at Teammates, the first thing that pops out is that they’re fun.
They have professional work headshots and funny names and quirky personalities. They have their own company email address and login to issue tracking and Slack @username.
But this isn’t just branding (👋 Devin, Ava, Harvey). Identity is a core feature! It’s the container for context, authorization, and accountability.
You don’t need to tell a Marketing Teammate to emphasize customer value props. It already knows!
You don’t need to remind a Security Teammate of your company’s infosec policies. It’s baked in!
You don’t need to worry that a Sales Teammate will access critical engineering systems. They can’t!
Identity enforces permissions and creates auditability: “Stacey updated the Salesforce record.” It defines who can assign work, what approvals are required, and who can provide them.
Fitting Teammates into corporate authorization frameworks isn’t just convenience or whimsy - it’s a core breakthrough.
(But also, you have to admit, their new work headshots are lit)
Connecting to third-party systems is table stakes. Operating them competently is not.
Most “tool use” today is painfully naive. Agents fire a REST call and hope the schema fits. They search MCP for available functions and pray they pick the right one.
Teammates don’t guess—they know how software behaves.
They understand that GitHub pull requests and issues share the same object model.
They inspect and understand a spreadsheet’s content and format before modifying it.
They know how all your CRM’s custom objects relate to each other.
We’ve taught Teammates not just how to call APIs, but how to use popular software product just like a real human colleague would.
By now, the distinction should be clear. Teammates aren’t “another agent platform.” They’re something categorically different. Yes, they fit the agent definition—they run tools in a loop to achieve goals. But that’s just the price of admission.
What defines Teammates are all the layers above: identity, autonomy, memory, personality, process, collaboration, and even humor.
OpenAI is building the “Windows of AI”: AI infrastructure for everyone.
Anthropic is building the best enterprise-grade reasoning systems on the planet.
But neither has cracked the social architecture of work; the space where autonomy meets coordination, where reasoning meets role, where intuition meets responsibility.
I like that term: “the social architecture of work”. I think that’s the gap we’re closing. Teammates is where intelligence meets structure, where autonomy becomes alignment, where individual insight turns into collective progress.
For decades, we’ve trained people to adapt to software. Now we’re training software to adapt to people. To follow process, respect context, collaborate across functions, and move work forward with intention.
This isn’t about replacing humans. It’s about creating systems that understand that teams actually operate with trust, accountability, and a shared sense of purpose.
That’s what Teammates represents: It’s not another agent, not another automation. This is the moment software grows up and learns how to work alongside us.
