AI Evolutions

Step 1: Tokenization & Embedding Lookup
Each word in the question "capital" "of" "italy" is converted into a token. For each token, lookup the LLM Token Embedding Table to find a vector. This vector is a multi-dimensional structure, and it contains the learned embeddings for the token. This is the initial state of the token vector. At this stage we have 3 token vectors :

Embedding Vector (capital) = [4,7,1,0,3,...]
Embedding Vector (of) = [2,7,2,4,6,...]
Embedding Vector (italy) = [8,1,4,9,3,...]

Step 2: Positional Encoding
Before passing the Embedding Vector to the transformers layers, Positional Encoding is added to each Embedding Vector. This gives the model a sense of sequence of the Vectors, since transformers by themselves do not know the order of the tokens "capital of italy"

Vector (capital) = Embedding Vector (capital) + Positional (1)

Vector (of) = Embedding Vector (of) + Positional (2)

Vector (italy) = Embedding Vector (italy) + Positional (3)

With the Positional Encoding added, now the model knows Vector (capital) comes first, Vector (of) second, and Vector (italy) third, so the transformer layers can respect sequence

Step 3: Transformer Layer - Self-Attention
Step 3a - Q, K, V vector projection - At each transformer layer, there are multiple attention heads, and each attention head contains 3 trained weights matrices :

Wq - this projects a token vector into a "query space" -> Q = what context the token is seeking
Wk - this projects a token vector into a "key space" -> K = what context it can provide
Wv - this projects a token vector into a "value space" -> V = the information of the context

Each Wq, Wk, Wv are applied to each token vector to project a Q, K, and V vector :

Vector (capital) = [4,7,1,0,3,...]
                   -> Q (query)
                   -> K (key)
                   -> V (value)

Vector (of) = [2,7,2,4,6,...]
              -> Q (query)
              -> K (key)
              -> V (value)

Vector (italy) = [8,1,4,9,3,...]
               -> Q (query)
               -> K (key)
               -> V (value)

Step 3b - Q-K similarity check - For each token vector, it compares Q vector against the K vector of every other token vector before it, including itself

Vector (capital) Q -> compare against Vector (capital) K -> calculate Score (capital,capital)

Vector (of) Q -> compare against Vector (capital) K -> calculate Score (of,capital)
Vector (of) Q -> compare against Vector (of) K -> calculate Score (of,of)

Vector (italy) Q -> compare against Vector (capital) K -> calculate Score (italy,capital)
Vector (italy) Q -> compare against Vector (of) K -> calculate Score (italy,of)
Vector (italy) Q -> compare against Vector (italy) K -> calculate Score (italy,italy)

Step 3c - Softmax Normalization - Convert raw scores into attention weights for computation in the next stage

Score (capital,capital) -> Softmax Normalization -> Weight (capital,capital)

Score (of,capital) -> Softmax Normalization -> Weight (of,capital)
Score (of,of) -> Softmax Normalization -> Weight (of,of)

Score (italy,capital) -> Softmax Normalization -> Weight (italy,capital)
Score (italy,of) -> Softmax Normalization -> Weight (italy,of)
Score (italy,italy) -> Softmax Normalization -> Weight (italy,italy)

Step 3d - Self-Attention Vector - After the comparision, generates a new context‑aware representation by weighting and combining the V vectors of all tokens before it

Self-Attention vector (capital) = Weight (capital,capital) * V (capital)

Self-Attention vector (of) = Weight (of,capital) * V (capital) + Weight (of,of) * V (of)

Self-Attention vector (italy) = Weight (italy,capital) * V (capital) + Weight (italy,of) * V (of) + Weight (italy,italy) * V (italy)

This process of comparing each token vector Q (what context is seeking) against every other token vector K (what context can provide) before it, and generating a self-attention output vector , is the Self-Attention process, and this allows every token vector (word) in the prompt, to have a context and meaning, based on it's relationship with every other token vector (word) in the prompt

This describes the process for one attention head. Each transformer layer can have multiple attention heads, and this process is repeated independently for each attention head, and the outputs are combined

Step 4: Transformer Layer - Residual Connections & Layer Normalization
Step 4a - Residual Connections - combines the original Embedding Vector (capital) and the Self-Attention Vector (capital). This ensures the model keeps both the original meaning and the contextual enrichment

ResidualOutput Vector (capital) = Original Embedding Vector (capital) + Self-Attention Vector (capital)

Step 4b - Layer Normalization - ResidualOutput Vector (capital) is normalized across dimensions. This stabilizes the values and prepares them for the next step

ResidualOutput Vector (capital) -> Normalization -> Normalized Vector (capital)

Repeat above steps to generate Normalized Vector (of) and Normalized Vector (italy)

Step 5: Transformer Layer - Feed-Forward Network (FFN)
Step 5a - Linear expansion - Apply the Expanded Weight Matrix to the Normalized Vector (capital), and expand the vector into a higher-dimensional space

Expanded Vector (capital) = Expanded Weight matrix * Normalized Vector (capital)

The Expanded Vector (capital) now contains enriched representations (syntax, semantics, positional cues, ...)

Step 5b - Bias addition - Apply the transformer layer Bias Vector to the Expanded Vector (capital), and shifts the Expanded Vector (capital) with a baseline offsets. This enables richer signal to propagate into the next stage

Expanded Vector w/ Bais (capital) = Expanded Vector (cpaital) + Bias Vector

Step 5c - Activation GELU (Gaussian Error Linear Unit) - GELU smoothly gates each dimension of Expanded Vector w/ Bias (capital), preserving strong signals while attenuating weaker ones, thereby refining the representation for the next stage

EV = Expanded Vector w/ Bias (capital)
CDF = Cumulative Distribution Function

GELU Smoothed Vector (capital) = EV * CDF(EV)

Step 5d - Linear compression - Apply the Compressed Weight Matrix to compress the vector back to the original dimensions, and generate the FFN (Feed-Forward Network) Vector, so it can be processed by the next stage

FFN Vector (capital) = Compressed Weight Matrix * GELU Smoothed Vector (capital) + Bias Vector

Repeat above steps to generate FFN Vector (of) and FFN Vector (italy)

Step 6: Transformer Layer - Residual Connections & Layer Normalization
Step 6a - Residual Connections - combines the original Normalized Vector (capital) and the FFN Vector (capital). This ensures the model keeps both the original meaning and the contextual enrichment

ResidualOutput Vector (capital) = Original Normalized Vector (capital) + FFN Vector (capital)

Step 6b - Layer Normalization - ResidualOutput Vector (capital) is normalized across dimensions. This stabilizes the values and prepares them for the next step

ResidualOutput Vector (capital) -> Normalization -> Normalized Vector (capital)

Repeat above steps to generate Normalized Vector (of) and Normalized Vector (italy)

Step 7: Stacking Layers
An LLM has multiple transformer layers, with each layer adding Depth and Hierarchical Learning to refine the representation

Depth - Each transformer layer allow the model the capture increasingly complex relationships (syntax, semantics, context)

Hierarchical Learning - Each transformer layer learn local patterns (word proximity, short dependencies). Deeper layers learn global patterns (long-range dependencies, abstract meaning)

For each transformer layer, the following steps are repeated :

Input : Vector (capital), Vector (of), Vector (italy)

Step 3: Transformer Layer - Self-Attention

Step 4: Transformer Layer - Residual Connections & Layer Normalization

Step 5: Transformer Layer - Feed-Forward Network (FFN)

Step 6: Transformer Layer - Residual Connections & Layer Normalization

Output : Normalized Vector (capital), Normalized Vector (of), Normalized Vector (italy)

Step 8: Final Layer & Output Projection
Step 8a - Final Layer - After stacking multiple transformer layers (Step 7), the last layer produces the final hidden representation of each token in the sequence :

Final Hidden Vector (capital) = Refines and integrates information of Normalized Vector (capital) of all transformer layers

Final Hidden Vector (of) = Refines and integrates information of Normalized Vector (of) of all transformer layers

Final Hidden Vector (italy) = Refines and integrates information of Normalized Vector (italy) of all transformer layers

Step 8b - Output Projection - Projects the Final Hidden Vector into the LLM vocabulary space, to calculate the Logit Vector, which is the relevance score of each vocabulary to the Final Hidden Vector :

Logit Vector (capital) = Vocabulary Weight Matrix * Final Hidden Vector (capital) + Bias Vector

Logit Vector (of) = Vocabulary Weight Matrix * Final Hidden Vector (of) + Bias Vector

Logit Vector (italy) = Vocabulary Weight Matrix * Final Hidden Vector (italy) + Bias Vector

Step 9: Softmax & Token Selection
In a GPT (Generative Pre-Trained Transformer) model, it only use the last token's Logit Vector to predict the next vocabulary. Since "italy" is the last token in the question "Capital of Italy", only Logit Vector (italy) will be used to predict the next vocabulary.

Note that althrough Logit Vector (capital) and Logit Vector (of) are not used to predict the next vocabulary, they have contributed to the final representation of Logit Vector (italy) , through the transformer layers

Step 9a - Softmax Probabilities - A softmax function is applied to the Logit Vector (italy) to convert raw scores into probabilities. This produces a probability distribution across the entire vocabulary in the LLM :

Probability Distribution (all vocabulary) = SoftMax [Logit Vector (italy)]

Step 9b - Prediction - Predicts the next vocabulary with the highest probability
Inside Probability Distribution (all vocabulary), it contains the probability of each vocabulary in the LLM relative to Logit Vector (italy). For example, the distribution might look like :

Probability (rome) = 0.55

Probability (milan) = 0.18

Probability (naples) = 0.12

Probability (turin) = 0.09

Probability (florence) = 0.06

...

Since Probability (rome) has the highest probability, Rome is selected as the next predicted vocabulary, answering the question "Capital of Italy"

Step 1: User Request

Step 2: Orchestration Layer process user request

Step 3: Orchestration Layer provides Tool Registry to LLM

Step 4: LLM Reasoning with execution plan & tool call

Step 5: Orchestration Layer validates & execute tool call

Step 6: LLM validates results, and provides next tool call

Step 7: Complete execution plan & tool call

Step 8: LLM Final Reasoning & Synthesis

Step 9: Orchestration Layer final output to user

Step 10: Memory/Context updated