Why Make.com Scores 67 for Agent Readiness: The Automation Platform Pattern
Make.com (formerly Integromat) scored 67 Silveron the Agent Readiness Score. That is higher than 87% of the 500+ businesses we have scanned. The reason is structural: automation platforms are built to connect APIs, which makes them naturally agent-friendly. But “naturally agent-friendly” is not the same as agent-ready.
The 9-Dimension Breakdown: Where Make.com Wins and Loses
Make.com's score tells a clear story: strong technical infrastructure (D2 API at 82, D7 Security at 75, D3 Onboarding at 78) dragged down by a near-zero D9 Agent Experience (28). This is the automation platform pattern — companies that build excellent APIs for human developers but have not yet adapted those APIs for autonomous agent consumption.
D1 Discovery (0.12)
72/100Excellent SEO, public docs site, Schema.org markup, robots.txt allows all crawlers. Strong sitemap coverage of API docs and templates.
D2 API Quality (0.15)
82/100Full REST API with JSON responses, well-documented endpoints, consistent error handling, pagination, webhooks. Built by developers for developers.
D3 Onboarding (0.08)
78/100Self-service signup, API key generation in minutes, free tier with real API access. No sales call required to start building.
D4 Pricing (0.05)
45/100Public pricing page but enterprise tiers are gated. Custom pricing requires sales contact. Operations-based billing is complex for agents to calculate.
D5 Payment (0.08)
52/100Stripe-based billing, but no x402 or agent-native payment rails. Subscription management requires human dashboard interaction.
D6 Data Quality (0.1)
71/100JSON-LD on marketing pages, structured API documentation, well-typed request/response schemas. Template marketplace has structured metadata.
D7 Security (0.12)
75/100OAuth 2.0, API key auth, TLS everywhere, rate limiting, security.txt. SOC 2 compliant. Standard security infrastructure.
D8 Reliability (0.13)
69/100Status page at status.make.com, sub-200ms API responses, CDN-backed, changelog exists but is HTML-only. Good but not exceptional.
D9 Agent Experience (0.1)
28/100No agent-card.json, no MCP server, no llms.txt, no AGENTS.md. The biggest gap. Make.com is built for humans to configure, not for agents to call directly.
The Automation Platform Pattern: Why API-First = Agent-Friendly
Automation platforms like Make.com, Zapier, and n8n exist to connect APIs together. Their entire product is built around consuming and exposing structured data over HTTP. This gives them a natural advantage on the Agent Readiness Score because the infrastructure agents need — REST APIs, webhooks, structured data, developer documentation — is the same infrastructure these platforms need to function.
Compare this to a local cleaning company (score ~9) or a dental practice (score ~11). Those businesses have to build API infrastructure from scratch. Make.com already has it. The question for automation platforms is not “can agents use your API” — it is “can agents use your API without a human configuring things first.”
That distinction — human-configured vs. agent-autonomous — is the gap between Silver and Gold. Similar to what we documented with developer tools, the technical foundation is excellent but the agent-specific layer is missing.
The existential question for automation platforms: In a world where AI agents can build integrations directly (calling APIs, setting up webhooks, handling auth flows), do automation platforms become more important or less important? The platforms that position themselves as infrastructure agents use — not just tools humans use — survive. The ones that stay human-only get disintermediated by agents that build integrations natively.
Automation Platform Scorecard
Make.com is not the only automation platform we scanned. Here is how the category compares. The pattern holds across all of them: strong APIs, weak agent experience. Similar to the pattern in our Slack breakdown, these are mature platforms with excellent developer ecosystems that have not yet built the agent-native layer.
Zapier's Natural Language Actions (NLA) is the closest any automation platform has come to being directly agent-callable. NLA lets AI models trigger Zaps using natural language descriptions — essentially an MCP-like interface before MCP existed. But NLA is proprietary. The first automation platform to ship a native MCP server gets access to the entire open agent ecosystem.
What Pushes Automation Platforms Toward Gold
Make.com is 8 points from Gold. Here are the specific changes that would close the gap — and transform automation platforms from tools humans configure into infrastructure agents use.
Ship an MCP server
Expose scenario creation, execution, monitoring, and template browsing as MCP tools. An agent should be able to: list available templates, create a scenario from a template, execute a scenario, and check execution status — all through MCP.
Publish agent-card.json
Declare capabilities, supported auth methods, rate limits, and pricing in a machine-readable agent card at /.well-known/agent-card.json. This is the discovery mechanism agents use to find services they can interact with.
Transparent per-operation pricing API
Replace "contact sales for enterprise" with a structured pricing endpoint. Agents need to calculate cost before executing. get_pricing({ operations: 10000, integrations: 50 }) should return a number, not a sales form.
Add llms.txt and AGENTS.md
These files tell AI models how to use the platform programmatically. llms.txt is a plain-text summary of API capabilities. AGENTS.md describes the optimal agent workflow for interacting with the platform.
Structured JSON changelog
Move from HTML-only changelog to a JSON API endpoint with version numbers, breaking change flags, and affected endpoints. Agents need this for reliability.
The strategic pivot: Automation platforms have a choice. Stay as visual builders for humans and compete with AI agents that can build integrations directly. Or become the execution layer that agents call when they need complex multi-step workflows. The first platform to make this pivot — to become the thing agents call, not just the thing humans configure — captures the agent-driven automation market. That market is larger than the human-driven one because agents can create and execute thousands of workflows per minute.
What This Means If You Use Make.com
If your business relies on Make.com for automation, your agent readiness is partially dependent on Make.com's agent readiness. When agents can call Make.com directly, they can trigger your workflows without human intervention. Until then, Make.com is a tool in your stack — not an agent-accessible interface.
The practical implication: do not wait for Make.com to become agent-ready. Build your own agent infrastructure (MCP server, agent-card, structured pricing) that agents can access directly. Use Make.com as a backend orchestration layer while exposing your own agent-facing endpoints. When Make.com eventually ships MCP support, you can integrate it into your agent infrastructure — but you should not depend on it.
If you build on Make.com
Your automations work but are not agent-accessible. Agents cannot trigger your Make.com scenarios directly. Build agent-facing endpoints that call Make.com internally.
If you compete with Make.com
The first automation platform with native MCP captures the agent-driven automation market. n8n's open-source model and built-in AI agent nodes position it well for this.
If you evaluate automation platforms
Score them on agent readiness, not just feature count. The platform that becomes agent-callable first delivers more long-term value than the one with the most integrations today.
If you are Make.com
Ship MCP. You are 8 points from Gold and one protocol implementation from capturing the entire agent-driven automation market. Your API infrastructure is already there. The missing piece is the agent-native layer.
Frequently Asked Questions
Why do automation platforms score higher than average?
Automation platforms are built to connect APIs — that is their core product. This means they already have REST APIs, webhooks, structured data schemas, developer documentation, and self-service onboarding. These are exactly the things the Agent Readiness Score measures. The average business scores 43/100. Automation platforms start at 55+ because their product inherently requires the infrastructure agents need.
What prevents Make.com from reaching Gold (75+)?
Two things: D9 Agent Experience (28/100) and D4 Pricing (45/100). Make.com has no agent-card.json, no MCP server, no llms.txt, and no AGENTS.md. It is built for humans to configure through a visual builder, not for agents to call directly. Enterprise pricing that requires sales contact also hurts. Adding an MCP server that exposes scenario creation and execution as tools would push Make.com into Gold.
Is Make.com competing with AI agents or complementary to them?
Both. Today, Make.com is a tool humans use to build automations. In the agent economy, Make.com could become infrastructure that agents use to execute complex multi-step workflows. An agent that needs to sync data between 5 systems could call Make.com's API to trigger a pre-built scenario rather than building the integration itself. The question is whether Make.com positions itself as the thing agents call or gets replaced by agents that build integrations directly.
How does Zapier's NLA compare to MCP?
Zapier's Natural Language Actions (NLA) lets AI models trigger Zaps using natural language. It is the closest any automation platform has come to being directly agent-callable. However, NLA is proprietary to Zapier and not based on an open standard like MCP. Agents that support MCP cannot automatically use NLA and vice versa. The platform that adopts MCP first gets access to every MCP-compatible agent on the market.
What would a Gold-tier automation platform look like?
A Gold-tier automation platform would have: (1) an MCP server that exposes scenario creation, execution, and monitoring as tools, (2) an agent-card.json declaring its capabilities, (3) transparent per-operation pricing that agents can calculate, (4) a structured JSON changelog, and (5) llms.txt explaining how to use the platform programmatically. The platform would be usable end-to-end by an agent without any human touching the visual builder.
How does your platform score?
Run your domain through the AgentHermes scanner. See your score across all 9 dimensions and find out exactly where you stand in the agent economy.