AI Teammates are agentic AI on Amazon Bedrock, and few engineering organizations run them in manufacturing on the scale that monday.com does. 9 in ten Builders use AI coding instruments each month, up from roughly half a yr in the past. Per-engineer PR throughput is up by greater than half. Each determine on this submit comes from monday’s personal inner manufacturing information.
On this submit, we share the structure behind these numbers, the retrofits that made it work in a decade-old code base, and the confidence-scored merge play closing the hole to full autonomy.
This isn’t a greenfield
monday.com is a decade-old code base, hundreds of thousands of paying customers, lots of of microfrontends and microservices, lots of of Builders (Engineers, PMs, Analysts, and Product designers). Each PR an agent opens goes right into a system hundreds of thousands of customers anticipate to maintain working by way of the following deploy. Greenfield demos are simple. Working brokers inside an enterprise SaaS with actual on-call, prospects, and compliance is the work.
Three ranges of AI engineering
You possibly can body the journey as three ranges:
- L1, the assistant. Engineers use AI as a pair programmer. Cursor for the quick reflexive work, Claude Code for the heavy lifts. Adoption has practically doubled yr over yr.
- L2, expertise and sub-agents. Groups construct reusable brokers for repeated work, engineers within the driver’s seat. That is the place most of monday runs at present, and the place per-developer PR throughput stepped up by greater than half.
- L3, multi-agent. Absolutely agentic. Brokers personal supply end-to-end whereas engineers orchestrate, taking duties from boards, speaking in Slack and monday, transport code alongside people.
Brokers are teammates, not jobs
Sphera is monday’s inner agent system. The very first thing you see isn’t a job queue, it’s a Groups web page: a mixture of people and brokers, every with a profile, a supervisor, a scope, and a efficiency rating. Atlas, the agent on the heart of this submit, is one among them: position: Software program Engineer. Job: choose up tickets, write the PR, ship the function. IDE: none. Identical backlog as everybody else.
This isn’t ornament, it’s the schema. Each agent has a steady identification that flows by way of Slack, GitHub, and monday, so a human tags, assigns, code-reviews, or deactivates them like every other teammate. The brokers that transfer the needle stay on actual groups, doing actual work, accountable for the consequence.
The structure
Right here is how the system matches collectively, from the inboxes an agent listens on to the AWS providers that carry every occasion.
Three inboxes, one agent
A monday-built agent has three first-class inboxes: a Slack @point out, a monday merchandise task, a GitHub PR evaluate request. All three hit the identical agent session, with the identical reminiscence and workspace on disk: three flavors of the identical occasion, identical queue, identical path. We don’t run three agent programs. We run one.
The structure in a single diagram
The seven AWS providers that we used are Amazon Easy Notification Service (Amazon SNS), Amazon Easy Queue Service (Amazon SQS), Amazon Elastic Kubernetes Service (Amazon EKS), Amazon Relational Database Service (Amazon RDS), Amazon ElastiCache, Amazon Elastic File System (Amazon EFS), and Amazon Easy Storage Service (Amazon S3). Alongside them, AWS Secrets and techniques Supervisor handles per-session secret administration. Amazon Bedrock handles mannequin calls, and monday-agent-sdk runs inside every agent runner pod.
Occasion path: From SNS to SQS to monday Builders CoWORK
Each exterior set off lands in SNS, which followers out to per-team SQS queues by matter and routing key. The monday Builders CoWORK, a set of SQS shoppers on EKS, pulls every message, resolves which agent owns it, and arms it to the precise agent runner pod.
Pub/sub plus queue provides us 4 issues we gained’t quit: retries and dead-letter queues out of the field, back-pressure when Amazon Bedrock throttles, sturdy replay (we re-run the final day of occasions towards a patched construct earlier than selling), and concurrent fan-out. If the Claude Agent SDK ships one thing higher on the runtime layer, we delete our model. The harness stays.
monday-agent-sdk: A skinny wrapper, on function
The Claude Agent SDK is the runtime. We wrap it for 3 causes:
- Supplier neutrality on the name website. Agent LLM calls route into an Amazon Bedrock mannequin endpoint.
- Chilly-start price. Agent runners ship with a heat
node_modulesand plugin caches, so the primary mannequin name goes out in often beneath a second. - We needed our personal harness. The runtime is turning into a commodity. The harness is the place our opinions stay: how an agent is evaluated, how plugins compose, the way it talks to Slack, monday, and GitHub, how its output is reviewed towards monday requirements. We hold the runtime another person’s downside and make the harness ours.
State, reminiscence, classes
Brokers have no less than three sorts of state. Placing all three in a single retailer prices you cash, latency, or correctness. The stay state transfer to Amazon ElastiCache. Present activity, run cursor, distributed lock, heartbeat, and the agent/human message log. Sub-millisecond reads, self-expiring keys. Amazon DynamoDB would work; ElastiCache is cheaper and quicker for this form of entry. Periods and reminiscence get saved in Amazon Elastic File System. Every energetic session is a listing on a shared filesystem:
/classes/<session-id>/
├── repos/ # checked-out workspace
├── secrets and techniques.json # encrypted per-session secrets and techniques
└── messages/ # chronological occasion log
/brokers/<agent-id>/
├── MEMORY.md # cross-session reminiscence
└── diary/2026-04-21.md # per-day journalTwo causes, not S3. First, the Claude Agent SDK and most plugins anticipate an actual POSIX filesystem (git, npm, file edits), which removes a complete class of “works in dev, breaks in employee” bugs. Second, when a run resumes on a unique EKS pod, that pod mounts the identical EFS path and picks up the place it left off.
Atlas’s day by day diary is an actual file. A redacted snippet:
# diary/2026-04-21.md
## In progress
- ENG-3491: rate-limit headers: confirm staging, then open PR
- ENG-3502: dependency bump: blocked on Guardrails security-boundary
rule, ready on standard-owner evaluate
## What I realized final session
- The accounts-api group information each new error code within the shared
registry BEFORE the PR opens. I did it in the identical PR final time
and bought reverted. Filed the registry replace first this time.That file is how Atlas resumes work the following morning. He reads it, remembers that the accounts-api group needs the errors-registry replace filed individually, and will get to work. Reminiscence is a file on a disk that multiple pod can mount.
Sturdy data go to S3. Last transcripts, snapshots, artifacts, and evals are keyed by session ID. EFS holds working reminiscence; S3 is the audit path.
Amazon Bedrock because the mannequin cloth
Amazon Bedrock is greater than a spot to get tokens. It’s the service that lets us run lots of of brokers with out dropping monitor of price, security, or capability. Most operational necessities for deploying brokers at scale are already options in Amazon Bedrock:
- Utility Inference Profiles route each mannequin name, so price monitoring and capability planning keep in a single place.
- One audit path for each mannequin name: when safety or a regulator asks what brokers despatched the place in a window, we now have one place to reply.
- Cross-Area failover when an AWS Area throttles. Agent code doesn’t discover.
- AWS PrivateLink endpoints hold mannequin visitors inside our digital personal cloud (VPC).
Working on EKS
The compute fleet is Amazon EKS, one pod per energetic agent session, mounting the agent’s EFS workspace. Crash isolation is per-session. Auto scaling is pushed by KEDA on common energetic classes throughout pods, measured utilizing Datadog. We run a single employee picture. Repos are cached on EFS and reused throughout classes. No service mesh, no orchestrator-of-orchestrators. EKS, SQS, and the cache layer carry the load.
5 retrofits that made all of it work
Structure is the ground. The next 5 retrofits are what made brokers helpful inside a decade-old code base. None are unique. All had been unobvious till we hit them:
Evals earlier than mannequin upgrades
“Seems high-quality” was the bar for Atlas’s early PRs. It broke as soon as quantity picked up. We added two eval layers: deterministic metrics (PRs merged, revert price, zero-touch merge price) per agent, and LLM-scored evals throughout 5 dimensions per PR: Intent & Resolution, Execution & Artifact, Completeness & Usefulness, Instruction & Boundary, Effectivity. Each feed again into the harness. Throughout successive variations of Atlas we modified no mannequin, no prompts, no human nudges, solely the evals, and scores moved throughout each dimension.
Reminiscence is a file, not a vector retailer
Session 1: Atlas constructed a function. Session 2: he had no thought Session 1 had occurred. We tried context-window stuffing and vector retrieval over previous transcripts. Each labored badly. What labored: a per-agent MEMORY.md and a diary/YYYY-MM-DD.md written at session finish, learn at session begin. Plain markdown, no embeddings, no recall scoring, no agentic-RAG ceremony.
Distant sandbox earlier than human evaluate
Atlas’s first dozen PRs handed native assessments and broke in CI. A monday-scale code base has dependencies that solely exist in actual environments: function flags, third-party providers, actual visitors. We gave Atlas a distant sandbox per session, and each PR auto-deploys to it. Checks, checks, and replayed manufacturing visitors run earlier than he asks for human evaluate: failure to repair to ship once more, no human within the loop.
PR Guardrails: Automated evaluate towards monday requirements
Atlas was transport extra, and human evaluate grew to become the bottleneck. We turned each monday engineering normal into an automatic reviewer: metrics tagging, feature-flag hygiene, Datadog utilization, safety boundaries, database and microservice conventions, check high quality, documentation. A subset are blocking. Every is wired to inner information by way of monday’s MCP servers, so the reviewer sees the identical context the standard-owner group would.
Each PR, agent- and human-authored alike, goes by way of Guardrails. At scale meaning tens of hundreds of PRs evaluated per thirty days and lots of of hundreds of normal checks executed. Roughly one in 5 PRs fails no less than one normal and will get bounced again, and human overrides run within the low single digits. The system manages the enforcement, not the human reviewer.
Builders CoWORK: monday boards because the shared state layer
The final failure mode was the most costly: brokers in silos opened PRs no group owned. We added the CoWORK workspace, the user-facing floor of the identical monday Builders CoWORK that routes occasions. An agent’s duties, standing, blockers, and handoffs now stay on the identical monday board because the group’s, so accountability stopped being a system downside: monday already solved it for people.
Brokers at work in a collaborative area
Brokers are co-workers you possibly can ask to share data or carry out duties, like several teammate
From one bottleneck to the following
By late Q1 2026 the bottleneck was now not code era however human evaluate: Guardrails caught what people used to catch, however each PR nonetheless waited on a human to approve. That wall was subsequent.
The primary of many: Morphex
Morphex is monday’s first totally autonomous engineering agent, working throughout the identical repo, CI pipeline, Guardrails, and revert protocols as each Builder. Nineteen of each twenty Morphex PRs merge robotically, not by skipping evaluate however by passing each gate, and an permitted PR ships to manufacturing with no human within the loop. It opens extra PRs a month than most engineers, and a rejected PR fails for a similar causes any engineer’s does: flaky assessments, ambiguous specs, unhandled edge circumstances.
That 19-in-20 price is a flooring, not a ceiling. The open query: what sign tells us, forward of time, which PRs are secure to merge with out a human.
The sign: A latest rigorous reduce
Throughout our high PR-generating brokers (no cherry-picking), the numbers break down cleanly: about three in ten PRs merged, roughly three-quarters of these with zero human edits, and a revert price within the low single digits. Round 1 / 4 of the PRs had been caught and declined by Guardrails earlier than reaching a human in any respect.
That final quantity issues most. Guardrails stopped 1 / 4 of agent PRs as a result of the system noticed they weren’t prepared, leaving a pre-filtered inhabitants of merges. A low-single-digit revert price on that inhabitants is the sign that confidence-based auto-merge is workable.
Confidence-scored computerized merging
The arrogance rating combines 4 indicators accessible the second the PR opens:
- Deterministic Guardrails consequence: each blocking normal should go.
- Per-agent eval trajectory: latest eval-score window for this model of the agent.
- Per-(agent × repo × change-class) historic revert price: near-zero reverts on dependency-bumps in a low-risk service is a unique image from the next revert price on monolith migrations.
- Sandbox consequence: inexperienced from retrofit 3 is critical, not adequate.
Above the brink, the PR merges robotically. Under it, it routes to a human with the precise failing sign known as out. That’s the L2 to L3 transition: not eradicating people, however eradicating people from the circumstances the place the system’s sign is powerful sufficient that including a human doesn’t enhance the end result. We’re driving one metric over the following two quarters: the fraction of merged agent PRs that ship with out a human reviewer, holding revert price flat or bettering.
AI engineering isn’t about creating excellent brokers. It’s about constructing suggestions loops that allow imperfect brokers be safely trusted whereas saving people time.
Trustworthy shut
Why we constructed it the monday approach
The worth isn’t the runtime, that’s solely a harness across the Claude Agent SDK. It lives in every little thing we’ve wired round it, and that wiring is monday by way of and thru:
- monday boards because the shared state layer: each agent’s duties, standing, and handoffs stay the place the remainder of the enterprise already appears.
- monday MCP servers because the substrate Guardrails and requirements plug into.
- monday’s auth and identification, so each agent has an actual Slack, GitHub, and monday consumer beneath the identical RBAC as any human.
- monday’s deploy pipeline so agent code ships by way of the identical CI/CD as each different Builder.
Brokers that share state, identification, and infrastructure with people don’t want a separate governance layer. The present one already applies. That makes the system auditable, reversible, and reliable by default, not by addition. A boilerplate system would have flattened all of that into another person’s mannequin.
Three issues we’d do otherwise
Evals ought to have been within the system on day one, not month 9. The rating raise Atlas bought from them was the headline consequence. We over-invested in vector shops earlier than realizing MEMORY.md on EFS was at all times the precise reply. And the primary CoWORK lived in a separate workspace that compelled people to context-switch to see what brokers had been doing. Shifting it onto monday boards ought to have been the primary choice, not a later correction.
Conclusion
We’re not open-sourcing monday-agent-sdk. The wrapper is small, and most of its worth is the harness, which is monday-specific in ways in which wouldn’t assist anybody else. What we’re sharing is the structure and the operational playbook, as a result of the trade strikes quicker when the groups working manufacturing brokers at scale are sincere about what’s working.
When you’re constructing brokers into your engineering groups, you’ll meet a lot of the identical partitions we now have, and we’ve already crossed them. Discuss to us: the monday AI Engineering group, or the Amazon Bedrock group, shall be completely satisfied to share our insights.
Study extra
Concerning the authors
