Karan Vaidya, founder of Composio: MCP use cases & Elon retweets
Karan Vaidya on how Composio went from almost no users to 100,000 in six months by racing every model launch with a working example, why their pricing page reads "totally free, ridiculously cheap, serious business," and how they're teaching agents not to repeat each other's mistakes.
Karan Vaidya is the founder of Composio, an integration layer — or "skills" — for AI agents, connecting tools like Slack, Notion, and Gmail. He shares what people are actually using MCP for, the future of function calling, and what an Elon Musk retweet actually does for signups.
We get into how Composio rode MCP, agent frameworks, and every major model launch to explosive growth, why developers hate being sold to, and how they're building a "skill layer" so one agent's mistake becomes every future agent's lesson.
The Q&A below is experimental — extracted from the episode transcript with AI. If you spot a mistake, let us know at jack@scalingdevtools.com.
You've gone from barely any users to 100,000 in about six months. What's that actually looked like?
We're building the integration layer, or skills, for AI agents — connecting things like Slack and Gmail via MCP or direct function calling. The biggest lever for growth was MCP: we launched our MCP product in March, and early on people were using Cursor with Supabase, Gmail, Slack, and so on to automate a big part of their day-to-day workflow — pulling a DB schema while writing code, or writing an engineering doc straight into Notion from inside Cursor. That was the unlock: people had been waiting to do that inside their IDE. The launch post itself got over a million views, and from what I remember it was one of the instigating moments of the whole MCP hysteria that followed.
How did an Elon Musk retweet actually translate into signups?
When Grok 3 launched, we made an example with it that Elon retweeted, which got around 2 million views; more recently, when Grok 4 launched, we shipped a Grok CLI — use Grok on your terminal the way you'd use Claude Code — which got about 500k views, got shared internally at xAI, and picked up 700 to 800 GitHub stars in two days. I still get queries about that Grok CLI example from people using it day to day. There was a real spike in signups from the Elon retweet — I'd guess at least a 100% jump that day — though it's genuinely hard to say how many of those were good users versus just eyeballs.
Is jumping on these launch moments a deliberate strategy, and do you have any patterns for how you actually post about one?
It's not really "drop everything" — you carve out extra hours, sometimes from sleep or personal time, because those moments are rare and you have to capture them when they come. But honestly it doesn't feel like a strategy so much as just liking to explore whenever something new comes out — me, my cofounder, and the team all enjoy doing that anyway, so it doesn't feel like extra work, it's more we're doing this regardless, why not share what we find. It's genuinely hard to build a deliberate strategy around this if you don't actually enjoy exploring new releases — if you do, it's basically a hack: post around it and you'll get some momentum. Tactically, I usually start by reading what other people are posting first, since there are always people faster than me who get access earlier. That builds a mental model — okay, this thing is better in this direction, maybe coding, maybe reasoning, maybe video generation — and from there I get a sense of which direction is worth building an example around.
How did the actual go-to-market journey unfold before the viral MCP moment?
We started building the current version of Composio around February 2024. We were cautious early on because we're providing the authentication and tooling layer for agents — a critical piece of infrastructure — and if something goes wrong once, users form a perception that's hard to undo, so we were always somewhat slow, balancing quality against speed. We noticed a lot of people building on frameworks like LangChain, LlamaIndex, and CrewAI, joined their Discord communities, and realized one of the biggest bottlenecks for people building agents was good-quality tools — connecting an LLM to tools requires authentication and converting API schemas into function calls that are actually LLM-friendly. We posted in those communities, got early adopters, and built native integration packages for every agentic framework — install composio-langchain and we handle all the tool formatting for you, same for LlamaIndex, CrewAI. Those frameworks already had large, hungry communities, and when we posted examples the response was strong enough that Harrison from LangChain, Jerry from LlamaIndex, and Joao from CrewAI reposted them, which brought real momentum.
Your blogs and Reddit posts drove a lot of views too — what worked there?
Our blogs went viral around release notes and comparisons whenever something new launched — people are hungry for that kind of content, and it does well on both SEO and Reddit. Early on, around January and February, we were getting a million-plus views a month across Reddit and Twitter individually. On Reddit specifically, what works is a detailed story of what someone actually did and how it affected their work — a user, not us as a company, saying "I used Composio and it saved me a ton of time" or "I built this thing I wouldn't have been able to otherwise." Mostly text content, with the graphics living in the linked blog post rather than the Reddit post itself.
Your pricing page copy is pretty bold — "totally free, ridiculously cheap, serious business." What's the thinking there?
Right now we're focused on getting the right usage — pricing itself is something we haven't put a lot of thought into. But every bit of white space you have is content, and you should use it wisely. Our audience is developers, and they respond to things that are interesting and a bit funky — a completely standard, serious pricing page, nobody looks at that and thinks "I want to use this company." So we didn't want to waste that space. Serious business, for the record, is $229 a month.
Can you separate the noise from the real use cases in MCP right now?
There are really two audiences. Direct consumers use MCP through a client like Cursor, Claude, or ChatGPT — ChatGPT's MCP support is still limited, mostly deep research. What MCP unlocks is connecting where you're actually chatting with an LLM to your real work — instead of drafting an email in Claude and then copy-pasting it into Gmail, or writing a design doc in Cursor and pasting it into Notion, MCP lets you do it directly. One of our biggest use cases right now is Figma MCP — getting Figma screens as JSON and having Claude Opus convert that almost directly into code, so a lot of users get their first version of a Figma design turned into code through it. Supabase is another heavily used one, for data analysis and even schema changes. As models keep improving — going from getting something 90% right today toward 99% — people will want to stay as close as possible to wherever the model lives, and everything else routes in through MCP. On the builder side, people building their own agents with MCP, it's more mixed: the advantage is you build one client and connect to the whole corpus of MCP servers — we have around 550 toolkits — but a lot of builders want to customize the function schema the LLM sees, or control the exact request and response shape, which MCP as a protocol isn't really optimized for. One of Anthropic's own MCP creators has said the protocol is designed to make servers easy to build, on the assumption most people will build servers rather than clients, and there'll only be a handful of clients like ChatGPT, Cursor, and Claude — so client-side developer experience isn't the focus. That's part of why a lot of our own users still prefer direct function calling over MCP, for the better developer experience and full customization.
With 550-plus tools and growing fast, how do you actually design an agentic loop without blowing up the model's context?
Most agentic loops, because models have improved so much, are converging on something close to a basic react-style for-loop — the real skill is how well you summarize the tool-call responses back to the agent so it can react well. We have around 550 tools and roughly 20,000 individual actions and growing fast — we added 140 apps in the last two to three weeks alone — so you can't hand all of that to the model at once, it will just blow up; even with a huge context window, attention is sparse, so giving everything doesn't mean it performs well. Internally we build what we call a dependency graph: for a task like "summarize my Slack messages and put them in Notion," you don't hand over every Slack tool and every Notion tool at once — you pass the Slack-conversation-related tools first, then once that's resolved, pass the tool for selecting the right Notion action, then the email tool if needed. We're leaning into what we call a skill layer — the idea that developers are only as good as their tools, and just like humans build a kind of subconscious pattern memory over time, like knowing what to do when a certain position comes up in chess, we want Composio to develop that same pattern memory for agents: if one agent using Composio makes a mistake, we learn from it, so the next agent using Composio shouldn't make the same mistake.
What are you most excited about next?
It's hard to predict in a world where there's a new release every couple of weeks, but two things are safe bets: latency will keep dropping and tokens per second will keep climbing, even if exactly which direction intelligence itself improves next is harder to call. Given that steady decline in latency and cost, I'm especially excited about voice — people building with MCP in voice contexts, like a third participant on a call who can just be told, right there in conversation, "go summarize the meeting so far and put it in Notion," and comes back having done it while the conversation continues.
What would you tell other DevTools founders, based on the last six months?
Two things. First, developers don't like to be sold to — build something genuinely cool, put it out there openly, write about it, and if it's good, people get excited and want to try it themselves; that's basically how most developer tools I've seen actually work. Second, and this is a longer lesson we're still learning: you have to optimize the very first moment someone tries your product, because if you don't and it goes the other way — "this isn't working" — that's catastrophic, since it's hard to get people to come back once they've formed that impression. Onboarding is something we're constantly correcting as we keep finding new points of friction.
Links & references
This episode is brought to you by WorkOS.