How Many AI Engineers Do You Need? Sizing by Project Type
How many AI engineers do you need for your project? Learn how to size your AI engineering team for LLMs, RAG, AI agents, and fine-tuning.

How many AI engineers do I need for my project? For most first production builds, two to six people at peak: two or three for an LLM feature inside an existing product, three to five for a RAG assistant or a single agent, and five to eight for multi-agent workflows or fine-tuning work. Fewer during discovery, fewer again once it runs.
Those ranges are our editorial guidance, drawn from how these projects are typically scoped. They are not an industry benchmark, and no published study sizes AI teams this precisely. Use them as a starting point you adjust with the drivers below. The count is people at peak build, across all seats (not just people with "AI" in their title), and it excludes the product owner and domain expert who should sit on your side. More on staffing and running these teams is in our AI Pods & Engineering Teams guides.
How many people does each type of AI project need?
| Project type | Peak headcount (editorial guidance) | Seats you usually can't merge | Where person number N+1 usually goes | Sign you under-sized it |
|---|---|---|---|---|
| LLM feature in an existing product (summarize, draft, classify, extract) | 2–3 | AI engineer; product engineer who owns the integration | A part-time tech lead to own evals and review | Demo works, but nobody owns the test set or the fallback when the model is wrong |
| RAG assistant over internal documents | 3–5 | AI engineer; data engineer; product engineer | A second data engineer when sources are messy, scanned or permissioned | Answers come from stale or unauthorized documents |
| Single agent with tools (reads and writes to a few systems) | 3–5 | Tech lead; AI engineer; product engineer (or integration engineer) | An engineer for each extra system the agent must act on safely | Tool calls fail silently; no audit trail of what the agent did |
| Multi-agent or cross-system workflow | 5–8, often split into two teams | Tech lead; two AI engineers; data engineer; MLOps/LLMOps | MLOps capacity for tracing, cost limits and replay | Nobody can explain why a run failed or what it cost |
| Fine-tuning or ML platform (custom models, training pipelines, serving) | 5–8 | Tech lead; ML engineer; data engineer; MLOps engineer | A data engineer for labeling and dataset versioning | Each retrain is a one-off; results can't be reproduced |
Two notes on reading the table. First, the numbers are people, not roles: one senior engineer can hold two seats on a small scope. Second, a project rarely stays in one row. Many RAG assistants grow tools and become agents, and that is when the headcount question comes back.
Why does project type change the headcount so much?
The model call is the cheapest part of the system to build. What scales headcount is everything around it: data, integrations, evaluation and operations.
LLM features are small because the surrounding system already exists. Your product has auth, a UI, logging and deployment. In its December 2024 guide "Building effective agents," Anthropic advises "finding the simplest solution possible, and only increasing complexity when needed," and notes that for many applications, "optimizing single LLM calls with retrieval and in-context examples is usually enough." If that describes your project, two or three people is honest sizing.
RAG assistants add a data problem. Retrieval quality depends on parsing, chunking, freshness and permissions, which is why the data engineer becomes a seat you can't skip. Whether you need retrieval at all, or fine-tuning, is its own decision; see when to fine-tune, when to use RAG, and when to do neither.
Agents add integration and safety work. Every system an agent can write to needs a tool definition, permissions, error handling and an audit trail. Anthropic's same guide distinguishes workflows, "orchestrated through predefined code paths," from agents, which "dynamically direct their own processes and tool usage." The second kind needs more engineering around it, not less. The architecture work is covered in how to build a production AI agent.
Multi-agent systems add operational weight. In its June 2025 write-up of its multi-agent research system, Anthropic reports that agents "typically use about 4× more tokens than chat interactions," and multi-agent systems "about 15× more tokens than chats." It also notes that agents are "non-deterministic between runs, even with identical prompts," which makes debugging harder, and that "the last mile often becomes most of the journey." That is why MLOps or LLMOps capacity is a named seat in this row, not an afterthought.
Fine-tuning and ML platforms add pipelines. Google researchers made the point in "Hidden Technical Debt in Machine Learning Systems" (NIPS 2015): "Only a small fraction of real-world ML systems is composed of the ML code." Training data, feature pipelines, serving and monitoring take the rest. Even on a hosted fine-tuning API, OpenAI's supervised fine-tuning guide says "Good evals first! Only invest in fine-tuning after setting up evals," so someone must own the eval set before anyone trains anything.
How does headcount change by phase?
A team that is the right size for build is the wrong size for discovery. The table below shows full-time-equivalent (FTE) headcount by phase. Again, these are editorial ranges, not benchmarks.
| Phase | LLM feature | RAG assistant | Single agent | Multi-agent / workflow | Fine-tuning / ML platform |
|---|---|---|---|---|---|
| Discovery (use case, data audit, eval set, baseline) | 1–2 | 2 | 2 | 2–3 | 2–3 |
| Build (iterate against evals, integrate) | 2–3 | 3–5 | 3–5 | 5–8 | 5–8 |
| Hardening (guardrails, monitoring, handover) | 2 | 3 | 3–4 | 4–6 | 4–6 |
| Run (after launch) | 0.5–1 | 1 | 1 | 1–2 | 1–2 |
Discovery is lead-heavy: a technical lead and whoever can audit the data. Build is maker-heavy. Hardening shifts toward operations and safety. Which seats carry the load in each phase is covered in the six roles inside an AI engineering pod, so we won't repeat it here; that guide is also the answer to "what roles are in an AI pod?"
The "Run" column matters for planning. If nobody on your side can absorb that last row, you either keep the outside team on a smaller retainer or you hire before handover.
What pushes the number up or down?
Start from the range for your project type, then adjust.
Drivers that push headcount up:
- Number of systems touched. Each system the AI reads from or writes to adds integration, permission and test work. This is the most reliable single driver.
- Messy or restricted data. Scanned PDFs, many source systems, row-level permissions or data that can't leave a region all add data engineering time.
- Regulated output. Healthcare, finance and legal use cases need audit trails, human review screens and documented evals, which adds hardening work.
- Write access. An agent that can send, approve or change records needs more guardrail and testing effort than one that only answers questions.
- Hard deadline with parallel workstreams. Two genuinely separate workstreams (say, a document pipeline and a reviewer UI) can justify a bigger team. One workstream with a deadline usually can't; see the next section.
Drivers that pull headcount down:
- A hosted model API instead of self-hosting. Removes most serving and GPU operations work.
- Existing platform engineering. If your team already runs CI/CD, observability and auth, the AI team doesn't rebuild them.
- One narrow, measurable use case. A single workflow with a clear success metric is smaller than "an AI assistant for the company."
- An engaged domain expert on your side. Fast answers about what "correct" looks like shorten every eval cycle.
- Senior people. One engineer who can design and build covers two seats; two juniors rarely cover one.
Why not just add more AI engineers to go faster?
Because past a point, more people make the project slower. Fred Brooks put it in The Mythical Man-Month (1975) as what is now called Brooks's law: "Adding manpower to a late software project makes it later."
His reasoning still applies to AI work. In the essay that gives the book its title, Brooks shows that if every part of a task must be coordinated with every other part, intercommunication effort grows as n(n-1)/2. Four people have 6 communication paths; eight people have 28. New joiners also need ramp-up time, and the people training them are usually your most productive engineers.
Two qualifications keep the law useful rather than fatalistic:
- It is about late projects. Staffing correctly at the start of build is different from adding people in a panic halfway through.
- Partitionable work scales; tangled work doesn't. Brooks contrasted tasks that can be split among workers with no communication against tasks with sequential constraints. AI projects are mostly the second kind: prompts, retrieval and evals interact, so a change in one place moves scores everywhere.
The practical answer for big scopes is to split, not grow. Two teams of four with a clean interface between them (say, a data platform team and an agent team) coordinate far better than one team of eight. How teams like that fit into a wider organization is covered in our guide to AI team structure and roles.
A five-step way to size your own project
- Pick the row. Classify the project by the table above, using the most complex part of the scope.
- List the seats, then merge. Write down every seat you need, then merge only where one senior person can genuinely hold both. Don't merge the person who builds with the person who evaluates.
- Count systems and data sources. Add capacity for each system the AI writes to and for any data that is scanned, scattered or permissioned.
- Phase it. Plan a smaller discovery team, scale for build, and decide now who owns the "Run" row.
- Check against Brooks. If the total goes above eight, look for a split into two teams before you add more people to one.
If you plan to fill these seats with your own hires, our guide on how to hire AI engineers covers screening and red flags. If you're unsure which specialist to hire first, see our comparison of LLM, RAG and MLOps engineers. Other options are to bring in an outside team through team augmentation or a dedicated pod.
How fwdpod approaches this
Fwdpod builds dedicated AI engineering pods for startups and enterprises, covering LLM development, RAG systems, AI agents and product delivery, with engineering delivery from India for buyers in the US, UK, EU and the Gulf. Fwdpod describes its pods as 4–6 experts working around a single measurable outcome, which maps to the middle rows of the table above. Pod templates include Voice AI, Agentic Operations, RAG and Knowledge, Compliance AI and Custom, with engagements ranging from 8 to 16 weeks. How a pod's headcount would map to discovery, build and hardening on your project is something the team can walk you through on a first call. To see how a pod would be sized for your project, read about our AI engineering pods, configure your AI engineering pod by answering five questions to get a custom pod proposal within 48 hours, or talk to the team, including for pricing.
Key takeaways
- Editorial guidance: 2–3 people for an LLM feature, 3–5 for a RAG assistant or single agent, 5–8 for multi-agent workflows or fine-tuning and ML platforms.
- Headcount follows systems, data and operations, not the model call.
- Size by phase: small discovery, peak build, a smaller hardening team, and a named owner for the run phase.
- Number of systems touched, data quality, regulation and write access push headcount up; hosted APIs, existing platform engineering and senior people pull it down.
- Brooks's law applies: past about eight people, split into two teams rather than growing one.
Frequently Asked Questions
1. Can one AI engineer build a production AI feature alone?
Sometimes, for a narrow feature on a hosted model API inside a product that already has strong backend, deployment and monitoring. Even then, someone else should review the evals and own the product integration. A single person building, judging and operating the system is a risk, not a saving.
2. How many AI engineers does a startup need for its first AI product?
Usually two or three to start: one engineer focused on model behavior and evals, one product or full-stack engineer integrating it, and a senior person who can make design decisions, possibly part-time. Add data engineering when the product depends on your own documents or records.
3. Do I need a data scientist on my AI project?
Not for most projects built on hosted language models. A data scientist earns a seat when you train or fine-tune your own models, run statistical experiments, or build classic prediction systems such as forecasting or risk scoring.
4. Should I hire AI engineers or use an outside team for the first project?
It depends on whether the work is ongoing. A first project with an uncertain scope often suits an outside team, because the headcount changes sharply between discovery, build and run. If AI will be core to your product for years, plan to hire, and use the first project to learn which seats you actually need.
5. How do I know my AI team is too big?
Watch for engineers waiting on each other, meetings growing faster than shipped changes, and eval scores that move without anyone being able to explain why. If two people regularly change the same prompts or retrieval logic, the team has outgrown a single workstream and should be split or trimmed.
6. How many people does it take to maintain an AI system after launch?
For most single-use-case systems, about one engineer's worth of time, often shared across several systems, to watch quality, cost and provider changes and to update evals. Multi-agent systems and self-hosted models need more, because tracing, retraining and serving don't run themselves.


