Preloop
The MCP Governance Layer
107 followers
The MCP Governance Layer
107 followers
AI agents are powerful, but one wrong action could be catastrophic. Preloop is an agentic automation platform with built-in human approval layer. AI agents automate routine work across your systems, and when they attempt risky actions (deployments, refunds, data changes), Preloop intercepts and routes them for approval via mobile, Slack, or Teams before execution. You can use Preloop for automation only, approval gates only, or both together depending on your needs.
Preloop
Hey Product Hunt!
I'm Yannis, co-founder of Preloop.
We built Preloop because we kept seeing the same problem: AI agents are incredibly powerful at automating work, but they can't take legal or moral responsibility for their actions.
The core insight: When your AI agent is about to deploy code, process a refund, or modify customer data, someone needs to approve it. Not after the fact - before execution.
What makes Preloop different:
- Built on MCP protocol from day one (no adapters needed)
- Approve critical actions from your phone, Slack, or Teams
- Use it for automation only, approval gates only, or both together
- Works as an MCP proxy alongside your existing tools
Question for the community: What is the one agentic automation that you would love to have but are afraid of launching due to lack of oversight or potential consequences?
Former co-founder of @d1_mo here!
Congratulations on the launch!
The manual approval flow makes total sense for getting started, but knowing you, you're probably already thinking about scale.
Do you have plans to introduce automated AI approvals for teams that have too much volume for manual review? E.g. Having a smaller model audit the agent's requests?
Preloop
@cpsaltis Spot on! We believe the future is 'AI-supervised AI.' We are working on a feature where you can use a model with appropriate context to score the risk of a request, and only escalate to a human if the score is > 80/100.
Swytchcode
This is really amazing. So how can we integrate this with our custom MCP apps?
Preloop
@chilarai Thanks! Preloop works as an MCP proxy sits between your client and MCP server, no code changes needed.
Point your MCP client at Preloop → we handle approvals → forward to your server.
Try the free trial and let me know if you hit any issues!
Product Hunt
Preloop
@curiouskitty Thanks for the thoughtful questions! These are exactly the adoption mechanics we spent the most time refining.
1. Smallest Integration (Value in minutes, not days): Since Preloop acts as an MCP Proxy, the "smallest integration" is literally changing the connection string in your claude_desktop_config.json or Cursor settings.
You don't need to rewrite your agent code or servers. You just point the Client to Preloop, and Preloop forwards to your existing Server. You get immediate value (centralized visibility + basic gates) instantly.
2. Common Organizational Hurdles:
Ownership of Approvals: This is the biggest friction point. We usually see teams start with "Self-Approval" (the dev approves their own agent's actions) just to prevent accidents. Once comfort grows, they create policies that route high-risk actions (e.g., "Payments > $50") to a specific manager or lead.
Security & Compliance: A major requirement we see is Forensics. Teams need to know exactly what an agent tried to do. We store the request payloads in a detailed Audit Log, giving security teams a complete "black box" recording of every agent action for compliance reviews.
On-Call Impact: We avoid the "bottleneck" problem by supporting routing to entire teams or to Slack channels. This ensures that an approval request is seen by the whole squad, rather than pinging a single person who might be asleep or offline.
Happy to dive deeper into your specific stack if you want to ping me on Twitter/X!
Preloop as an MCP proxy for approval gates makes sense... agents with tool access need human checkpoints. The mobile and watch notifications are clever for async approval. Curious how you handle request state TTL when someone takes a few minutes to approve from their phone.
Preloop
@piroune_balachandran
This is the million-dollar question in human-in-the-loop systems. You hit on the core architectural tension: Machine Timeout vs. Human Latency.
To answer your question on Request State & TTL:
The "Hold" Strategy: When an agent triggers a gated tool, Preloop intercepts the request and effectively "pauses" the HTTP/JSON-RPC response. We keep the connection open while pushing the notification to your phone.
The Timeout Reality: You are spot on. If the Client (e.g. Claude Desktop) has a hard 60s timeout, it will hang up even if we are still holding the connection.
The Practical Fix (Today): We advise users to bump the timeout config in their agent (e.g., timeout: 600s in claude_desktop_config.json) to accommodate human reaction time.
The Protocol Fix (Future): We are betting on the notifications/progress feature in the MCP spec. The spec suggests clients should reset their timeout clock if they receive a progress event. Preloop emits these "heartbeats" (e.g., "Waiting for approval..."), and as clients like Cursor and Claude mature to respect them, the timeout issue will vanish without code changes.
Reducing Human Latency: Since we can't always control the client, we focus on speeding up the human. This is why we built Team Routing (sending the approval to an entire team or to a Slack channel instead of just one person) and Escalation Policies.
Great catch on the async nuance. It's the hardest part of retrofitting governance onto synchronous protocols!
Congratulations on the launch! Interesting idea — it will be useful in financial AI applications and beyond.
Preloop
Hey Product Hunt,
Hunter & CTO here! Super excited to share Preloop with you all today.
While Yannis touched on the "Responsibility Gap," I wanted to share a bit about the technical architecture choice we made.
When building this, we had a choice: Build an SDK (that you have to import into your code) or build a Proxy.
We chose the MCP Proxy approach because:
Zero Code Changes: You shouldn't have to rewrite your agent just to make it safe. You just change the connection string.
Runtime Agnostic: It works whether you are using Claude Desktop, Cursor, or your own Python/LangChain scripts.
State Management: We capture and hold the tool call request state. This allows for "human-speed" approvals (via mobile/watch) without losing the context of what the agent was trying to do.
I'm hanging out in the comments all day. Hit me with your hardest technical questions about our MCP implementation or the approval flow!