Waves '26: The glass box for the agentic era

A year ago, most companies were early in their AI journey. Today, almost every company we talk to has rolled out AI. However, few of them can say what it's actually doing and, for most, AI stays stuck in localized pilots and personal chat windows. 

We’re at an inflection point. While AI usage in business has transformed, AI isn’t yet transforming the processes businesses run on.

The problem isn't the models. They're capable enough today for far more than most companies run in production. The problem is that your business can feel like a black box when you scale AI at speed. AI tools spread faster than anyone can authorize them. Spend grows with no way to tie it to solutions or measure ROI.

That's fine for personal productivity. But it's unmanageable for the business processes your company runs on. If one of those fail, the whole business feels it. And without visibility of AI in your business, you can't see what went wrong, let alone take control and fix it.

Today, our CEO Fabian Veit shared what we believe: in the agentic era, businesses need a glass box, not a black box. Every solution, every process, and every action, whether a person or an agent takes it, should be visible, permissioned, and reversible.

Three convictions about where work is going

AI is moving faster than ever before. Based on how our customers operate and what we see across the market, we hold three convictions. Everything we announced at Waves 2026 is built on them.

• The vast majority of business operations will be run by agents. Your teams will give the instructions, see the solution come to life, and stay in control of the quality of the result.

• Chat becomes the place where work happens. Language becomes the fastest way to build, and visual stays the fastest way to understand. The canvas stops being an authoring tool and becomes where people inspect, tweak, and correct what agents built. 

• Move fast from experiment to a governed solution. What starts as a quick experiment should naturally mature into an enterprise-ready process as you gain confidence in what works.

How Make is evolving

Our vision is to become the visual layer where agents do the majority of the work reliably, and humans stay in control.  In order to deliver this vision we will focus on four promises:

• AI of your choice. Make will be powered by your favorite AI provider. You're never locked into one model or vendor, and when a new model arrives, you plug it in.
• Every system, workflow, and agent on one visual map. Everything that runs through Make is logged and tracked, so you get a visual source of truth for how your systems are configured and how agents actually work across the business.
• Connected to thousands of systems. Your agents work with the full picture of your business, through one central, governed layer.
• Governance built in by design. With governance built in, teams move from experiment to governed solution without slowing down.

Backing up an ambition this bold requires real execution and not just high-level talk. Our product team, walked through the concrete updates bringing this vision to life across four pillars - Discover, Build, Govern, Observe - and where we see the future heading.

How we bring it to life: Discover, Build, Govern, Observe

Everything we ship is anchored in four product pillars: Discover, Build, Govern, and Observe. 

Discover: Where your business finds its next opportunity

Before you build anything, you need to know what's worth building. Too often, automation priorities are still set by workshop sticky notes and whoever complains loudest. Make Process Intelligence, powered by Celonis technology, replaces guesswork with evidence
It builds a live map of how work actually runs across your systems, AI agents, and people. Ask why a case is delayed, find the root cause, and prove whether a change worked. PI runs on 2 core capabilities:

• Task Mining: See the manual work that leaves no trace in system logs, grouped into tasks and ranked by where time goes. Turn the best candidates into scenarios with Maia. 
• Process Mining: Understand what happens inside your systems: the map of your processes, including how your agents actually run.
  Waitlist for both is open!

Build: Where people and agents turn opportunities into solutions

There are now two ways to build with Make. The traditional way is Scenario Builder, where you design the scenario by hand. The agentic way is where an agent builds for you – Maia by Make, or the agent you already use, over MCP. Either way, you end up with a scenario you can open, read, and change.

Here are key upgrades for building the traditional way:

• Run up to a module with reuse: Test mid-scenario with previous run data to save time and operations on earlier modules. (coming soon)
• Data pinning: Pin and edit test data on any module, so you test your fix without re-running the whole scenario or spending operations on it. (coming soon)
• Human in the loop (HITL): Pause any scenario for approval and sign-off from Slack, Teams, or the Make mobile app. Agents act; you decide how far. (coming soon)
• Agent orchestration: Give an agent a team of subagents, so it hands each job to the right specialist instead of collapsing under 20 instructions. (available)
  

We’re also dialing up the experience when you’re building with an agent. 

Maia by Make, upgraded: Maia now covers more of the life of a scenario, with you in control at every step. In Plan mode, Maia lays out its approach, modules, and assumptions, checking connections and app capabilities, and plan-tier access before anything changes on the canvas. Nothing is built until you approve. Memory carries your preferences, such as the apps you use and how much detail you want, across chats. Now you can paste a diagram or screenshot straight into the chat instead of typing everything out. (available)
‍
Introducing an execution layer for building better with agents: Getting an agent to do something once in a chat is easy. Getting it to do the same work reliably inside a company is much harder: results have to be consistent, the task spans several tools, the context is scattered, and someone is accountable when it goes wrong. A smarter model doesn't solve that. The execution layer does. It's the part of the stack where an agent's decisions become actions, and where those actions stay dependable and under control. It has four parts:

• Functions: Code agents can run. Your agent writes the code; Make runs it with the connections you already have and shows it visually on the canvas, so the same job runs the same way every time. Keys stay safe. (coming soon)
• Endpoints: These are systems that agents are allowed to reach. Business systems hold critical data and critical processes, so access should come through connections a team already manages, not through credentials handed around case by case. With Endpoints, you can grant access to single API actions, not whole apps. If you want the agent only to read email, that's all it will do. (coming soon)
• Knowledge: Context it can use. Keep company context in one place, and everyone, people and agents, will use information from a single source. (available)
• MCP toolboxes: Hand each agent a defined set of connections, scenarios, functions, and knowledge, and nothing outside it. Toolboxes work with Claude, ChatGPT, and any agent that speaks MCP, and every call is logged against the person who made it. (coming soon)
  
  

Govern: How you stay in control as you scale

An agent isn't a new kind of actor with its own door into Make. It acts on behalf of someone, with their role and their connections. That holds today: when an agent calls Make over MCP, it's checked against its owner's role at the moment it acts. Our governance model builds rings around that rule, and nothing can cross its boundary.

• Organization policy: Decide which apps, endpoints, and AI models your company connects to, enforced at runtime for people and agents alike. (coming soon)
• New controls for organization owners:
  
  • Custom Roles: Choose permissions one by one. Granular roles for a person, and every agent they work with inherits the same permissions. (available)
  • Private Spaces: Keep experiments and credentials private from everyone else in the organization, including admins and their agents. (available)
  • Locked connections: Lock a connection without letting anyone edit or reuse it somewhere you didn't agree to. (coming soon)
  • Asset-level permissions: Move the boundary from the team to what you build, so you decide exactly who can open, read, and change it.

• Controls for users’ agents with MCP toolboxes with a defined set of connections, scenarios, functions, and knowledge, and nothing outside it.

Governance isn't how you slow people down. It's how you let more of them in, so IT can finally say yes to AI.

Observe: Where people and AI get the context to trust the system

The more people and agents you let in, the more you need to see what's there and what's happening. Whoever is accountable for the platform still has to answer the hard questions from auditors, security, and privacy teams. Observe gives them the answers.

• See what is there with Make Grid: 
  
  • See everything built in Make, including AI agents and automations on other platforms, in one live map. Trace objects, agent prompts, and execution logs with full-text search.  (available)
  • Give Maia or your agent of choice the full picture, so it can answer "what reads from this Salesforce table?" and change your landscape without breaking it. (coming soon)

• Understand what’s happening with:
  
  • Agent evals and AI spend: Track whether agents are getting better or worse, and what. (coming soon)
  • Event subscriptions: Hear about the events you care about the moment they happen, including agent runs that finish but go wrong. (available)
  • OpenTelemetry support: Stream Make data to the observability tools your team already uses. (coming later)
  • Audit logs for agents and MCP: One immutable record of changes, whether a person, an agent, or an MCP client made them, also reachable via MCP (available)

What comes next: Introducing MakeOS

Each pillar solves a real problem on its own. Today, our CTO and co-founder Patrik Simek showed the future of how they will work together.

Introducing MakeOS, a new product: The place where AI agents do your company's work reliably. You see all of it, orchestrate how it's done, and stay in control.

For more than 10 years, we've helped you trust the automations you build, because you could see every module, run, and error. Our next mission is to help you trust what AI builds for you.
‍
MakeOS gives your business a Glass Box: every agent, process, and action visible, permissioned, and reversible. You can move from AI pilot to AI transformation confidently.

Here's what MakeOS promises:

• Full visibility: See every agent, what it's working on, what it costs, and who's responsible for it, with your scenarios on the same map.
• Intelligent self-learning: MakeOS watches how work runs and suggests AI or fixed automation steps where relevant, keeping your token spend under control.
• Governance built-in: When an agent tries to go past its limits, MakeOS blocks it, asks a person, and logs the attempt, all on guardrails IT approved once.
• Built for teams: Share automations, agents, and apps across departments.
• Multiplayer: shared across departments: Share agents, automations, and apps across departments. Colleagues get the agent, not your data. 

MakeOS enables your business to be deterministic where it matters, agentic when it helps, and human when it counts.