Purpose
This article introduces Giotto as a platform, explains what problems it solves, and shows how its main parts fit together. It is the bridge between general LLM concepts and the concrete workflows users will run in the platform.
Overview
Giotto is a platform for building, evaluating, deploying, and operating AI systems. It is designed to support both the development lifecycle of models and the production lifecycle of agentic systems within one unified environment.
At a high level, Giotto helps users do two kinds of work:
- offline work, where models are trained, evaluated, benchmarked, and compared
- online work, where trained models are deployed inside orchestrated agentic systems that can interact with tools, users, and other services
This distinction is central to understanding the platform. A user who wants to train or compare models will mostly work with the offline flow. A user who wants to deploy an AI system that behaves as a set of collaborating agents will mostly work with the online flow.
Why a platform like Giotto is needed
Working with modern AI systems usually involves more than just running a model.
Even a relatively simple workflow often needs:
- datasets and model artifacts
- distributed compute
- training and evaluation logic
- deployment infrastructure
- metrics, logs, and traces
- access control
- storage for outputs and intermediate artifacts
If these concerns are managed through separate tools without a common structure, the result is often fragile and hard to maintain. Giotto solves this by bringing them together under one operational model.
The key idea is that the platform is configuration-driven. Instead of writing custom orchestration logic every time, users define what they want through YAML configuration files, and the platform turns those files into executable workflows or deployed systems.
The two main flows of Giotto
Offline flow
The offline flow is used for AI development and evaluation.
This includes activities such as:
- retrieving datasets and models
- preparing prompts or input data
- training or fine-tuning models
- running decoding or generation
- filtering model outputs
- scoring results
- sweeping parameters through grid search
- benchmarking multiple runs
The offline flow is best understood as a pipeline. It is made of stages that run in sequence, where the output of one stage often becomes the input of the next.
A typical offline lifecycle looks like this:
- declare artifacts and datasets
- prepare the data
- train a model
- generate outputs from the model
- validate or filter the outputs
- score or compare the outputs
- repeat across parameter combinations if needed
This is the side of the platform most closely connected to the model-training concepts introduced earlier in the course.
Online flow
The online flow is used for deploying and orchestrating agentic systems.
This includes activities such as:
- defining agents and their responsibilities
- connecting agents to tools
- configuring a root controller or manager
- specifying how agents may delegate to one another
- deploying the model-backed services
- exposing the system through chat
- monitoring agentic activity through streaming events
The online flow is best understood as a runtime graph rather than a linear pipeline. It is about relationships between agents and tools, not only about ordered stages.
A typical online lifecycle looks like this:
- define the orchestration graph in YAML
- configure the orchestrator
- deploy the system
- trigger the deployment job
- verify the services in Ray
- interact with the deployed system through chat
- inspect events, logs, and metrics if needed
This is the side of the platform most closely connected to the concepts of agents, tools, and orchestration.
[Insert image here: high-level diagram showing offline flow on the left and online flow on the right, both connected through shared platform services]
The role of YAML in Giotto
If there is one idea users should remember from this introduction, it is this:
YAML is the main control surface of Giotto.
The platform UI is important, and so are Airflow, Ray, MLflow, Kafka, and the other interfaces. But the core behavior of the platform is defined in YAML.
The YAML files answer questions such as:
- which model should be used
- which dataset should be loaded
- how should training run
- which generation strategy should be used
- which agents exist
- which tools can they call
- how should the deployed services be configured
In other words, YAML does not merely describe the system. It defines the system.
This is why the final part of the course focuses so heavily on reading configuration files. Once you can read the YAML confidently, most of the platform becomes much easier to understand.
Main components of Giotto
Although YAML is the main definition layer, Giotto relies on several major components to execute and operate the defined workflows.
Airflow
Airflow is used to orchestrate flows. In practice, once a YAML configuration is submitted, it can be converted into a DAG that is then triggered and monitored in Airflow.
Airflow is especially central to the offline flow and to deployment jobs in the online flow.
Ray
Ray is the distributed compute and serving layer. It handles:
- training
- inference
- serving
- distributed runtime execution
In the offline flow, it is used for compute-heavy stages such as training, decoding, filtering, and scoring. In the online flow, it is used to serve the deployed agents.
MLflow
MLflow is used to track AI-specific experiment results, especially in offline workflows. It is the place to inspect runs, compare experiment outcomes, and review tracked metrics.
VictoriaLogs
VictoriaLogs provides centralized logging. This is where users can inspect logs across the platform, including centralized Ray logs.
VictoriaMetrics
VictoriaMetrics provides time-series metrics, especially from systems such as Ray and Airflow. It is useful for inspecting GPU activity, workload behavior, and resource usage over time.
Jaeger
Jaeger provides distributed tracing. It is useful when users want to understand how requests move across services in a multi-component system.
Kafka
Kafka acts as the streaming backbone for online execution. The orchestrator emits events there, and consumers such as the chat interface can use those events to provide runtime visibility.
Keycloak and Authz
Keycloak manages authentication and user identity, while Authz applies authorization rules based on roles and resource patterns.
Object storage
Object storage is the shared artifact layer. It stores models, datasets, intermediate outputs, and final results. In practice, it acts as a shared file-like backbone across stages and services.
Chat interface
The chat interface is the user-facing entry point for deployed online systems. It allows users to interact with the system conversationally while also observing agentic actions.
The mental model users should build
A very useful mental model for Giotto is the following:
- LLMs are the model layer
- offline YAML defines how models are trained and evaluated
- online YAML defines how models are deployed inside agentic systems
- Airflow executes workflows
- Ray provides distributed compute and serving
- observability tools explain what happened
- storage preserves the inputs and outputs
- identity and authorization control access
Seen this way, Giotto is not only an AI platform. It is an operational environment for the full lifecycle of AI systems.
Why this matters for the rest of the course
Up to now, the course has focused on model concepts:
- what LLMs are
- how they generate text
- how they are trained
- how they can be used inside agentic systems
From this point onward, the course becomes more practical.
The next two articles explain how those ideas are encoded in Giotto's two main YAML formats:
- the offline configuration
- the online configuration
That is where abstract LLM knowledge becomes platform literacy.
Learning goals
By the end of this article, readers should be able to:
- explain the purpose of Giotto at a high level
- distinguish between offline and online flows
- understand that YAML is the main definition mechanism
- identify the main platform components and their roles
Comments
0 comments
Article is closed for comments.