Puente OS vs Make: Comparison and When to Use Each

A visual automation platform is a tool for building flows that connect applications and run steps on their own, drawn on screen: a trigger, such as a webhook or a schedule, and a chain of modules that read, transform and write data in other apps. Puente OS is the platform that builds the systems that run your business: apps, workflows, databases and agents that read from your systems, cross-reference the information none of them holds in full, decide on your rules and execute the action inside them. Automation is one of those four pieces, and the other three complete the process.

I'm Cris Ugarte, CEO and co-founder of Puente OS. We work with retail, eCommerce and logistics companies in Chile, Peru and Mexico, and when we talk about automating processes, Make comes up often, especially in marketing, sales or operations teams that built their first scenarios on their own, outside IT. The next question is direct: how is Puente different?

My answer is that Puente delivers the system that runs your process, up and running and with someone accountable for it. A scenario moves data between your apps, and around it the process needs a design, a screen for your team, business data, integrations with local systems and someone to keep it running. Here I go through what each one does, with public sources for everything I say about Make, and when each one makes sense. If you've read Puente OS vs n8n, this is the same category seen from a different audience: n8n speaks to technical teams, and Make speaks to business teams.

What is Make and what does it solve?

Make is a visual AI automation platform. It started as Integromat, which Celonis acquired on October 14, 2020, and on February 22, 2022 it was renamed Make, according to its press page. Today it is part of Celonis, the process mining company, according to its About page. Its home page presents it with the headline "The visual AI automation platform" and the promise to connect any app, data source or AI model, and build automations and AI agents visually, in code or with a prompt.

Its audience is business teams. The home page speaks to IT, Operations, Marketing, Sales, Finance, Customer Experience and People teams, and in its comparison with n8n Make describes itself as "visual-first", a platform that lets teams of all kinds use AI automation without developer support.

What it offers, according to its website and its help center:

Scenarios on a canvas. Each automation is a scenario: modules connected on screen, started by a webhook, an app's instant trigger or a schedule, according to its webhooks documentation. The Router splits the flow into several branches, each with its own filter and a fallback route for whatever matches none of them, and the Iterator turns a list into items processed one by one.
Code when you need it. The Make Code app runs JavaScript or Python inside the scenario, in an isolated sandbox.
Integrations. Its home page mentions over 3,000 pre-built apps, and its directory listed 3,620 as of October 11, 2026, across verified and community apps. For anything missing, the same directory offers the HTTP app, which connects to any service with an API.
Error handling. Five error handlers per module: Skip, Retry, Resume, Commit and Rollback. With incomplete executions turned on, a failed execution is stored so it can be retried, automatically or by hand.
AI agents. Make AI Agents are built on the same canvas, with a panel that shows the reasoning step by step. According to its help center, the new version is in open beta, and each agent combines a model, instructions, knowledge files and tools: modules, scenarios, MCP server tools and other agents.
Maia. Maia by Make, in public beta, creates scenarios and agents from what you write, modifies existing ones and helps fix errors using the run history.
MCP. The Make MCP server lets assistants like Claude or ChatGPT run your scenarios as tools and, with management permissions, view and modify scenarios, connections, webhooks and data stores.
Data and map. Data stores are Make's built-in database tool, to keep data between scenarios. Make Grid automatically draws a map of how your scenarios, apps, data stores and AI components connect, and flags the ones with errors.

According to its home page, over 400,000 organizations in over 200 countries use Make.

A visual canvas with thousands of apps, agents and an assistant that builds scenarios through conversation, so your business teams connect their tools on their own: that is Make's job.

What is Puente OS and what does it solve?

Puente OS is the platform that builds the systems that run your business. Your ERP records what happened. Your BI shows you what happened. Puente makes it happen. In your stack it is the system of action: it reads from your systems, cross-references the information none of them holds in full, decides on your rules and executes the action inside them.

What it builds comes from four pieces:

Workflows with explicit, auditable rules that start on their own when data changes or at a set time.
Databases that bring together context from several systems: the order, its receipt, its shipment and its settlement in a single record.
Apps where your team reviews, decides on and approves the exceptions.
Agents for the steps that take judgment, like an ambiguous complaint or a discrepancy that needs investigating.

With Puente OS you describe in natural language what your operation needs and get software running: apps, workflows, databases and agents. Puente's Growth Ops team builds each process with you and maintains it, and each one reaches production in 2 to 4 weeks. Puente acts on your systems, and where the operation lives in spreadsheets, it also keeps the record.

The discipline behind it is autonomous operations design: designing your operation so the repeatable work runs on its own, on your rules, and your team decides what takes judgment. For a closer look at the layer, see what a system of action is.

What does it take, around a scenario, to run a business?

It takes five more things: the designed process, the screen where your team works, your business database, someone accountable when something fails and integrations with local systems. The scenario moves data between your apps, and those five are what close the process.

Take a typical case for a business team in Chile: reconciling marketplace sales, which someone in finance wants to automate.

The designed process. Before the first module, someone defines what triggers the process, which rules it applies, what its exceptions are and who resolves each one. This is the work that decides whether the scenario is useful, because a scenario built on a poorly mapped process automates the error.
The screen where your team works. Every exception needs a place: finance sees payment discrepancies, operations sees stalled shipments and whoever approves sees the full case before deciding.
Your business database. The order, its receipt, its settlement and its return sit in a single record, with their history. That is where each rule cross-references what no single system holds in full, and where your team measures.
Someone accountable when something fails. An API changes, a report arrives in a different format, a credential expires and the execution stops. Someone has to see it, understand what happened, fix it and get the process running again, including when the person who built the scenario is on vacation or has moved to another team.
Local integrations. Mercado Libre, Bsale, the SII (Chile's tax authority), your invoicing system and your courier, each with its own API, format and calendar.

When those five live in different tools and with different people, coordinating them eats up your team's hours: that is the coordination tax. An autonomous operation meets three conditions: work starts on its own when data changes, your systems talk to each other with no person in the middle, and the system executes the clear cases and brings you what takes judgment. Scenarios contribute to all three, and all three hold when the process also has its database, the screen where your team decides and a team that maintains it. Puente OS delivers all three together, on a single platform.

How do Puente OS and Make compare, dimension by dimension?

Dimension by dimension:

Who builds. Make: people on your business teams, on the canvas, backed by Maia, which builds and adjusts scenarios through conversation, and by the Make Code app for steps that call for JavaScript or Python. Puente OS: the Growth Ops team builds each process with you. You describe in natural language what your operation needs and get software running, and every activation or irreversible change goes through your confirmation.
Who maintains. Make: whoever built the scenario, or the person you assign the right team role. Its team roles range from Team Admin and Team Member, who edit, to Team Operator, who activates, deactivates and schedules scenarios, and Team Monitoring, with read-only access to scenarios and execution logs. Puente OS: the Growth Ops team maintains each process as your operation changes, with a new channel, a new rule or a report that changes format, and responds when something fails.
Process design. Make: the canvas, where the builder draws the flow module by module, and Make Grid, which shows how existing scenarios connect. Puente OS: design is part of the work. Growth Ops maps what triggers each process, what it decides and what its exceptions are, and defines with you what happens to each one: the system resolves it or it reaches the right person with full context.
Apps and interfaces. Make: people work in the apps the scenario connects, like your email, your chat or your spreadsheets, and on Enterprise the Human in the loop app creates a review request with its own link, and the scenario continues when someone approves, adjusts or cancels it. Make AI Agents add manual approvals inside the agent's flow, according to its agents page. Puente OS: web apps tailored to each process, hosted on Puente with their own link, where your team reviews, decides on and approves the exceptions, like a discrepancy dashboard for finance or a stalled-shipments inbox for operations.
Data. Make: data stores, its built-in database to store and manage data across scenarios, and modules to read and write the apps and databases you connect. Puente OS: your business databases, with typed columns validated before saving, queries with filters, grouping and aggregation, and loads of up to 10,000 rows in a single operation. The workflows and apps of the same process read and write them.
Integrations. Make: over 3,000 apps according to its home page and 3,620 in its directory, plus the HTTP app for any API. In its directory, as of October 11, 2026, searches for Mercado Libre, Bsale, Defontana, SII and Falabella return 0 results, with verified and community apps included. A search for "mercado" returns a single app: Notifications for Mercado Pago, verified and maintained by its vendor, which reports accredited payments and authorized or canceled subscriptions. Puente OS: native connectors for Mercado Libre (orders and shipping details), Bsale (stock and documents), Multivende, WhatsApp, Gmail and Google Sheets, among others. The Growth Ops team connects the rest, like the SII, your invoicing system or your ERP, through its API, over HTTP or Python, or by reading the ERP's database.
Error handling and monitoring. Make: five error handlers per module (Skip ignores the error, Retry stores the execution to retry it, Resume sets a substitute value, Commit stops and saves what was processed, Rollback stops and reverts); incomplete executions, off by default, which store the failed execution to be resolved automatically, for the error types that support it, or by hand; and the scenario history, with each run's status, duration and data, the output of each module, a change log and run replay. Make Grid flags scenarios with errors on its map. Puente OS: each execution's detail shows the step where it stopped and, per step, the error, the traceback and the logs; there are failure alerts with an excerpt of the error, and failure policies per step and per iteration. Behind it is the team that responds: at an electronics seller in Mexico, every incident is recorded in a support log, and from August 1 to 12, 2026, the median resolution time was 10 minutes.
AI. Make: Make AI Agents on the canvas, with step-by-step visible reasoning, knowledge files and tools that can be modules, scenarios, MCP servers or other agents; Maia, which builds scenarios and agents through conversation; and an MCP server so Claude or ChatGPT can run your scenarios. Its own guidance recommends keeping agents away from tasks involving sensitive data, high-stakes financial or strategic decisions and strict legal requirements, according to its introduction to Make AI Agent. Puente OS: the complete system is built with AI. You describe in natural language what your operation needs and get apps, workflows, databases and agents running: that is how, at an electronics seller in Mexico, one person built 20 apps and 75 processes in ten months. Inside each process, critical logic runs on explicit, auditable rules, and agents take the steps that call for judgment: they run inside workflows, with tools, history and an iteration cap, and a decision agent classifies and routes with closed questions.
Governance and versions. Make: version history for each scenario for 60 days, with restore; organization and team roles; and Make Grid to see dependencies between scenarios. Puente OS: every workflow save creates a new version, and rolling back means activating the previous one; in apps, every publish is saved as a version, with earlier ones kept as history. Each app is assigned the tables its process uses, with read, write and delete permissions, and irreversible actions, like issuing a tax document, are designed in two steps: a draft and a person's confirmation. Puente manages the platform where everything runs.

What does it look like in a real operation?

It looks like a complete system that runs on each customer's rules, with a team that maintains it. Two Puente OS customers:

Example 1: a multichannel electronics seller in Mexico, from order to shipping label

An electronics seller in Mexico runs without an ERP, and Puente has seven of its sales channels connected. Every order follows its path on rules: the address is validated, the carrier is chosen by zone, cost and insurance, the label is generated and the tracking number is written to the order. Other processes run around it: a report that consolidates 213,362 Mercado Libre orders via API, a competitor price capture that has collected 1,209,812 records and saves the team 33 hours a month, and a support log where every incident is recorded.

Of the 38,628 orders processed between November 2025 and August 2026, 97.9% got their shipping label with no human intervention: 37,815 labels. Generating the labels for a cutoff went from 5 to 7 hours to 15 minutes, and monthly volume grew 40% with the same operations team. From August 1 to 12, 12 of 2,051 orders had an incident, 0.59%, with a median resolution time of 10 minutes. Behind it are 20 apps, 75 processes, 7 channels and 19 APIs, built in ten months by one person.

Example 2: a pet retailer in Chile, with orders, shipping and margin on one platform

A pet retailer sells on four channels. Its OMS (order management system) on Puente processed 56,597 orders between January and August 2026, and every shipment is measured against the delivery promise: 33,192 shipments measured and 85.0% on-time delivery among those not canceled, calculated against the courier's API. A workflow calculates the margin of every sales line each day: as of August 2026 it had covered 247,626 lines, and 3,830 of them, 1.5%, showed a negative margin that nobody saw before. Prices are also executed from Puente, with 8,362 changes in its online store.

It runs 10 apps in production for six departments, with 167 versions deployed, built and maintained by one person. The time from requesting a new process to having it in production dropped from 105 days, on the first project, to 7.

Why choose Puente OS?

Because you get your process running end to end and a team accountable for it. Make connects your teams' apps, and it does that very well; Puente OS delivers the complete system up and running: the apps where your team works, your business database, the workflows and the agents on a single platform, connected to your local systems, designed around your processes and built and maintained by the Growth Ops team. Six concrete reasons:

You get the complete system, ready to operate. Each process reaches production with its screen, its data, its rules and its agents, and your team works the exceptions in an app built for that process. At the pet retailer in Example 2, that adds up to 10 apps in production for six departments.
It works on the local systems you already use. Puente has native connectors for Mercado Libre, Bsale and Multivende, and the team connects your invoicing system, your courier or your ERP through its API, over HTTP or Python, or by reading the ERP's database. Puente reads, cross-references and writes back where it belongs, logging every action.
The process is designed before it's built. Growth Ops maps what triggers each process, what it decides and what its exceptions are, and defines with you where each one goes. The rules are written down explicitly, with history and rollback: changing one means editing it.
A team builds and maintains it, and your team keeps the decisions. Growth Ops builds each process with you and adjusts it when your operation changes. Your people spend their time deciding the exceptions, and the knowledge of the process stays in the system and in the team that keeps it running.
Someone is accountable when something fails. Every execution shows where it stopped and why, alerts flag the failure and Growth Ops resolves it. At the electronics seller in Example 1, from August 1 to 12, 2026, 0.59% of orders had an incident, with a median resolution time of 10 minutes.
Each process builds on the last. Each one reaches production in 2 to 4 weeks and uses the connections and data the previous ones left in place. At the pet retailer, the time from requesting a new process to having it in production dropped from 105 days to 7.

That way your operation runs on your rules, and your team spends its time deciding what takes judgment.

When does each one make sense?

Make fits when your business teams want to build and maintain automations between the apps they already use, on their own. Puente OS fits when you want the process working end to end, with a team that builds it with you and maintains it.

Make, if you have people in marketing, sales, operations or finance with the drive and the time to build their own scenarios, and your processes live mostly in apps already in its directory, like your CRM, your email, your spreadsheets or your store. Its visual canvas, its catalog of thousands of apps, Maia and the visibility that Make Grid and each scenario's history provide are real strengths.
Puente OS, if you want the process left running with its apps, its data and its rules, connected to Mercado Libre, Bsale, your invoicing system or your ERP, with a team that designs it with you, maintains it and responds when something fails. Also if you want your team to spend its time deciding the exceptions, and the next process to be added on the same platform.

How do you start?

With a process that hurts, with volume and manual handoffs: generating shipping labels, reconciling a marketplace or matching documents. With Puente OS, each process reaches production in 2 to 4 weeks.

Pick the process. With volume, manual handoffs and a visible cost when it fails.
Take the baseline. Cases per month, hours of manual work per week and the share of cases that come out right the first time.
Take inventory of what already runs. The scenarios, spreadsheets and scripts that touch that process, with what they do, who built them, who maintains them and which apps they use. That list defines what gets connected and what gets redesigned.
Connect the sources. Your ERP, your store, your marketplaces, your invoicing system, your courier and your bank statements.
Write down the rules your team applies from memory. For example: "if an order still has no label two hours after the cutoff, it goes to operations with the full order in view."
Decide where each exception goes. The system resolves it, or it reaches a named person with full context in an App.
Measure from the first week and add the next process on the same platform.

That is autonomous operations design applied process by process: the repeatable work runs on its own, on your rules, and your team decides what takes judgment. To choose which steps go to a workflow and which to an agent, this guide on how to implement AI in your business can help; if your technical team is evaluating a workflow tool, see Puente OS vs n8n, and if you sell on marketplaces, the same approach is in Puente OS vs Multivende.

We believe every company in Latin America can be operationally autonomous, and that starts with having every process running end to end, with its rules and a team that keeps it running.

Key takeaways

Make is a visual AI automation platform, part of Celonis, for business teams at any technical level to build scenarios: over 3,000 apps according to its website, routers and filters, five error handlers, Make AI Agents, Maia and an MCP server.
Around a scenario, running a business takes five more things: the designed process, the screen where your team works, your business database, someone accountable when something fails and local integrations.
Puente OS delivers the complete system up and running: apps, databases, workflows and agents on a single platform, designed around your processes and connected to your systems.
Puente has native connectors for Mercado Libre, Bsale and Multivende, and the Growth Ops team connects the rest of your systems via API, such as the SII, your invoicing system or your ERP.
The Growth Ops team builds each process, maintains it and responds when something fails: at an electronics seller in Mexico, 97.9% of orders go out with their label with no human intervention, and from August 1 to 12, 2026, incidents were resolved with a median time of 10 minutes.
Make fits when your business teams want to build and maintain their own automations between apps in its directory. Puente OS fits when you want the process running end to end, in 2 to 4 weeks per process.

Want to see what your process looks like running end to end? Let's talk about your processes, and we'll show you Puente OS running with cases like the ones in this article. Book a conversation with our team.

Frequently asked questions

What is Make and what is it used for?

Make is a visual AI automation platform, formerly called Integromat and now part of Celonis. Business teams use it to build scenarios on a canvas that connects over 3,000 apps, or any API with its HTTP app, with routers, filters, error handling and JavaScript or Python code when needed. It adds AI agents on the same canvas, an assistant, Maia, that builds scenarios through conversation, and an MCP server so assistants like Claude or ChatGPT can run your scenarios. According to its website, over 400,000 organizations use it.

Are Make and Integromat the same?

Yes. Celonis acquired Integromat on October 14, 2020, and on February 22, 2022 Integromat was renamed Make, with a new platform under that name, according to Make's press page.

Does Make work for companies without a technical team?

Make is built for that: it describes itself as a visual platform that lets teams of all kinds use AI automation without developer support, and Maia builds scenarios from what you write. In that model, each scenario is built and maintained by someone on your team, who also reviews it when an execution ends with an error. Puente OS is built for the company that wants the process working with someone accountable for it: the Growth Ops team designs it with you, builds it and maintains it, and your team decides the exceptions.

Does Make have AI agents?

Yes. Make AI Agents are built on the same canvas as scenarios, with a panel that shows their reasoning step by step and the option to add manual approvals. The new version, in open beta, combines a model, instructions, knowledge files and tools, which can be modules, scenarios, MCP server tools or other agents. Separately, Maia, in public beta, builds scenarios and agents through conversation.

Does Puente OS have AI agents?

Yes, and Puente OS's AI starts earlier: it's in how the system gets built. You describe in natural language what your operation needs and get software running; at an electronics seller in Mexico, one person built 20 apps and 75 processes in ten months. Inside that system, the agent is one of the four pieces, along with apps, workflows and databases, and it runs inside a workflow: a simple agent to draft or summarize, an advanced agent with tools, history and an iteration cap, and a decision agent that classifies and routes with closed questions. Each step goes to what fits it: a workflow for the rule, a model for the reading, an agent for the judgment and a person for the exception, as I explain in how to implement AI in your business.

Does Make integrate with Mercado Libre and Bsale?

In its integrations directory, as of October 11, 2026, searches for Mercado Libre and Bsale return 0 results, and the same goes for Defontana, the SII and Falabella, with verified and community apps included. The only app in the directory tied to that ecosystem is Notifications for Mercado Pago, verified and maintained by its vendor, which reports accredited payments and subscriptions. For a service without its own app, Make offers the HTTP app, which connects to any API. Puente OS has native connectors for Mercado Libre (orders and shipping details), Bsale (stock and documents) and Multivende, and the Growth Ops team connects the rest via API.

What happens to the scenarios I already have in Make?

They go into the inventory first. The Growth Ops team reviews with you the scenarios that touch each process, what they do, who built them and who maintains them, and decides which ones keep running where they are and which get redesigned within the process in Puente OS, with its app, its data and its rules. Each process reaches production in 2 to 4 weeks.

External sources cited

Everything this post says about Make comes from its website, its integrations directory and its help center, reviewed on October 11, 2026. Puente OS customer figures are production measurements as of August 2026; label generation time, the hours saved on price capture and the request dates for each process come from follow-up with the customer.

Make: company and product

Make, home page: headline "The visual AI automation platform"; "Connect any app, data source, or AI model. Build and manage automations and AI agents – visually, in code, or with a prompt."; over 3,000 pre-built apps; over 400,000 organizations in over 200 countries; solutions for IT, Operations, Marketing, Sales, Finance, Customer Experience and People; products Make AI Agents, Maia by Make, Make MCP Server and Make Grid.
About (Make): Make is part of Celonis, a process mining company; it has worked with customers since 2015; over 400,000 organizations.
Press (Make): "Celonis acquires Czech startup Integromat to accelerate move to process automation" (October 14, 2020); "Integromat evolves to Make" (February 22, 2022).
Make vs n8n (Make): Make describes itself as "visual-first" and says its visual interface and pre-built modules let teams of all kinds use AI automation without developer support.
Webhooks (Make help center): webhooks receive data over HTTPS and start a scenario immediately; each app's instant triggers and custom webhooks.
Router (Make help center): splits the scenario into several chains of modules, each route with its own filter; the fallback route processes data that matches no other route; routes are processed sequentially.
Iterator (Make help center): converts an array into a series of bundles processed one by one.
The Make Code app is available (Make help center): JavaScript or Python code inside the scenario, with an editor, in an isolated sandbox.
Data stores (Make help center): built-in database tool to store and manage data across scenarios.
Introduction to Make Grid (Make help center): dependency map showing how scenarios, apps, data stores and AI components connect; it updates automatically and flags scenario errors.
Teams (Make help center): Team Admin, Team Member, Team Operator (activates, deactivates and schedules scenarios), Team Monitoring (read-only access to scenarios and execution logs) and Team Guest roles.
Restore and recover scenario (Make help center): version history keeps each version for 60 days and lets you restore it.

Make: integrations

Integrations directory (Make): "over 3,000 pre-built apps"; the directory counter showed 3,620 apps on October 11, 2026, with the verified and community app filters on; offers the HTTP app to connect to any service with an API. Searches in the directory's search box on October 11, 2026: "Mercado Libre", "MercadoLibre", "libre", "Bsale", "Defontana", "SII", "Impuestos Internos" and "Falabella" return 0 results; "mercado" returns only Notifications for Mercado Pago. The directory addresses for mercadolibre, mercado-libre, bsale, defontana, sii, falabella and mercadopago return 404.
Notifications for Mercado Pago (Make): verified app, maintained by its vendor, with triggers for accredited payments and authorized or canceled subscriptions, and a module for API calls.
Human in the loop (Enterprise) (Make): app maintained by Make, on the Enterprise plan only, that creates review requests with their own link and starts a scenario when a review is approved, adjusted or canceled.

Make: errors and history

Error handlers (Make help center): Skip, Retry, Resume, Commit and Rollback.
Incomplete executions (Make help center): store the failed execution so data isn't lost; off by default; resolved automatically for the error types that support it, or by hand.
Scenario history (Make help center): each run with its status, duration, operations and data transferred; the output of each module; change log; run replay and CSV export.

Make: AI

Make AI Agents (Make): "Build AI agents you can trust"; agents built on the canvas, with a step-by-step reasoning panel, rules, manual approvals and stopping points; they work alongside deterministic logic.
Introduction to Make AI Agent (New) (Make help center): in open beta; components: model, instructions, knowledge, input, tools (modules, scenarios, MCP server tools and other agents) and files; shows step-by-step reasoning; recommends avoiding tasks involving sensitive data, high-stakes financial or strategic decisions and strict legal requirements.
Introduction to Maia by Make (Make help center): Scenario Builder assistant, in public beta, that creates scenarios and agents, modifies existing ones and helps fix errors with the run history; its changes can be reverted from the chat.
Make MCP server (Make help center): MCP clients like Claude and ChatGPT run active scenarios with on-demand scheduling as tools; with management permissions, they view and modify scenarios, teams, connections, webhooks and data stores; MCP toolboxes limit which scenarios are exposed.

Puente OS vs Make: From the Visual Scenario to the System That Runs Your Business