Make Review July 2026: Private Spaces, GPT-5.6, and Whether the 4.4 Holds

The 4.4 moves to 4.5. Make's July additions close the one governance gap that kept a mixed-technical team on the fence: Private Spaces caps per-member credit spend on every plan now (help.make.com/private-spaces, retrieved July 24 2026), and the agent builder that sat behind a closed-beta waitlist in our June review ships as a documented app.

Here is the one thing to leave with. If you read the June review and stopped at the con "no way to cap an individual team member's spend," that blocker is gone, and it is gone on the 9-dollar Core plan, not just Enterprise. The GPT-5.6 cost worry that looked like it might drag the score down turns out to be mostly a non-issue, for a reason worth walking through: with your own OpenAI key, Make bills one credit per operation and OpenAI bills the tokens, so there is no token markup for routing a model through Make.

What changed since June 25

The June review is 29 days old and predates all of this. Three dated items.

• Private Spaces (July 17 2026). Every member of an organization, guests excepted, gets an isolated workspace for scenarios and connections teammates can't see, and admins set a monthly or yearly credit limit per space (help.make.com/private-spaces, retrieved July 24 2026). Available on all plans.
• GPT-5.6 landed at OpenAI (July 9 2026). OpenAI shipped the GPT-5.6 family, Sol, Terra, and Luna, across ChatGPT, Codex, and the API (TechCrunch, July 9 2026). Make's OpenAI connector points an agent at any model on your own OpenAI key, the same path that carried GPT-5.5 after Make added it April 28 (help.make.com 2026 changelog).
• The MCP Client module. Make shipped the client half of its MCP story, a module that lets a scenario or agent call tools hosted on external MCP servers "without raw code, local hosting, or external infrastructure" (make.com blog, MCP Client). This deepens the MCP tools launch that went GA for AI Agents June 3 (Make community, June 4 2026).

Two of those, Private Spaces and the graduated agent builder, are the reason the score moves. The GPT-5.6 item mostly clarifies a cost question the June review left open.

Private Spaces: the per-member spend control the June review wanted

This is the headline change, and it maps almost exactly onto a gap operators kept flagging: a shared Make org had no way to stop one member from burning the whole credit pool. Now it does.

Private Spaces gives every member their own workspace for scenarios and connections other members can't access, and it is on every plan, not gated to Enterprise (help.make.com/private-spaces, retrieved July 24 2026). An admin enables it once for the whole org, then sets a default credit limit that every new member inherits.

The control that matters is per-member. An admin sets a specific number of credits per month or per year for each member's space, or leaves it unlimited, in which case that member draws from the organization's shared pool (help.make.com/private-spaces, retrieved July 24 2026). The enforcement is blunt in a good way: when a member hits their limit, every scenario in their private space pauses. They can keep building, they just can't run, until the limit resets or an admin raises it.

Here is the click path an admin follows to cap one member:

# Cap a single member's monthly credit spend (Make org admin)
# Source: help.make.com/private-spaces, retrieved 2026-07-24

1. Left sidebar > Org > Org Users
2. Find the member row, hover the "Private space" column, click the pencil icon
3. Toggle "Set credit limit" on
4. Enter a number (e.g. 2000 credits/month), click Save
   -> that member's scenarios pause when they hit 2,000 credits;
      they can still edit scenarios, just not execute them

The Enterprise-only piece is visibility, not control. On Enterprise, an admin can open a member's private space in a read-only view and see scenario names, the modules used, and credit usage. They can't see module settings, run history, run details, data stores, or connections (help.make.com/private-spaces, retrieved July 24 2026). So a 20-person org on Teams gets the spend cap that stops a junior from draining the pool, but not the audit view of what that junior actually built. If you need the read-only oversight, that is an Enterprise conversation.

Tie it back to June. The June review's implicit knock on Make for larger teams was that credit governance was all-or-nothing at the org level. That knock is resolved on every paid tier. The candid con that replaces it is narrower: the oversight layer, the read-only view, is still an Enterprise feature.

GPT-5.6 in an agent loop: is the credit meter the problem?

Short answer: no, not the way people assume. The worry going in was that routing GPT-5.6 Sol through Make's credit meter would double-tax it, once by OpenAI for tokens and again by Make for credits, making agent runs cost-prohibitive next to calling the API directly. The billing docs say otherwise.

Sol is the reasoning tier of the GPT-5.6 family, priced at 5 USD per million input tokens and 30 USD per million output tokens (GPT-5.6 Sol pricing, OpenRouter, retrieved July 24 2026). Those are real numbers, and on a chatty agent they add up. But here is how Make bills a Sol run when you connect your own OpenAI key, which is a custom AI provider connection available on any paid plan:

# Make AI Agent credit cost by provider (per help.make.com/credit-usage-for-ai-agents,
# updated 2026-07-02, retrieved 2026-07-24)

Run an agent:
  Make's AI Provider (Make's bundled key):  1 credit/op + credits based on AI tokens
  Custom provider (your OpenAI/Anthropic key): 1 credit/op   [no token markup]

Chat that calls tools:
  Custom provider: 1 credit/op + 1 credit/op per called tool

With your own key, Make charges one credit per operation, and OpenAI bills the tokens directly to your OpenAI account (help.make.com/credit-usage-for-ai-agents, retrieved July 24 2026). Make does not mark up the tokens. You pay OpenAI the same 30 USD per million output tokens whether Sol runs inside a Make agent or from a raw script.

So what does a credit cost you? On Pro, 16 USD buys 10,000 credits (make.com/en/pricing, pulled July 24 2026), which works out to 0.0016 USD per credit. Put those two facts together on a worked example:

# One Sol-powered agent run inside Make, own OpenAI key
# 1 reasoning operation + 5 tool calls (chat that calls tools)

Make credits:  1 op + 5 tool calls  = ~6 credits
Make dollar cost: 6 x 0.0016 USD     = ~0.0096 USD   (about one cent)
OpenAI token cost: whatever Sol bills for the tokens in that run
                   (the actual money, at 5/30 USD per M in/out)

The credit tax on a single Sol run is a rounding error next to the token bill. Running Sol through Make is not cost-prohibitive versus the direct API. The place credits bite is exactly where they bit in June: fan-out. An iterator over a 500-row array that fires a tool each pass is 500-plus operations, and every operation and every called tool is a credit. High-volume agent loops are where the meter shows up, not the per-run model cost. If your workload is a few hundred agent runs a month, credits are negligible and Sol's token cost is your real line item. If it's tens of thousands of iterated operations, budget against your scenario shape, not the list price.

One caveat worth stating plainly: this holds because you bring your own OpenAI key. If you use Make's bundled AI Provider instead, Make does charge credits based on AI tokens on top of the per-operation credit. On any paid plan, connect your own key and skip that.

The MCP Client: calling an external server without an HTTP module

The June review covered MCP tools going GA for AI Agents on June 3, where an agent could read the tool list an external MCP server exposes and call those tools in its reasoning loop. The MCP Client module is the packaged version of that connection.

What it adds is a no-code path. Before, wiring an agent to a service without a native Make module usually meant hand-building an HTTP module: method, URL, headers, auth, body, one per endpoint. The MCP Client lets a scenario or agent "call tools hosted outside of Make securely and visually, without raw code, local hosting, or external infrastructure" (make.com blog, MCP Client). Point it at an MCP server, and every tool that server exposes becomes callable.

Concretely: say you want an agent to scrape a page with Firecrawl and write structured rows to Postgres. Both have MCP servers. Instead of two HTTP modules with their own auth and payload shapes, you add one MCP connection each and the agent sees the tools:

# Make AI Agent with two external MCP servers as tool providers
# Shape follows help.make.com/mcp-tools-for-ai-agents; connection created
# via the MCP Client module (make.com/en/blog/mcp-client)
agent:
  name: "page-to-postgres-agent"
  provider: openai            # custom provider connection, your own key
  model: gpt-5.6-sol          # any model your OpenAI key can reach
  instructions: |
    Scrape the requested URL, extract the fields the user asks for,
    and insert one row per record into the leads table.
  tools:
    - type: mcp_server
      name: firecrawl
      url: "https://<FIRECRAWL_MCP_HOST>/mcp"
      auth: bearer
    - type: mcp_server
      name: postgres
      url: "https://<POSTGRES_MCP_HOST>/mcp"
      auth: bearer

The agent reads the tool lists both servers expose and decides when to call scrape versus insert during the run. You write the instructions; the model picks the path. For an ops person who was building HTTP modules by hand, that removes a real chunk of setup. n8n has had an MCP client node for a while, so this is Make reaching parity on the integration surface, not leapfrogging, but it lands the capability inside the visual builder a non-developer already uses.

Updated pros and cons vs June

The June review held Make at 4.4 with four candid cons. Here is what July did to them.

June 2026 con	July 2026 status
Next-gen visual agent builder is closed beta	Improved. The Make AI Agent (New) app is documented in the help center (updated July 2 2026), past the very-limited waitlist the June review described
Still no self-hosting	Unchanged. No self-host path; the credit meter never hits zero
Credit math punishes high fan-out	Unchanged, and reinforced. Agent tool calls bill one credit each, so chatty loops add up
Features carry beta labels	Improved. The agent app ships as documented; AI Web Search still carries a beta tag on the pricing page (make.com/en/pricing, July 24 2026)
(New gap the June review flagged) no per-member spend control	Resolved. Private Spaces caps per-member credits on every plan (help.make.com/private-spaces, July 24 2026)

The new consideration that arrives with July: GPT-5.6 puts stronger, pricier models one dropdown away, and Sol's 30 USD per million output tokens (OpenRouter, July 24 2026) lands on your OpenAI bill. That is not a Make markup, but a team pointing agents at Sol should watch OpenAI spend the way they watch credits.

Net: two cons resolved or improved, the two structural ones (no self-hosting, fan-out credit math) unchanged. That is a 4.5, not a 4.7. Self-hosting and volume economics are the ceiling, and only n8n's model removes them.

The verdict, by who you are

Make earns 4.5 in July 2026 because Private Spaces closes the governance gap on every plan and the agent builder is out of closed beta. The picks, by situation:

• Solo non-developer operator. Make, still, without hesitation. Private Spaces is irrelevant for a team of one, but GPT-5.6 through your own OpenAI key gives you frontier reasoning at OpenAI's token price plus a fraction-of-a-cent credit per operation, inside a canvas you can read. Start on Free's 1,000 credits, validate a real agent, then move to Core at 9 USD a month (make.com/en/pricing, July 24 2026). If you land here, Make's paid plans are the buy.
• Mixed-technical ops team, deciding Make vs n8n. Make now edges n8n, and Private Spaces is why. A team with a budget owner who needs to cap what each member can spend gets that on Teams at 29 USD a month per 10k credits (make.com/en/pricing, July 24 2026), with no server to run. n8n has no hosted equivalent; you'd build governance yourself. The flip condition: if every member is technical and the team wants zero per-run cost more than it wants managed spend caps, n8n self-hosted wins. For the common case, a few technical people and several who aren't, Make is the cleaner call.
• Dev team with Docker capacity. n8n still wins on cost, and nothing in July moves that pick. Make added no self-hosting, so the per-credit meter stays. GPT-5.6 is available on both, since both point at your own OpenAI key. The MCP client reaches parity, not advantage. Once your monthly operations clear roughly 30 to 40k and someone can patch a Docker box, self-hosting deletes the meter Make charges on. An n8n VPS runs in the 10-to-20 USD a month range on a small box such as Cloudways, and the n8n review covers the license clause that decides resale cases. The number that block never shows is your ops time; if nobody wants the pager, Make's managed model is still the rational buy even where the dollar math favors n8n.

FAQ

Did Make's rating change in July? Yes, from 4.4 to 4.5. Private Spaces added per-member credit caps on every plan (help.make.com/private-spaces, July 24 2026) and the next-gen agent builder left closed beta. No self-hosting and credit fan-out at volume keep it under a 4.7.

What is Make Private Spaces? An isolated workspace for every org member's scenarios and connections, on all plans, where an admin sets a monthly or yearly credit limit per member, or leaves it unlimited to draw from the org pool. Enterprise adds a read-only admin view of a member's space (help.make.com/private-spaces, July 24 2026).

Does running GPT-5.6 through Make cost more than the OpenAI API? Not in tokens. With your own OpenAI key, Make bills one credit per operation and OpenAI bills the tokens directly, so there is no token markup (help.make.com/credit-usage-for-ai-agents, July 24 2026). A credit is about 0.0016 USD on Pro; the real cost is Sol's tokens at 5/30 USD per million in/out (OpenRouter, July 24 2026).

What is current Make pricing? Free is 1,000 credits a month. Core is 9 USD, Pro 16 USD (recommended), Teams 29 USD, each for 10,000 credits a month, with Enterprise custom. Annual saves 15 percent or more (make.com/en/pricing, pulled July 24 2026).

Is Make better than n8n now? For a mixed-technical team that needs per-member spend caps without running a server, yes, Private Spaces is the deciding feature. For a Docker-capable team at high volume, n8n's self-hosted model still removes the per-credit meter and wins on cost.