The software is written to model the fundamental biology of the human brain, with some important and purposeful limitations.
The foundation is the neural network. In our brain we have brain cells. Each cell is connected to other cells by something called synapse connections. Each synapse may have a varying strength of connection to the other cell. These connection strengths are controlled through inputs from our 6 senses. All of these cells communicating with each other with varying strengths of connections is what makes up the neural network.
In an AI software model, it's best to first define a few terms and link them to the human brain analogy.
| Software Model | Description | Human Brain Analogy |
|---|---|---|
| Node | Represents one cell in the neural network. | Cell |
| Weight | A number representing the strength of the connection between one node and another. | Strength of a synapse connection between one cell and another. |
| Iteration | One input of data to the model with a resulting output based on the current weights, followed by an adjustment of the weights as a function of the output, if the output does not match the expected answer. | One human experience with accompanying adjustments in strengths of synapse connections. |
Prior to training, the weights are set to random small numbers. You might think of this as close to the state of the human brain in a new born baby.
During the training of AI Large Language Model (LLM) model, strings of words are broken into tokens. As a general rule each prefix, each suffix, and each punctuation is a token. And then root words are tokens. This provides for may less tokens to define a written language than if each word were a token. For example, instead of having 10 variations on each verb times the number of verbs, you have each prefix and suffix once and each verb once. In other words, no player, played, playing, plays, replay, and so on for every verb. Just each verb, play for example, once and each prefix and suffix once.
Then phrases, sentences, paragraphs, or pages of writing samples are broken into strings of tokens. Strings of tokens are then input into the model. The model predicts what the next token should be based on the tokens that came before it. During training, the correct next token is already known, so the model's prediction can be compared with the correct answer. The model won't get the answers right on the first tries because the weights were initially set to random numbers. After each iteration, the weights are "back propagated," meaning adjusted by a formula that is a function of the errors the model made. This process can be thought of as analogous to the initial learning of a newborn baby. It doesn't know much yet. Mostly cries or coos. If you show it a picture of 4 + 4, it won't yet think, 8! But it's paying attention. Its synapse connections are adjusting as it takes in the world through its senses. It's learning words and concepts. Eventually when it sees 4 + 4 it will think, 8!
At this point, after the initial training, the model is basically a probability predictor of the likely next token in a string. The input string is called the prompt. It's the questions or instructions that the user gives it. The model then predicts most likely next token, add that to the end of the prompt string and uses that new string as input. Then out pops the next likely token, and so on. One might ask, how did the models start to give such good answers to complex questions toward the end of 2025 and into 2026? I'll get to that.
As of September, 2026, the largest "Frontier" models are of approximately the following size.
Number of parameters: 3 trillion
Number of training tokens: 30 trillion
Number of tokens per iteration: 30 million
Number of initial training iterations: 1 million
That's a lot of synapse connections with a lot of training iterations containing a lot of tokens
The modes also include innovations in self-learning, such as STaR (Self-Taught Reasoner) which is in the general category of RLAIF (Reinforcement Learning from AI Feedback). Also innovations in creative learning such as ToT (Tree of Thoughts) search algorithms.
In STaR the model is asked a technical question with a know answer and asked to show its work. The model then compares its answer to the know answer. If it gets the answer right it assumes that each step in its reasoning is correct. It can then use each step for additional training focused on reasoning.
In ToT the model takes a problem and breaks it into a tree structure of branches of multiple steps. The algorithm then propagates down multiple branches at a time, giving a score to each step representing the likelihood that the step will lead to a good solution. If it thinks it has made a mistake or is not progressing toward a solution, it may return to a previous step and start down a different branch, until it has arrived by logically true steps to a solution that it believes is correct.