A single LLM works well for isolated tasks, but struggles when a goal requires multiple coordinated steps over time. That's where multi-agent systems come in: an orchestrator (also an LLM) breaks the goal down into subtasks and assigns them to specialized agents, on a path that starts with Turing's question in the 1950s and arrives at today's generative models, open weight and closed weight alike.
What an LLM is, in plain words
An LLM — Large Language Model — is a software system trained on enormous amounts of text: billions of pages of books, articles, forum posts, source code, scientific documentation. During training, the system learns the statistical patterns of language — which words go together, how reasoning is structured, how to answer a question — until it develops an extraordinary ability: producing coherent, sensible text on virtually any topic.
It doesn't "think" in the human sense, has no consciousness or persistent memory — but the level of competence it picks up during training is such that the result looks, for all practical purposes, like genuine intelligence.
"Large Language Model" is exactly what it sounds like. The term weights refers to the billions of numeric parameters the system acquired during training — they're its "memory," know-how distilled into numbers from enormous amounts of text. When you talk to ChatGPT, Claude, or Gemini, you're interacting with an LLM.
Seventy years of research: from Turing to generative models
There's a common belief that artificial intelligence exploded out of nowhere in the last two or three years. It didn't. The theoretical foundations go back to the 1950s, when Alan Turing posed the question that would guide decades of research: "Can machines think?" From that point on, generations of researchers built it brick by brick.
The first symbolic AI programs emerge: systems built on rules hand-written by experts. They worked in very narrow domains and didn't learn from experience.
Machine Learning takes hold: instead of writing the rules by hand, you teach the machine to work them out on its own by analyzing examples. Email spam filters — the ones still sorting your inbox from the flood of promotions today — are one of machine learning's first mass successes.
Machine learning enters everyday life without anyone calling it that. Netflix, Spotify, and Amazon's recommendation systems — "you might also like…" — are ML. So is early voice-assistant speech recognition and online ad targeting.
The Deep Learning turning point: thanks to much deeper neural networks and increasingly powerful GPUs, systems learn to recognize images, translate languages, and play chess better than any human. It's the direct precursor of generative models.
Deep Learning applied to language produces the first large generative models: GPT, BERT, then Claude, Gemini, Llama. Generative AI isn't a revolution that fell out of the sky — it's the latest link in a chain seventy years long.
Artificial Intelligence is the broad field. Inside it sits Machine Learning (systems that learn from data). Inside ML sits Deep Learning (deep neural networks). And Deep Learning applied to language at enormous scale produces LLMs — the models we interact with today.
Open weight vs. closed weight: is there a secret recipe?
All LLMs are trained in roughly the same basic way, but there's a fundamental difference that splits the AI world into two big families: the ones that share their "secret code" and the ones that lock it away in a vault.
Remember the weights we talked about earlier — those billions of numbers representing everything the model has learned? Well: an open-weight model makes them public. Anyone can download them, use them, modify them, run them on their own computer. A closed-weight model, on the other hand, keeps them secret: you can only use the model through an online service — and pay to do it.
The weights are public
- You can download it and run it on your own hardware
- No data ever leaves your network — total privacy
- You can modify it and train it further
- No per-call API cost
- You depend only on yourself (and your power bill)
The weights stay secret
- Accessible only via API or web interface
- Data passes through external servers (watch out for GDPR)
- You can't modify or inspect it
- You pay based on usage
- Often the most capable models on the market
Neither one is inherently better. It's a choice that depends on your priorities: if you need total privacy and want to keep everything in-house, open weight is the way to go. If you want maximum performance without worrying about infrastructure, closed weight is the right fit.
"Open weight" isn't the same thing as "open source." An open-weight model shares its weights but not necessarily the training code or the data used to create it. It's like being given a cake that's already baked: you can eat it, even tweak it, but you don't know exactly how it was made or with what ingredients.
Can a single LLM do it all? Almost.
A single LLM is already powerful. You can ask it to write an email, summarize a document, translate a text, explain a complicated concept. It's fine for most things.
But consider this scenario: you want to build a system that every morning reads the financial news, analyzes the stocks in your portfolio, checks the weather, updates a spreadsheet, and sends you a summary on Telegram. A single LLM could try, but it would be like asking a great chef to also be the waiter, the cashier, and the dishwasher — all at once.
Think of a hospital. There's no doctor who does everything: there's the cardiologist, the radiologist, the surgeon, the nurse. Each one is a specialist. And there's the chief physician who coordinates who does what, and when. Multi-agent systems work exactly the same way.
What a multi-agent system with an orchestrator is
A multi-agent system is a set of "agents" — each usually an LLM with a specific task — working together to reach a bigger goal.
But who coordinates them? Who decides who does what, in what order, and what to do if something goes wrong?
Enter the orchestrator. It's also an LLM — but its job isn't to carry out technical tasks. Its job is to think big: it understands the final goal, breaks it down into subtasks, assigns them to the right agents, gathers the results, and assembles them into a coherent answer.
The orchestrator, in practice, is the conductor. It doesn't play any instrument, but without it the orchestra would be just noise.
A team of specialists, not a single model
Here's the most interesting part. In a well-designed multi-agent system, the team's members don't all run on the same AI model. This approach is called heterogeneous multi-model architecture: each agent on the team can use a different LLM, chosen specifically for the kind of task it has to perform — exactly the way a company hires different profiles for different roles.
Why? Because AI models aren't all the same, and there's no reason they should be. Some are huge, reason in sophisticated ways, but are slow and expensive. Others are compact, fast, perfect for narrow tasks. Does it make sense to mobilize the whole team of senior researchers to answer a trivial question? Absolutely not — let the junior handle it.
This makes the team extremely flexible: you can have one member running on your home computer (private, offline, zero cost), one using a powerful cloud model for complex reasoning, and one trained specifically on medicine, law, or code — whatever the project calls for.
Say you're building a medical assistant. The orchestrator (a powerful model) understands the doctor's question. It passes it to an agent specialized in clinical literature, running a model fine-tuned on PubMed. A second agent retrieves up-to-date guidelines from the web. A third summarizes everything in plain language. Three different models, one single goal.
Putting it all together: the full picture
So, recapping without the jargon: a multi-agent system with an orchestrator and a heterogeneous multi-model architecture is basically a team of specialized AIs, each with its own tailored model, coordinated by a project-lead agent managing the workflow. Every team member does what it does best; the orchestrator holds it all together.
It's how AI is moving from a single, generic assistant to a squad of personal assistants ready to tackle real everyday problems: managing your calendar, tracking your finances, looking up medical information, answering emails, filling out documents — not one at a time, but in parallel and in a coordinated way.
And it's no coincidence that the major operating-system makers are already rethinking the PC interface in exactly this direction. Windows, macOS, and the leading mobile OSes are gradually gearing up to host AI agents as natural intermediaries between the user and applications: no longer an icon to click for every task, but a set of intelligent assistants that understand what you want to do and do it for you — or nearly.
It's the same logic behind the shift from the command line to graphical interfaces in the 1980s: a radical simplification of interaction that makes powerful tools accessible to everyone. Except this time the intermediary isn't a mouse cursor, but an agent that speaks your language.
And all of this — worth remembering — is the result of seventy years of research. It isn't magic. It's engineering, patiently built.