We Built Latch for Ourselves. Now It's Yours.

We Built Latch for Ourselves. Now It's Yours.

We found ourselves handing AI agents raw API keys and hoping for the best. So we built the infrastructure that let us delegate authority to agents with confidence instead of compromises.

At Subzero Labs we are focused on building the infrastructure for neofinance, which is why we're excited to be launching Latch, the solution to give your agents real authority.

As AI agents start moving money and executing financial decisions in real time, systems that treat compliance as an afterthought won't keep up. Neofinance is the next generation of financial infrastructure that enables more complete and inclusive access to the elements of finance that matter. It's a paradigm in which the rules, logic, and execution of financial activity are embedded directly into the systems that carry them out, making compliance and automation inseparable from infrastructure rather than layered on top of it.

Latch today is built for individual developers, with enterprise solutions on the roadmap. Before we show you how to give your first agent real agency in under 10 minutes, it's worth understanding why the agentic ecosystem needs proper delegation in the first place.

The Problem: Agentic Workforces Are Outrunning Their Oversight

AI infrastructure budgets are set to triple this year. Enterprises are seeing 2–4× productivity lifts from agents in real workflows, and companies are cutting headcount to fund machine labor. Robinhood recently launched agentic trading and a credit card built specifically for AI agents. Spending caps and controls need to be an essential part of these products and services.

The agentic economy is here, and the infrastructure to govern it needs to be too.

Fast deployment without governance isn't progress. Uber burned its entire 2026 AI budget in four months without being able to show the ROI. The GitHub breach showed what one unscoped credential can do at scale. Microsoft is wary of agents without proper governance. The pattern holds across organizations of every size: capability arrives first, and the infrastructure to govern it gets built, if it gets built at all, only after something goes wrong.

The deeper issue isn't only API keys, it's identity. Most teams hand an agent the same broad, standing access they'd give a trusted employee, then hope nothing goes wrong. There's rarely a clear answer to basic questions like: What can this agent actually touch? What happens when the task ends? Who can prove what it did?

We felt this firsthand at Subzero Labs. We were deploying agents across our own infrastructure and running into the same problem every time: APIs with unbounded access, spend with no ceiling, and no good way to cut things off when a job ended. We patched it a few times. Then we built it properly, because our mission has always been the same: give teams the infrastructure to build for neofinance. That means in a world that wants to deploy AI agents, they need to be able to do so with confidence, not compromises.

The next challenge is security. All of the world's systems are designed to operate securely via software; but what happens when software can no longer be trusted? Poisoning of software code to create illegal access is now becoming mainstream. Over 450,000 malicious open-source packages were identified in 2025 across public registries, and a single supply chain attack on GitHub Action workflows pushed malware to over 5,500 GitHub repositories. The downstream implications of this are staggering, and the only truly secure method to ensure trust is at the hardware layer. For this reason, we built Latch with a machine-bound identity foundation.

We found that this isn't just a big-company problem; unexpected AI spend can even sink a startup before it ever gets off the ground. That's why we built Latch for both ends of that spectrum: enterprises and financial service providers scaling agent deployment, and individual developers standing up their first agents.

Introducing Latch: Delegate to Agents With Confidence

Latch is an AI workflow tool that provides governance and access control for agents. Define what an agent can do, set a spend ceiling, bind it to the hardware it runs on, and get a verifiable log of everything it has touched. When the task ends, access expires.

Latch is being built with configurable security modes, so you can match the level of control to the sensitivity of the work:

• Standard trust model for teams getting started with scoped agent access. Fast to deploy, fully auditable, with all the core controls in place from day one.
• Full trusted execution environments (TEEs) for organizations that require hardware-level security guarantees. Even Latch can't see your keys or tamper with your policy, plus you get cryptographic proof that policy was executed exactly as configured.
• Distributed key management for teams that need to eliminate single points of failure entirely. Keys are split across independent parties, so no single party ever holds the complete credential.
• Machine-bound identity to tie access of critical data and accounts to the specific hardware fingerprint of the device it's authorized on, so even an extracted token won't authenticate from anywhere else.

Standard trust and TEEs both ladder up to the same goal: an enterprise-grade security posture you can put in front of a regulator, an auditor, or a board.

*Editor's note: some features may not be available at launch, and updates can be found by subscribing to our newsletter here.

The Opportunity for High-Impact Users: Built for Neofinance

Currently, Latch is available for all individual developers to try for free. However, any team deploying agents at scale needs this kind of governance.

Latch's current design roadmap is focused on institutions where the cost of getting it wrong is highest: financial services companies, fintechs, and the broader ecosystem of teams building what we call neofinance.

For these teams, "move fast" and "stay compliant" have historically been in tension. Agentic governance is what lets both be true at once: a spend ceiling that can't be argued with, an audit trail a regulator can actually trust, and a credential that expires the moment a task is done instead of sitting around as a standing liability.

That's also why Latch is being built to scale with how an organization actually operates.

• Individual teams and builders can self-serve: sign up, scope a policy, and connect an agent in minutes.

• Organizations and large-scale outfits with more complex compliance and infrastructure needs can reach out to our team directly to map policy to their existing controls and integrate Latch into the systems they already run.

Subzero Labs is building the smart layers for neofinance. Latch is the agent infrastructure built to meet the rise in demand.

Getting Started: Your First Latch in Under 10 Minutes

Step 1

Start from the Latch dashboard. Click + New latch in the top right to begin setting up your agent's access policy.

Step 2

Name your latch, set the Upstream Base URL, and attach the appropriate credential under the Credentials section. Optionally, you can use the AI Builder to describe your policy parameters.

Step 3

Configure your policy pipeline. Add filters like endpoint allowlists, content rules to block unwanted actions, and a rate limit (e.g. 10 req / 60s) to keep your agent in check.

Step 4

Review the full policy summary before going live. Latch shows a simulated view of all 4 filters and lets you run test scenarios to confirm allow/deny behavior before activating.

Step 5

Activate the latch and connect your agent. Latch waits for your agent of choice (e.g. Claude Code) to connect via the proxy. Once it does, your agent will now abide by the governance created by Latch.

Bonus Step

Now that you've created your first latch, you can go to Simulate to fire a request and watch the pipeline evaluate. Each filter will light up in sequence; deny short-circuits and tells you exactly which rule rejected the action.

Create your first latch here.