Make is the visual automation tool for power users, and it has been busy. AI Agents went into open beta in early 2026 with Maia, Make's AI builder, behind them. The Grid, a visual map of your whole automation landscape, rolled out to all paid users. A Reasoning Panel now traces agent decisions live during a run, and Autopilot gives agents their own cloud computers for work beyond API reach. Meanwhile the pricing model has been shifting from operations to credits, with AI modules consuming more per action than plain data moves.
The canvas remains both the appeal and the tax. Building a scenario still means understanding modules, routers, iterators, aggregators, data structures, and Make's execution model, and the new AI features are layered onto that same architecture. Your marketing manager is still not going to open the canvas and ship a competitor-monitoring workflow, and with credit consumption varying by module type, predicting what a scenario costs has gotten harder, not easier.
General Input takes the opposite path: no canvas to learn, because you describe the workflow and review what the platform builds. AI is the engine rather than a premium module class. And the run-time layer, per-execution cost breakdowns, approval gates, credential firewalling, workspace roles, comes standard rather than assembled.
What Make does well
- Visual expressiveness. For complex data routing, branching, array iteration, and error handling across dozens of modules, Make's canvas is one of the most capable tools anywhere.
- Catalog depth. 3,000+ apps with granular control over every field mapping and transformation.
- The Grid and Reasoning Panel. Seeing your whole automation landscape, and watching an agent's decisions stream live, are genuinely good observability ideas.
- Approachable entry pricing. Paid plans start around $9 a month, cheap for hobbyists and small experiments.
How they compare
| General Input | Make | |
|---|---|---|
| Natural language workflow buildingMaia assists inside the canvas. General Input's builder produces the entire workflow from a description or voice. | ||
| Visual drag-and-drop canvas | ||
| App integrationsMake: 3,000+ apps. General Input: 500+ apps with 30,000+ documented operations. | 500+ | 3,000+ |
| Built for non-technical usersMake requires learning modules, mapping, and its execution model. | ||
| AI agentsMake AI Agents are in open beta on paid plans. General Input agents are a core workflow type. | ||
| Deterministic code workflows | ||
| Human-in-the-loop approvals | ||
| Per-run cost transparencyGeneral Input shows the dollar cost of each run by step. Make bills credits that vary by module type. | ||
| Model choiceGeneral Input: two dozen models from nine labs, your keys, or your subscriptions via Token Tunnel. | ||
| Least-privilege credential scopingAgent Firewall limits each credential to specific operations, enforced outside the model. | ||
| Self-hosted / on-prem deployment |
Where they differ
Describing vs. diagramming
"When a deal closes in HubSpot, enrich the company, draft an onboarding email, and wait for the account manager to approve before sending" is a working General Input workflow in about a minute, built by typing or speaking that sentence. In Make, it is eight-plus modules to select, connect, and configure, and the person who builds it becomes its permanent maintainer. Make's Maia narrows this gap by assisting inside the canvas, but the artifact is still a canvas, and the canvas still has a learning curve that decides who in your company gets to automate.
What a run costs
Make's shift toward credit billing made AI's price variable: AI modules consume more credits than standard operations, consumption depends on what the agent does, and unused allowances only roll forward a month. Estimating a scenario's monthly cost means modeling module mix and agent behavior. General Input meters the actual run: every execution reports its exact cost, broken down by model tokens, integration calls, and compute, in credits with a fixed, published rate ($25 buys 4,000). Forecasting is arithmetic, not simulation. And Token Tunnel can zero out the model line by running the AI subscriptions you already pay for, or local models on your own hardware.
Governance and the security review
Make offers scenario permissions and logs; the deeper controls production automation needs are thinner. General Input ships them as the default: approval gates that pause a run until a person signs off, credentials encrypted and never placed in model context, Agent Firewall scoping so each credential can only perform the operations its workflow needs (read-only, write-only, or a single endpoint), every credential use logged, and on-prem deployment when data cannot live in a vendor's cloud. Make is cloud-only.
Where the AI actually lives
Make added AI to an architecture built for deterministic data routing: agents are modules inside scenarios. General Input was built the other way around: the model is the engine, and determinism is what you add where you need it, via code workflows that run identically every time. Both philosophies work; they optimize for different centers of gravity. If your automations are mostly data plumbing with occasional AI, Make's shape fits. If reasoning is the core of the work, summarizing, deciding, drafting, enriching, the AI-native shape wins.
When to use Make
Choose Make when a technically minded operations team wants visual control over intricate data flows: heavy branching, array manipulation, and error handling across a deep catalog, at low entry cost. For visually orchestrated ETL between SaaS tools, the canvas earns its keep.
When to use General Input
- Everyone builds, not just the canvas experts. Plain-English and voice building puts automation in the hands of ops, finance, support, and marketing.
- AI is the workload. Agents, model choice across nine labs, effort control, and auto-routing, without premium-module credit math.
- You must answer for costs. Exact per-run breakdowns and workspace analytics, priced at a published credit rate.
- Security signs off. Approval gates, credential firewalling, audit logs, and on-prem deployment.
- One platform, four building blocks. App workflows, deterministic code, AI agents, and interactive Apps, sharing credentials, permissions, and monitoring.
FAQs
Can General Input handle Make-level complexity without a canvas?
Yes. Complex logic lives in the workflow definition and, where determinism matters, in TypeScript code steps you can review line by line. You express the complexity by describing it; the platform writes and maintains the implementation.
We have hundreds of Make scenarios. Is migration realistic?
Migrate incrementally. Leave stable data-plumbing scenarios in Make, and move the AI-heavy and approval-needing workflows to General Input first, where the payoff is largest. A webhook connects the two platforms for hybrid flows.
Does General Input have anything like the Reasoning Panel?
Every run has a full execution trace: inputs, outputs, tool calls, timing, and cost per step, kept as reviewable history rather than a live-only view, and exportable for audits.
Better together
Make's canvas is a fine home for intricate, developer-adjacent data routing. General Input is the layer where AI does the thinking and the whole team does the building, with the cost and governance story a business can stand behind. Many teams run both, connected by a webhook.