Low/No-Code AI Agent Builders: n8n, AgentKit, make, Zapier
We shared our thoughts and experiences on using frameworks for building AI agents, such as LangChain, which heavily require a coding background. For those interested in using low/no-code tools for building AI agents, we will describe our experience using n8n (self-hosted free edition), OpenAI’s AgentKit, make, and Zapier.
AI agent builder options
- n8n: Open-source low-code workflow engine with AI extensions. Developer-oriented, code-driven. Essentially a wrapper on LangChain. Also, swings heavily towards SaaS. Support deep agent orchestration features like memory or tool reasoning. Provides a dedicated agent node.
- OpenAI Agent Kit: Low-code, drag-and-drop agent builder for creating chat and tool-using agents. Best for teams and users deeply embedded in OpenAI’s ecosystem; not a strong tool for building highly custom agents. It includes agent evaluation tools as built-in features, such as automated grading, prompt optimization, and performance tracking
- make: Visual, cloud-based SaaS tool. Supports multi-step agent workflows, conditional branching, and API integrations. Provides less agentic flexibility and logic than n8n, but it still supports custom configurations setups via HTTP requests, JSON/router modules and webhooks.
- Zapier: Visual, cloud-based SaaS tool. The most beginner-friendly option with a code prompt-based AI agent builder. However, its architecture is linear, and deeper logic (like branching or feedback loops) requires paid features such as Paths or Code by Zapier.
AI agent builders benchmark summary
Evaluation methodology: To reflect real-world priorities for building no-code AI agents, we adjusted the maximum value per category based on practical importance, not just feature count.
Core capabilities like agent tooling support, model support were given more weight. We assigned relatively fewer points to auxiliary aspects like ease of use, UI elements. See the detailed breakdown of how each tool was scored in every category.
About n8n
n8n is a workflow automation tool, often compared with competitors like Zapier and Make. What sets n8n apart is that its entire source code is available on GitHub. It is a large TypeScript codebase with more than 145+k stars, and it is a large TypeScript codebase you can actually learn from.
With n8n repository, you can extend workflows with real code through the Code node, which lives in the packages/nodes-base/nodes/Code/ folder. This part of the repo shows how n8n handles custom JavaScript and Python execution inside workflows.
n8n calendar agent workflow with connected nodes for chat input, memory, LLM processing, and Google Calendar integration.
n8n hosting: n8n is distributed under a Fair Code license:
- You can use self-hosted n8n for free if it’s for personal use, internal automation, or client work.
- You must purchase a commercial license only if you’re building a SaaS where n8n itself is exposed to end-users who log in or connect their own accounts through n8n nodes.
For this review, we used the free self-hosted community edition of n8n.
About OpenAI’s AgentKit
In October 2025, OpenAI announced AgentKit, a toolkit for building and deploying AI agents. Similar to othe AI agent builders it features a visual drag-and-drop canvas to integrate workflows, tool calls, memory, and logic with minimal coding.
How is it different:
- AgentKit is more specialized toward agentic logic and reasoning: how an AI reasons, delegates, uses tools, retrieves context, follows guardrails, and works across sub-agents.
- Other tools provide borderer automation, for example, n8n is primarily about wiring APIs or workflows.
AgentKit hosting: Agent Kit runs on OpenAI’s cloud infrastructure, and agents and their workflows are hosted and managed by OpenAI.
About make
make enables you to create structured, multi-step AI workflows that mimic agent behavior.
Unlike n8n, where you can write custom logic directly in JavaScript or Python and even create your own nodes, Make relies entirely on predefined modules. Each module acts like a tool or function an agent might use, and you’re limited to what these modules or the HTTP and webhook tools provide.
Creating webhooks in make
AI agent & RAG template examples in make:
- Automate lead qualification with AI agents
- Build a lead generation automation using AI agents
- Build an AI email assistant
- Create an auto-email organizer
make hosting: Make is a cloud-based, SaaS-only platform; you run automations (scenarios) via Make’s servers; it does not offer a self-hosted or on-premise version.
Scenarios: In Make, automations are called scenarios. They are built by linking modules together, often with API calls via the HTTP module or triggers through webhooks. Unlike n8n workflows, scenarios do not include custom code nodes you can extend with JavaScript or Python. Instead, you work within Make’s expression language for transformations.
Scenarios in make
Make does not support full scripting because it limits logic to its expression language and modules. There is no code node, no ability to import external libraries, and complex logic must be handled indirectly through connectors or HTTP calls. In contrast, n8n lets you drop into JavaScript or Python.
About Zapier
Zapier is primarily designed for non-technical users who want to automate tasks between web apps. It’s most useful when you need to connect two SaaS tools quickly without writing any code.
It offers a visual interface and supports over 8,000 app integrations, including Google Workspace, Slack, Notion. It also features ready-made Zapier Agent Templates and AI agent templates:
Zaps: Each workflow in Zapier, called a Zap, follows a linear structure with a single trigger and one or more actions.
This setup works well for simple data synchronization or notification tasks but becomes limiting when building complex logic.
Adding action steps (PDF filter) to my Zap
Zapier hosting: Zapier is a cloud-based, SaaS-only platform. All automations (called Zaps) run on Zapier’s managed infrastructure.
Pricing comparison
Cost modeling for individual and team plans
Cost modeling for enterprise plans
Key highlights:
- n8n: Charges per workflow execution: one run counts as a single execution, no matter how many nodes it includes.
- Agentkit: Cost is tied to API/model usage: you pay for tokens and any used tools per OpenAI’s rates; there is no separate charge for AgentKit itself.
- make: Charges per operation: each module in a scenario (Make’s term for a workflow) counts as one operation.
- Zapier: Charges per task: each action step after the trigger counts as one task.
For example, if a workflow has 10 nodes:
- make and Zapier would count that as 10 operations or tasks each time it runs.
- n8n would count it as one execution, regardless of the number of nodes it includes.
However, n8n’s pricing can be a bit confusing: even though operations aren’t counted individually, each plan still has a limit on the total number of executions (for example, 2,500 per month on the free tier).
n8n
n8n pricing: n8n provides both self-hosted and cloud-hosted options. Both can run on your own infrastructure using Docker or Docker Compose.
The Community edition lacks a few enterprise-level features, including SSO, access controls, and global variables. Some of these missing features can be replaced by community-built nodes; for example, the n8n-nodes-globals package offers an alternative to global custom variables.
As of August 2025, n8n has removed active workflow limits across all its cloud plans, meaning you can have unlimited workflows, steps, and users in each plan. 1
AgentKit
AgentKit pricing: Cost is tied to API/model usage: you pay for tokens and any used tools per OpenAI’s rates; there is no separate charge for AgentKit.
make
make pricing: make uses an operation-based pricing model:
That means even a moderate workflow can burn through your free quota fast. Suppose you build a daily AI agent that runs 3 times a day and uses 5 modules (e.g. fetch news, filter, call OpenAI, format result, send email). That’s 5 operations × 3 runs = 15 operations per day. Over 30 days, that’s ~450 operations.
- Free plan: includes 1,000 operations per month and allows up to 2 active scenarios.
- Paid plans: start at $9/month for 10,000 operations.
Because make bills per operation, workflows with more nodes or more frequent runs become costly.
Zapier
Zapier pricing: Zapier charges based on the number of tasks performed by its Zaps. A task corresponds to each data element processed by an action step in the workflow. For example, if a Zap adds one row to a Google Sheet, that counts as one task.
- Free plan: 100 tasks/month and 5 Zaps (workflows).
- Paid plans: Start at $19.99/month for 750 tasks/month.
Note that when you exceed your task limit, Zapier switches to pay-per-task billing at a higher rate to keep your Zaps running.
AI agent pricing: Zapier also offers AI agents as part of its AI orchestration package. These plans allow you to create AI-powered chatbots and agents. Free plan includes 400 activities/month.
Our user experience with n8n, OpenAI Agent Kit, make, and Zapier
In this analysis, we compare how n8n, AgentKit, Make, and Zapier approach AI agent development specifically, what tools they offer for agent logic, branching, AI automation. We focused on highlighting each platform’s distinct features.
AI agent development tools
n8n
AI agent node: n8n has a dedicated AI Agent node that enables you to build autonomous, multi-step agents directly within a workflow. The node can:
- Connect to LLMs like OpenAI, Claude, or Hugging Face
- Maintain context and memory across runs
- Dynamically decide which “tools” (other workflow nodes) to use
AgentKit offers a visual agent builder that also supports memory, tool usage, agent delegation, and logic control (e.g. If, While), but is more focused on declarative, agentic workflows than broad automation.
make doesn’t have an equivalent “AI agent” framework.
Zapier has AI Agents (beta), but they operate through a natural-language interface rather than within the automation builder.
At a glance, the workflow is composed of the following nodes:
Code inside workflows: One of the most useful aspects of n8n is that it lets you bring real code into automations. JavaScript is available in many places, including input fields, expressions and dedicated code nodes.
This means you can use familiar functions like JSON.stringify without needing to learn a new syntax or special functions like in Make. Python is also supported through the Code node using Pyodide, which is helpful if you prefer Python, although its use is more limited compared to JavaScript.
JSON.stringify can be put right into any input for n8n
Triggers: n8n offers native triggers for app events, chat, webhooks, schedules, sub-workflows, etc. It can trigger agents contextually from nearly any source.
External npm packages: If you self-host n8n, you can run external npm packages inside the JavaScript Code node. This gives developers the freedom to pull in any library they need directly in a workflow. On n8n Cloud, this feature is not available (at least as of September 2025), and neither Make nor Zapier allows the use of external packages.
Workflow architecture: Supports multiple triggers per workflow, flexible conditional branching, and dedicated error workflows for retries or fallbacks.
I built a workflow architecture that you can see below:
- Multiple triggers: the workflow can start manually with the “Execute workflow” button or run automatically every morning at 7 AM.
- Flexible branching: one branch collects tech news, the other collects world news, and both are merged into the AI step.
- Dedicated error workflows: if the OpenAI node fails, I can route the error into a separate workflow to retry or send myself an alert.
DevOps & version control: On Business/Enterprise tiers, n8n integrates with Git, enabling workflows as code with versioning, rollbacks, and team collaboration.
AgentKit
Agent tools: AgentKit includes native tools like web search, file search, and MCP server integrations (e.g., Gmail, Google Calendar). These are easy to use but limited in number and scope. It doesn’t yet offer broad API coverage or deep customization for agent workflows.
In contrast, n8n supports more integrations than AgentKit does (over 500 native integrations, custom HTTP requests, and modular sub-workflows).
Make and Zapier also offer broader app integrations and easier setup, but are less focused on agentic logic.
Evaluation tools: AgentKit also provides evaluation tools, including automated grading, prompt optimization, and performance tracking across runs. These features help developers iterate and improve agent behavior systematically. n8n, Make, and Zapier offer no native equivalent for agent evaluation.
- Automated grading:
- Prompt optimizer:
- Agent trace grading:
Model support: AgentKit is tightly integrated with OpenAI’s models (e.g., GPT‑5) and allows basic parameter tuning (reasoning effort, verbosity). It’s streamlined but limited to OpenAI’s model ecosystem.
n8n supports OpenAI, Anthropic, Google, Cohere, open-source models via OpenRouter, and even self-hosted LLMs.
Natural-language setup / prompt assistant: Like Zapier, AgentKit allows users to configure agents through a no-code interface, and when setting up an agent node in the canvas, users can input instructions in natural language to guide the agent’s behavior.
However, it does not currently include a full prompt-crafting assistant with auto-validation, testing feedback, or live prompt grading.
Widget system: AgentKit includes a built-in widget system (ChatKit) that allows users to embed chat agents into websites or apps.
For example, HubSpot uses ChatKit to deploy a live AI-powered customer support agent:
Source: OpenAI2
make
Native Chrome DevTool integration: Make is the only platform that offers a dedicated Chrome Developer Tools panel for debugging workflows directly in the browser. The Make DevTool extension adds a new tab inside Chrome DevTools where you can watch your scenarios run in real time and inspect what’s happening behind the scenes.
Chrome Developer Tools panel
Live stream view: When you click Run once in a scenario, the Live Stream view shows:
- All API requests and responses between Make and connected apps
- Request headers, payloads, and timestamps
- Which module succeeded or failed
This level of visibility makes it much easier to understand how your AI workflow performs. You can trace every API call, inspect prompts and responses, and debug how data moves between model calls in real time.
Scenario debugger:
The scenario debugger provides a history of workflow runs, letting you:
- Search by module name or ID
- Jump directly to any failed step
- Open module settings from within the debugger
In comparison, n8n keeps execution logs within its own workflow UI, while Zapier only exposes high-level task logs that lack detailed request and response data.
I find make’s debugger approach more transparent. When an agent flow fails, you can identify the exact module, inspect the full payload, and understand why it broke
Developer utilities: The DevTool also includes a set of features that make editing and maintaining workflows faster:
- Copy or swap mappings, filters, and connections
- Retrieve app metadata or version info
- Highlight modules in large scenarios
- Remap data sources or duplicate connections
When you’re building complex, multi-step AI automations involving several APIs or model calls, these utilities make Make feel much closer to a developer environment than a simple no-code builder.
Zapier
Natural-language setup / prompt assistant: Less manual coding, more prompting: Unlike n8n where you write explicit JavaScript/Python logic, Zapier’s AI agents lean heavily on prompt instructions rather than granular code control.
You can define agent behavior by writing instructions in plain English, often guided by a “prompt assistant” tool that helps you craft effective instructions.
Here’s a calendar summary AI Agent I created in Zapier using natural language:
You can use Code by Zapier for small custom logic or light data manipulation within a Zap.
Zapier includes a built-in free feature called Code by Zapier, which lets users insert short JavaScript or Python snippets inside their Zaps, which is for small custom logic or light data manipulation within a Zap. These code steps can be used either as a trigger or an action to process data, make API calls.
However, these scripts run under strict limits:
- 30-second execution time
- 256 MB memory cap
- No external npm or Python libraries
- 250-item output limit
AI code generator: Zapier also features an AI code generator. Inside the Zap editor, you can describe in plain language what you want your code to do (e.g., “convert a date to YYYY-MM-DD format” or “remove @mentions from Slack messages”).
Note that n8n and make do not currently offer an AI code generator feature as of October 2025.
If you want to connect to external APIs (e.g., call OpenAI, Notion, or a private endpoint), you’ll need Webhooks by Zapier or a paid plan that allows it.
Limited transparency in decision logic: Because agent behavior is derived from prompt + tool mapping, it’s harder to predict exactly why a certain tool was chosen or how decisions branch internally.
When things go wrong, you can’t “step through” the logic like in n8n or Make. Instead, you have to check Zapier’s activity logs or traces, which show what the agent decided to do, which tool it called.
Branching and conditional logic
n8n
n8n is the best choice for building context-aware AI agents that need to reason, branch, and interact with multiple tools in a single workflow.
It enables you design flows where an agent can evaluate a condition, run different actions based on the outcome, and merge everything back together.
You can use IF, Switch, and Merge nodes to handle decisions, and Loop or Split Out nodes to process multiple data items or iterate through results from APIs or model outputs.
This structure makes it possible to build logic like:
“If the model detects sentiment = negative, summarize and send to Slack; otherwise, store in the CRM and move on.”
Here’s a visual example showing the IF, Switch, and Merge nodes
- The IF and Merge node:
- The Switch node:
AgentKit
AgentKit offers basic branching and control flow logic through its visual builder, but with more limited flexibility compared to n8n or make. Most decisions in AgentKit still rely heavily on the agent’s internal reasoning via prompts and tools.
You can still use built-in logic nodes like If, Else, to create simple conditional paths. However, you won’t find nodes like Switch, Merge, or Loop iterators as you do in n8n.
make
make’s visual logic system sits somewhere between Zapier’s simplicity and n8n’s developer flexibility.
You can design branching workflows using routers and filters, allowing different paths to run depending on data conditions. Each branch can trigger specific modules, call APIs, or interact with AI models.
Setting up a filter after the overdue invoice recovery scenario’s trigger module, this lets the rest of the scenario run only if there are overdue invoices that need following up on.
Adding a router module to branch the scenario. This enables to processing of completely different workflow sequences for different situations.
You can also create loops, call sub-scenarios, or re-run parts of the flow until a condition is met, giving the system a pseudo-“reasoning” capability.
Zapier
Zapier isn’t the best fit for building multi-step AI agents that need to think, decide, or loop through actions.
It works great for parallel workflows, things like “generate text with OpenAI and send it to Slack”.
Below is an example of such a parallel setup, where multiple independent actions run side by side:
The branching feature (“Paths”) helps a bit to introduce conditional logic into workflows, but it’s locked behind higher-tier plans.
Source: Zapier3
AI automation
n8n
n8n allows you to build true AI agent systems rather than just simple AI calls. The AI agent tool node lets you create multiple collaborating agents in one workflow. For example, a researcher, an analyzer, and a writer, all orchestrated by a controller agent.
You can connect any LLM or vector database, define memory, run evaluations to benchmark prompt quality, and combine agentic reasoning with traditional logic using IF, Switch, or Code nodes. This makes it possible to design AI agents that think, decide, and act predictably within defined rules.
Because every step is visible on the workflow canvas, you can trace each agent’s decision path and integrate deterministic fallbacks or human approval steps, which is crucial when running AI in production.
AgentKit
AgentKit is purpose-built for agentic workflows, with native support for multi-agent reasoning, session memory, tool use, and structured logic (e.g., If, While, Set State). Each agent can run with its own instructions and memory scope. It also includes built-in evaluation tools for grading and optimization.
However, integration with external systems is limited, and control (like retries, branching, or vector databases) often requires pairing with tools like n8n.
make
Make can simulate AI agent workflows using modules and routers to build branching, multi-step logic. You can connect OpenAI or Anthropic APIs, add decision routes, and loop results for refinement.
While Make doesn’t have a dedicated AI agent framework, it’s flexible enough to create tool-using agents through chained modules and API calls. However, there’s no built-in memory or context persistence, so long-term reasoning or iterative loops require workarounds with variables or HTTP callbacks.
Still, for building task-oriented AI workflows that analyze, summarize, or act based on data, Make’s visual interface makes it efficient and intuitive.
Zapier
Zapier’s AI automation focuses on simplicity. You can connect OpenAI or Claude to create basic workflows like “analyze message → draft email → send reply.”
Its new AI Agents (in beta) let you describe behavior in natural language and link the agent to Zapier’s ecosystem of 7,000+ apps. However, these agents still operate on top of Zapier’s linear task-based system, without true branching, feedback loops, or shared memory.
That makes Zapier suitable for single-agent, prompt-response workflows, but not for autonomous, reasoning-based agent networks.
What is a low/no-code AI agent builder?
A no-code or low-code AI agent builder is a platform that allows users to create, deploy, and manage such agents without needing to write traditional code. Coding is usually optional or simplified, making these platforms more accessible.
Most no/low-code builders use visual interfaces, such as drag-and-drop editors or flowchart-style UIs. Others rely on prompt-based setup, where you describe an agent’s behavior in natural language, and the system handles the rest.
These tools come pre-configured with reusable components, like triggers, logic, and integrations. So, users can focus on assembling workflows rather than developing them from scratch.
While some platforms give developers the flexibility to add custom code for complex tasks, others prioritize simplicity for non-technical users.
Benchmark evaluation rubric
1. Ease of use (0–10)
Scoring rubric:
- Drag-and-drop interface (+3)
- Templates for agents (+2)
- Natural-language setup / prompt assist (+2)
- No-code tool configuration (+2)
Scores:
- n8n (8): Drag-and-drop UI (+3), templates available (+2), some no-code config (+2), no native prompt assistant (0).
- AgentKit (9): Drag-and-drop UI (+3), native natural-language prompt setup (+2), no-code config (+2), limited templates (0).
- Make (7): Drag-and-drop UI (+3), templates available (+2), no-code config (+2), lacks prompt setup (0).
- Zapier (8): Drag-and-drop UI (+3), no-code config (+2), very simple interface (+2), lacks prompt assist and templates (0).
2. Triggers (0–10)
Scoring rubric:
- Scheduled triggers (+2)
- App event triggers (+2)
- Webhook support (+2)
- Multi-channel routing (+2)
- API/SDK trigger support (+2)
Scores:
- n8n (10): Scheduled (+2), app event (+2), webhook (+2), multi-channel routing (+2), API/SDK (+2).
- AgentKit (6): Webhook support (+2), API trigger support (+2), lacks scheduled (+0), app triggers (+0), multi-channel routing (+0).
- Make (10): Supports all five: scheduled (+2), app event (+2), webhook (+2), multi-channel (+2), API (+2).
- Zapier (8): Scheduled (+2), app event (+2), webhook (+2), API (+2), lacks multi-channel routing (0).
3. Agent tools & orchestration (0–10)
Scoring rubric:
- Native multi-agent orchestration (+3)
- Agent-to-agent communication (+2)
- Structured tool calling (+2)
- Agent memory/state (+2)
- Reasoning config (verbosity, tool logic) (+1)
Scores:
- n8n (10): AI Agent Tool (+3), agent-to-agent interaction (+2), tool calling (+2), memory (+2), reasoning config (+1).
- AgentKit (7): Delegation (+2), structured tools (+2), memory/state (+2), reasoning config (+1), lacks full multi-agent orchestration (0).
- Make (5): Module chaining (+2), tool calling via HTTP (+2), limited orchestration (+1), no memory or reasoning config (0).
- Zapier (4): Prompt steps (+1), tool calls via OpenAI steps (+2), minimal control (+1), no memory/orchestration (0).
4. Model support (0–10)
Scoring rubric:
- Multiple model providers (OpenAI, Claude, etc.) (+2)
- Self-hosted or local model use (+2)
- Config options (temperature, etc.) (+2)
- Support via OpenRouter or plugins (+2)
- Native chat interface node (+2)
Scores:
- n8n (10): Multi-provider (+2), self-hosted (+2), OpenRouter (+2), config options (+2), native chat node (+2).
- AgentKit (6): OpenAI models only (0), config options (+2), chat interface builder (+2), limited extensibility (+2).
- Make (6): OpenAI/Anthropic via API (+2), config options (+2), chat UI (+2), no OpenRouter/local models (0).
- Zapier (5): OpenAI/Claude (+2), basic config options (+1), LLM integrations (+1), optional memory step (+1).
5. Evaluation tools (0–10)
Scoring rubric:
- Built-in prompt grading (+2)
- Performance logging (+2)
- Step-by-step tracing (+2)
- Dataset testing (+2)
- Prompt optimization tools (+2)
Scores:
- n8n (4): Execution tracing (+2), performance logs (+2), no prompt grading/optimization/testing (0).
- AgentKit (10): Prompt grading (+2), performance dashboard (+2), trace view (+2), dataset testing (+2), optimization tools (+2).
- Make (1): Execution logs (+1), no grading, tracing, or optimization (0).
- Zapier (1): Basic logs (+1), no evaluation tools (0).
6. Extensibility & integrations (0–10)
Scoring rubric:
- 500+ native integrations (+2)
- HTTP/API request support (+3)
- Webhook support (+2)
- SDK/plugin system (+2)
- (300–499 = +1 if <500)
Scores:
- n8n (10): 500+ apps (+2), HTTP node (+3), webhooks (+2), plugin/modules (+2), SDKs (+1).
- AgentKit (4): MCP server integrations (+1), webhook/API support (+2), limited extensibility (+1), no SDK/plugins (0).
- Make (9): 1000+ apps (+2), HTTP modules (+3), webhooks (+2), plugins (+2).
- Zapier (9): 7000+ apps (+2), HTTP (+1), webhooks (+2), plugins/app builder (+2), SDKs (+2).
7. UI / chat components (0–10)
Scoring rubric:
- Custom embeddable widget (+3)
- Chat memory/state support (+2)
- UI components / ChatKit framework (+3)
- Multi-agent UI support (+2)
Scores:
- n8n (5): Community plugins (+1), state via nodes (+2), partial multi-agent UI (+2), no native widget/framework (0).
- AgentKit (9): ChatKit widget (+3), memory (+2), UI framework (+3), partial multi-agent interface (+1).
- Make (4): Basic UI (+1), memory via variables (+1), routing logic (+2), no widget/system (0).
- Zapier (3): Prompt steps (+2), basic task flows (+1), no memory/widget/UI components (0).
8. Data control / deployment (0–10)
Scoring rubric:
- Self-hosting (+4)
- Observability/logging (+2)
- No vendor lock-in (+2)
- Bring-your-own LLM (+2)
Scores:
- n8n (10): Self-hosting (+4), full logging (+2), BYO LLM (+2), no vendor lock-in (+2).
- AgentKit (4): Docker-based local support (+2), basic logs (+1), limited control (+1), OpenAI-locked models (0).
- Make (5): API control (+2), logging (+2), partial flexibility (+1), cloud-only (0).
- Zapier (3): Webhook observability (+2), limited logging (+1), cloud-only, no BYO LLM or control (0).
Reference Links
Cem's work has been cited by leading global publications including Business Insider, Forbes, Washington Post, global firms like Deloitte, HPE and NGOs like World Economic Forum and supranational organizations like European Commission. You can see more reputable companies and resources that referenced AIMultiple.
Throughout his career, Cem served as a tech consultant, tech buyer and tech entrepreneur. He advised enterprises on their technology decisions at McKinsey & Company and Altman Solon for more than a decade. He also published a McKinsey report on digitalization.
He led technology strategy and procurement of a telco while reporting to the CEO. He has also led commercial growth of deep tech company Hypatos that reached a 7 digit annual recurring revenue and a 9 digit valuation from 0 within 2 years. Cem's work in Hypatos was covered by leading technology publications like TechCrunch and Business Insider.
Cem regularly speaks at international technology conferences. He graduated from Bogazici University as a computer engineer and holds an MBA from Columbia Business School.
Be the first to comment
Your email address will not be published. All fields are required.