Membrane

Why have an integration roadmap if you can just have them all? Most teams I talk to measure integration velocity in weeks per integration. We just flipped that. Last month we shipped 1,000 API integrations in seven days. 10 concurrent AI agent sessions running around the clock. Here's how it actually worked. If you've built integrations before, you know the drill. Read the docs, figure out auth, build the client, write tests. That's 30 to 60 minutes per integration on a good day. Multiply by a thousand and you're looking at roughly a full engineer-year of work. We didn't want to spend a year. So we built a pipeline. It runs in two phases. Phase one handles auth. Phase two generates the action packages. Both follow the same pattern: fetch eligible apps, spin up concurrent agents, validate outputs against schemas, publish what passes, flag what doesn't for human review. In the auth phase, each agent gets just an app name and a URL. That's it. From there it searches for API docs, figures out the auth method (OAuth2, API keys, Basic auth), configures everything including token endpoints and credentials, builds the client, writes tests, and actually hits the API to confirm it works. About 2.5 minutes per app. With 10 agents running in parallel, that's roughly 10 validated connectors every 2.5 minutes. We started with 10 agents as a conservative choice, not a technical ceiling. Once auth exists, phase two kicks in. Agents generate the most common API actions, covering about 80% of what people actually use. For the long tail, users can build their own through our self-integration capabilities. One thing we got right early: one task per session. Fresh context window every time. No bloat, no confusion. When validation fails, the agent self-corrects in a clean environment. The takeaway isn't really about the number. It's that integration work is extremely parallelizable if you design the right scaffolding around it. Full technical breakdown: https://lnkd.in/eeWxwgzG

One of our engineers, Ivan B., shipped 1,000 API integrations last week. Not over months. In one week, with 10 Membrane Agent sessions running in parallel. Here’s the thing most people miss about integrations: building one is not the hard part. Building many that are production-ready, scalable across thousands of customers, with proper auth, error handling, and guardrails? That takes hours or days. Even with tools like Claude Code, without the right infrastructure you’re still doing most of the work yourself. That’s what Membrane Agent + our infrastructure changes. For each app, Membrane Agent finds the API docs, figures out how to authenticate, builds a working connector, tests it against the real API, and publishes it. About 2.5 minutes per app. No human involved. What we learned along the way: ➡️ Giving Membrane Agent all the context upfront works better than letting it figure things out on the fly. At this scale, consistency matters more than flexibility. ➡️ Adding a validation step that lets Membrane Agent correct its own mistakes turned a 60% success rate into something we could run unsupervised. ➡️ APIs in the wild are chaos. Some have great docs. Some have a PDF from 2019. Membrane Agent handles it surprisingly well. Is it perfect? Not yet. Some apps still need manual review. But the pattern works, and it gets better every time we run it. Full writeup: https://lnkd.in/eSnXAK4H

Every AI product (even ChatGPT or Claude) hits the same wall. Your agent is brilliant at reasoning. It can plan, analyze, decide.                                                                                                                         But the moment it needs to actually DO something in another app: create a task in your Linear, update a record in your CRM, send a Slack message, you're back to building integrations the old way..configuring custom MCP servers yourself, definition tools etc.                                                                                                                                                                                   At Membrane we’re pioneering a new capability: self-integration for software. Add a version of Membrane Agent inside of your product and it can integrate any app, on the fly. Describe what you want in plain English. The agent figures out the API, handles auth, maps the fields, and executes.  Any API. No connectors to configure. No waiting for us or you to "add support."                     We're building with a small founding cohort right now, teams from Dialpad, PandaDoc & many others who believe integrations should disappear into intent. The first deployments are happening right now and I’m very excited to see how this technology can spread out in the AI world and circles.                                                                                                                  If you're building an AI product and see possibilities, DM me or feel free to apply                                                                                                Link in comments.

🟡 Today, Membrane Core in enabled as part of our new offering 🟡 A pay-as-you-go tier that gives developers full access to the core Membrane platform capabilities with no credit card, no time limits & no restrictions on which APIs you can connect to. What's included: - Unlimited integrations with any API - Membrane Agent to build integrations for you - Ability to create & run Actions (simple operations) - 20,000 action runs per month - 20 free AI credits per month - Built-in monitoring and observability - AI and community support This isn't a timed trial or a feature-gated demo. It's a fully functional part of our platform designed to take you from idea to production. Whether you're vibe-coding a side-project, shipping your first startup, or adding integrations to your first AI agent you can start today. Links in comments to find out more 👇

We don’t need more integrations or better integrations. We need software that integrates itself. I believe this is inevitable and will become a standard in a few years. Think about that for a second. Your AI agent can understand a customer's question in any language, interpret intent from vague requests, and respond with nuanced, contextual answers. No engineer coded every possible scenario. It just... figured it out. But ask that same brilliant agent to sync a contact to Salesforce? Suddenly it needs a human translator. An engineer has to wire up Claude Code, create the integration, work to define the data mappings, handle authentication, manage webhooks, and maintain the whole thing as APIs inevitably change. The integration market's answer to this problem has been: more connectors. Better connectors. Connector marketplaces. Unified APIs that normalize everything into the same schema. None of it works. Not really. Pre-built connectors can't cover the long tail. There are thousands of SaaS apps, each with unique APIs, each constantly changing. No library will ever be complete, and the moment it's published, it starts getting stale. Unified APIs sacrifice depth for breadth. They give you the lowest common denominator across apps, which means you lose the custom fields, advanced features, and per-customer variants that make integrations actually useful. And building everything in-house? That's just trading one problem for another. Now you have a team of engineers maintaining integration plumbing instead of building your product. That’s why at Membrane we are already working on self-integration. Self-integration doesn't replace your existing integrations, it augments them. When a user asks your agent to do something with an external app, it first checks your existing integrations and tools. If something's already built, it uses it. No reinventing the wheel. But if there's no integration? Instead of failing or waiting for an engineer, your agent collaborates with a specialized integration-building agent to create the connector it needs..dynamically, in real-time. The new integration is then used exactly like any pre-built tool to fulfill the user's request. From the end-user's perspective, it just works. They don't know or care whether the integration existed before or was created on the fly. That's the magic: infinite coverage without infinite engineering. What do you guys think? If that resonates with you, read more about our take here: https://lnkd.in/e8bDBKmx

🚀 We are looking for a new Growth Lead to join our GTM lead 🚀

Integrations are still treated like projects. Built once, maintained forever, and breaking every time an API changes. That approach doesn’t scale. Integrations aren’t a phase in development, they’re a continuous capability your product needs to own. We’ve all tried to crack things with various general-purpose coding agents like Cursor or Claude but the reality is besides accuracy being off and unreliable code, you need to AI to have the right context about APIs and infrastructure to operate in a safe environment. That’s where the Membrane Agent comes in. - Research Membrane agent reads API docs, understands authentication, schemas, and how APIs actually behave in production. - Development It builds operations, data models, and integration logic using the same APIs developers use. No shortcuts. - Testing & QA The agent runs tests, validates edge cases, and keeps integrations production-ready as things change. - Support When issues or questions come up, the agent is already there, debugging, explaining, and adapting in real time. Membrane turns integrations from one-off work into a built-in capability. One agent. The entire integration lifecycle.

Integrations shouldn’t be features locked in someone else’s platform. They should be code, living, versioned, and owned by you. That’s what Membrane Packages make possible. Most integration platforms give you configuration UIs and prebuilt connectors. When APIs change or vendors sunset, your integrations break, and there’s nothing you can do. You don’t own the code. You don’t control the logic. You’re renting connectivity. With Membrane, integrations become part of your product’s DNA. - The Membrane Agent reads API docs, understands your use case, and builds integration logic automatically. - The Membrane Engine runs that logic reliably, managing authentication, flows, retries, and observability. And what you deploy isn’t a config, it’s a Package. Each Package bundles YAML + JS code that connects your product with external apps, combining Engine elements like: Actions, Flows, Data Collections, and Events. You can build Packages for any use case: - Single-app Package - one connector (e.g. get Slack messages into your product) - Multi-app Package - unified logic across multiple apps (e.g. sync messages from all comms tools) - Custom Package - build for any new app with an API (e.g. import contacts from a new CRM) These are real, portable integration blocks, versioned, inspectable, and fully owned by you. Run them anywhere: your repo, your cloud, or on-prem. Find out more about Membrane’s Packages here: https://lnkd.in/ep4xA8ay