The login problem changed shape
For two decades, software assumed a human would log in to use an application. Then AI agents started invoking business apps and APIs on behalf of users — or entirely on their own — and the identity systems underneath did not know what to do with them. An agent is not a person with a password, and it is not a bot to be blocked either. It is something new: a non-human user that needs to prove who it is, what it is allowed to do, and on whose behalf it is acting.
Satya Devarakonda and Ravi Madabhushi saw that shift coming earlier than most, because they had lived through the previous version of the problem. At Freshworks, they scaled authentication for 50,000 businesses. They watched what happens when identity infrastructure is treated as an afterthought: brittle, ad hoc solutions, shared credentials doing far more than any one person should, and no clean answer when someone asks who did what. Their conclusion, stated plainly at Scalekit's launch, was that business apps now need to let authenticated agents in — and decide exactly what data they can read or write.
A $5.5M seed for agent identity
On 16 September 2025, Scalekit launched an authentication stack purpose-built for agentic apps and announced a $5.5 million seed round led by Together Fund and Z47, with angel backing from Adam Frankl, Oliver Jay, Jagadeesh Kunda and others. The pitch was deliberately narrow: verify every agent's identity and enforce precise, least-privilege access through a single drop-in toolkit.
The timing argument came with a number to back it. Gartner predicted that by 2028, a quarter of enterprise breaches would be traced to compromised AI agents. Whether or not that forecast lands exactly, the direction was hard to argue with: agents were already generating short-lived sessions and touching hundreds of applications across a stack, in places where conventional identity systems — built around human directories and long-lived sessions — were ineffective. Girish Mathrubootham, founding partner at Together Fund, framed the bet as infrastructure for the next billion agent identities.
Scalekit's stack secured both sides of agentic flows: incoming authentication for MCP servers, and outgoing agent actions to third-party tools. Early teams using it as their auth service included Fello, Sifthub, Napkin, Unstract, Hubbl and Aerchain — AI-native applications and SaaS apps adding agentic features, where the question of who an agent is could no longer be deferred.
From who the agent is to what it can do
Identity was the first half of the problem. The second half is capability: once an agent is authenticated, how does it actually do useful work across the apps a team already uses, without a developer hand-wiring every integration and every permission? That is the gap AgentKit, launched on Product Hunt in November 2026, is built to close.
AgentKit gives agents 30,000-plus tools across more than 600 apps — from Salesforce to GitHub — through one MCP gateway. Instead of building and maintaining each integration, a developer connects once and hands agents a gateway. The crucial part is that the gateway inherits Scalekit's identity thinking: AgentKit handles auth and integrations so that every action runs as the user who asked, within the scopes they granted. An agent does not act with a god-mode API key. It acts as a specific user, with specific permissions, and the call is logged.
Virtual MCP Servers are the mechanism that makes least privilege practical rather than theoretical. Each agent gets only the tools its job needs. A support agent gets the ticketing tools; a sales agent gets the CRM tools; neither gets the other's. Internal APIs can be added as custom connectors, so the gateway covers the systems a company built itself as well as the SaaS apps it rents. And Triggers start an agent the moment an email lands, so agents can be event-driven rather than only chat-driven.
Built for developers taking agents to production
The phrase Scalekit keeps returning to is production. A demo agent can share one API key and nobody will notice. A production agent cannot: it touches real customer data, real money systems and real inboxes, and when it makes a mistake, someone needs to reconstruct exactly what happened. AgentKit's answer is that every call is logged and attributed — to the agent, to the user it acted for, and to the scope it held at the time.
That discipline is also the through-line from the founders' Freshworks years. Scaling auth for 50,000 businesses taught them that identity infrastructure is invisible until it fails, and that the failure modes are always the same: over-broad permissions, untraceable actions, and credentials that outlive their purpose. AgentKit applies the same lessons to a world where the user is code. Short-lived, scoped tokens instead of permanent keys. Per-user OAuth instead of shared secrets. Audit logs instead of guesswork.
AgentKit is free to start with 10,000 tool calls a month, which fits the way developers actually adopt infrastructure: try it on a real agent, watch the logs, and only pay when the agent earns its place in production. The story of Scalekit so far is not a growth chart. It is a sequence of two bets, both about the same idea: first, that agents would need identities; second, that once they had them, they would need a governed way to act. AgentKit is the second bet, shipped.
The playbook
- Treat agents as users, not scripts — If an agent acts on someone's behalf, it needs an identity, a scope and an audit trail — the same machinery humans get, rebuilt for code that lives outside user directories.
- Make the permission the product — Virtual MCP Servers give each agent only the tools its job needs, so a compromised or confused agent cannot reach everything the user can.
- Log every call — Attribution is what turns a demo into production infrastructure: when something goes wrong, you can see exactly which agent did what, as whom.