How Monday.com build their genAI Asisstent Managin +1B Tasks

Over +100% MoM in User Engagment

Ali Z.

𝄪

CEO @ aztela

Imagine assigning AI agents to real work — just like a teammate.
No new tools. No training required.

Just faster execution, fewer mistakes, and a team that never sleeps.

That’s what monday.com did.
They built a Digital Workforce — powered by GenAI agents — to manage over 1 billion work tasks per year.

And the best part? It’s not just a concept.
It’s shipping. It’s working. And they shared exactly how they built it.

Here’s what they did — and how you can do the same.

The problem:

monday.com powers workflows for thousands of teams — sales, marketing, ops, dev, support.
But scale introduced friction:

→ “Can AI actually do work — not just suggest?”
→ “Can I trust it with real boards and real data?”
→ “Will it break things?”

Early usage was high — but only in read-only mode.
The moment AI tried to change something, users froze.

The blocker wasn’t tech. It was trust.
So they designed for it — and adoption exploded.

The Digital Workforce

What they built:

A modular, multi-agent AI system
Embedded directly in monday’s Work OS
That works across:
→ Boards
→ Docs
→ Tasks
→ External sources

Users can:
→ Assign agents to tasks like teammates
→ Preview changes before anything updates
→ Undo or revise easily
→ Ask questions or get work done conversationally

Result?
100%+ month-over-month AI usage growth since launch.🛠️ How They Built It (Step-by-Step)

Step 1: Start with trust, not autonomy
→ They didn’t launch fully autonomous agents
→ Instead, built preview + undo as first-class features
→ Users could explore safely → adoption followed

Step 2: Use existing flows, not new UX
→ Agents work inside monday’s current workflows
→ No side panels. No AI tab.
→ Just assign an agent like a team member

Step 3: Modular agent architecture

Supervisor Agent: Routes tasks + manages flow
Data Retrieval Agent: Fetches from boards, docs, KB, web
Board Actions Agent: Executes updates and changes
Answer Composer Agent: Writes in the user’s preferred style

Each agent does one thing well.
Easier to scale. Easier to debug.

Step 4: Add fallbacks early
→ Most real user requests are unhandled at first
→ They built smart fallback flows:

Search help docs
Suggest self-serve steps
→ Avoids dead ends = better UX

Step 5: Eval is the IP
→ They built an internal evaluation framework
→ Tracks:

Accuracy
Hallucination rates
Undo usage
Conversion from preview → commit
→ This is their edge — not the model

Step 6: Control agent sprawl
→ Too many agents = compound hallucination
→ 90% x 90% x 90% = 73% accuracy
→ They tune agent chaining carefully to maintain output quality

Step 7: Build reusable workflows
→ One-off automation (e.g., earnings reports) aren’t scalable
→ They built dynamic orchestration
→ Reuse finite agents across infinite tasks
→ Just like human teams

What it Looks Like in Action: Example Workflow

Let’s say a user wants to update a board and generate a summary.

Here’s what happens under the hood:

User asks:

“Update the Q3 Marketing board with new leads and send me a summary for execs.”

Supervisor Agent:
→ Understands request
→ Splits into subtasks
→ Routes to right agents

Data Retrieval Agent:
→ Pulls latest lead data
→ Gets board status
→ Fetches docs if needed

Board Actions Agent:
→ Updates board
→ Assigns tasks
→ Logs the action

Answer Composer Agent:
→ Writes exec-friendly summary
→ Adapts tone to past user style

Preview Mode:
→ User sees full changes
→ Can approve, cancel, or revise
→ Built-in Undo option available

Memory Layer:
→ Stores preferences
→ Tracks user context for next time
→ Logs changes for traceability

All in one flow. All inside monday.
Feels like a teammate. Works like a machine.

TL;DR

Start small, but build trust
Let users preview. Build confidence before pushing automation.
Use preview, undo, and fallback
Guardrails matter more than the model.
Don’t add new UX — build into existing flows
Adoption is easier when AI lives where the user already works.
Modular agents scale better
One job per agent. Easier to improve.
Eval = the foundation
You can’t improve what you don’t measure.
Personalize output by user type
Executives don’t want the same answer as analysts.
Use supervisor agents to orchestrate
Think: traffic control, not just automation.
Limit agent chaining to avoid hallucination
Too many hops = risk.
Dynamic > Static — reuse your logic
Build general agents that plug into dynamic flows.
HITL isn’t optional — it’s your failsafe
Especially in high-stakes workflows.
Build memory from past tasks
Session-to-session memory increases usefulness over time.