Purpose
This article explains how a single LLM becomes part of a larger agentic system and why orchestration matters.
Overview
A single LLM can answer prompts, but many production systems need more structure than one model call.
An agentic system adds:
- roles
- delegation
- tools
- memory
- orchestration rules
- runtime visibility
This is the conceptual bridge between LLM theory and the online side of Giotto.
One model versus one agent
A model is the underlying inference engine. An agent is a runtime role built on top of that model.
An agent usually has:
- a role or specialization
- a system prompt
- allowed actions
- access to selected tools
- a place in a larger execution graph
This is why Giotto online YAML defines agents explicitly.
Why multiple agents
Some systems split work across specialized agents, for example:
- a manager agent
- a code or Python specialist
- a memory specialist
This can make behavior more structured and more observable.
Tools
Agentic systems often include tools so the model can act beyond pure text generation.
Examples include:
- code execution
- memory retrieval
- memory writing
- external API usage
In Giotto, tools are defined with explicit contracts.
Orchestration
Once you have multiple agents and tools, you need a control layer that determines:
- who starts
- who may call whom
- how many steps are allowed
- when the task is finished
That is the role of orchestration.
Why this matters for Giotto
This is the conceptual foundation of the online configuration:
root_nodeservice_registrychildrensystem_prompttool_contractray_serve_config
Key takeaways
- An agentic system is more than a single model call.
- Agents, tools, and orchestration add structure and capabilities.
Comments
0 comments
Article is closed for comments.