bilingual · en / pt
artificial intelligence didn't begin with ChatGPT
AI and machine learning#history#learningIn the post "you're not an AI expert", I promised to tell the history of AI from the beginning, in the same format as the cryptography post. That one already covered Turing. What remained was to follow the story through neural networks, language models and the agents we use today.
The frustration was the same: "AI" had become a synonym for chatbot, and knowing how to use the tool had started to pass for knowing the subject. But opening ChatGPT doesn't explain how a machine learns, why it needs so much data, or how it can write an answer that's convincing and wrong.
I'm still studying this on my own. I'm neither a computing historian nor an AI researcher; the sources are linked throughout the text. There are many people and paths in this history, and I'll explain each idea before relying on its acronym. You don't need programming or mathematics to follow along.
The first part follows the field's precursors: how to represent knowledge, execute procedures and, later, learn from examples. Dartmouth marks the formation of a shared agenda, but those questions had already emerged along different paths. We'll follow both the methods and the people, institutions and resources that made them possible.
You can read in order or jump to learning from examples, language models and agents, or institutions, resources and impacts. The "further reading" blocks stay expanded; the "skip further reading" link takes you to the next passage. At the end, the map, chronology and glossary are there for reference. Beside the controls, the experiments explain what they actually calculate and what they only illustrate.
The question running through this post is: what does the machine do, how does it do it, and what does that still not demonstrate? It applies to a seventeenth-century calculator, a neural network and an agent in 2026.
before AI: making reasoning something we can manipulate
the shape of an idea
Before computers existed, people were already trying to describe the structure of reasoning. If that structure could be repeated, perhaps reasoning wouldn't depend on having a good idea every time.
Consider these two statements: “every mammal is an animal” and “every dolphin is a mammal.” They let us conclude that every dolphin is an animal. You don't need to know every dolphin in the ocean to get there. The conclusion depends on the relationship between categories, not on fieldwork carried out at that moment.
Now replace the names: “everything in category A is in category B” and “everything in category C is in category A.” We can still conclude that C is in B. The content is gone, and a form of reasoning remains. Logic studies this kind of structure: which conclusions follow from which premises, and under what conditions.
Aristotle studied these forms of inference long before AI existed as a research field. Calling his work artificial intelligence would be anachronistic, but the question was already there: what lets us move from one statement to another? If we describe the form precisely, perhaps a mechanical operation can carry out part of it.
But a conclusion can follow correctly from false premises. If I say that all birds live on Mars and that a macaw is a bird, the rule delivers an absurd conclusion without making an error in the transition between statements. The validity of reasoning and the truth about the world are different questions. A machine that applies rules flawlessly doesn't thereby gain magical access to correct facts.
An expert system can apply a correct rule to a wrong fact. Later, we'll encounter a similar problem in language-model answers and agent actions.
what if arguing could become calculating?
In the seventeenth century, Gottfried Wilhelm Leibniz imagined something ambitious: a symbolic language that could represent ideas precisely, and a calculus that could operate on them. Instead of getting lost in words that meant different things to each person, two people could clarify the representation and calculate its consequences.
That ambition had two halves. The first was representing knowledge. The symbol for “animal,” for example, would need a sufficiently definite meaning. The second was establishing permissible operations on the symbols. A collection of labels doesn't reason by itself; it needs relationships and rules.
Leibniz also worked on mechanical calculators. His project for universal reasoning remained an ambition, far from a modern computer. He wanted to extend calculation beyond arithmetic. Perhaps parts of reasoning could be treated as calculation. The account of his work in the Stanford Encyclopedia of Philosophy places that ambition in its intellectual context.
In the nineteenth century, George Boole gave logical operations an algebraic form. As a first approximation, imagine two conditions: “the door is closed” and “the alarm is on.” Each can be true or false. AND requires both; OR accepts at least one; NOT reverses a condition.
This is familiar even if you've never programmed. To qualify for a promotion, you might need to be a registered customer and spend more than a certain amount. For an alarm to sound, the door opening or a sensor detecting motion might be enough. Logic makes these combinations explicit. Boole gave those operations a systematic mathematical treatment. The historical reference on Boole also distinguishes his work from later formulations of Boolean algebra.
Gottlob Frege extended formal logic's reach with his Begriffsschrift, published in 1879. The difference that matters here is moving from simple combinations to a language that can discuss objects, properties, relationships and quantities: “someone exists,” “for every object,” “this person is that person's mother.” A more expressive language represents more things, but also demands more work from whoever operates on it. The reference on Frege documents that contribution.
The sequence so far is this: recognize a form of inference, write it in symbols and define the permissible operations. We can then ask whether a procedure could do part of the work.
It also exposes a problem that has never left AI: representing the world takes work. “The glass is on the table” sounds simple. But what counts as a glass? Which table? Is it on top, resting on the edge, inside a box that's on the table? Good representations simplify a task. Bad ones hide precisely the detail that matters.
the machine that didn't always have to do the same thing
Machines built to imitate actions also existed long before anyone called them AI. The automaton of Diana on a stag, from around 1620, could move across a table. Gears produced a prepared sequence; the appearance of action doesn't demonstrate learning. That tradition helps distinguish three things we'll keep encountering: automating, imitating and learning.
Another tradition ran in parallel: building machines that performed work. Pascal's and Leibniz's mechanical calculators automated arithmetic, but automating an operation differs from having a machine whose behavior can be described by a program.
A music box is a useful comparison. It has a mechanism and a sequence that determines what it plays. Replacing the sequence changes the music without requiring you to reinvent the gears. The machine stays the same; the instructions change.
In the 1830s, Charles Babbage designed the Analytical Engine. The design distinguished storage, operations and instruction control; punched cards would help direct the work. These are conceptual relatives of the memory, processor and program in today's computers. But Babbage didn't build the complete machine. The distinction between a design and a working machine matters here. The Computer History Museum helps separate them.
In her notes on the Analytical Engine, published in 1843, Ada Lovelace recognized that the design could work with things other than numbers. If something could be represented by symbols, a symbol-manipulating machine might work with more than numerical quantities. Music is one example associated with the notes: relationships between sounds could, given suitable representations, enter that world of operations.
To work with music, the machine would need a representation of sounds and operations on it; a musician's experience is a different matter. Lovelace also discussed the limits of what the machine could originate on its own. Following instructions and producing a result that surprises their author were already questions before the electronic computer.
For example, a number can represent a musical note, a color or a letter. “Change this number” means different things depending on the representation. If symbol 65 represents the letter A, adding one may point to B. If it represents a pixel's intensity, adding one brightens part of an image. The mechanism operates on numbers; their meaning depends on the system in which they're used.
This helps explain why a computer can handle images, text, audio and money. It doesn't need a different physical gear for every subject. It needs a way to represent the subject and a suitable procedure. That generality will be decisive for AI: ideas about language, games, logic and learning can be tested on the same class of machine.
But which problems can a machine solve by following instructions? Having a program doesn't yet answer that.
what a machine can do
recipe, proof and limit
A procedure is a sequence of steps that doesn't depend on inspiration at every attempt. The recipe needs to say enough for someone to follow it. “Make good dough” isn't a recipe; “mix these quantities for this long” begins to be one.
In mathematics, there's a stricter version of this question: is there a procedure that always terminates and correctly decides a class of problems? Solving a few examples isn't enough. A rule that works when I choose favorable cases isn't a general solution.
David Hilbert was central to a program seeking secure formal foundations for mathematics. Among its questions was the possibility of general procedures for deciding certain logical problems. If all mathematical reasoning could be transformed into symbols and rules, perhaps deciding what follows from those symbols could be automated.
In 1931, Kurt Gödel showed limits of sufficiently expressive formal systems. The conditions are very specific: the results don't say that "nothing can be proved" or that "every opinion is equally valid." The incompleteness theorems show that certain consistent, effectively axiomatized systems cannot prove every arithmetical truth expressible within them, and establish a limit on proving their own consistency under precise assumptions. The Stanford Encyclopedia of Philosophy's explanation spells out those conditions.
Even without following the proof, we can understand the consequence: powerful rules aren't guaranteed to settle every possible question about themselves. The history of formalization encountered internal limits, and faster electronics didn't make those limits disappear.
In the 1930s, Alonzo Church and Alan Turing gave rigorous descriptions of computation. Church worked with lambda calculus, a mathematical language of functions. Turing described an abstract machine with a tape, symbols, states and movement rules. The formalisms proved equivalent. The claim that they capture every effective procedure is the Church–Turing thesis, not a theorem about an informal definition of computation.
The Turing machine was a mathematical model for studying procedures, much simpler than a physical computer. Imagine a tape divided into cells and a head that reads one cell at a time. Depending on the symbol and its state, it writes something, moves and changes state. It's simple enough to analyze and general enough to represent complex computations.
Turing proved that some problems have no general decider of this kind. One familiar result is the halting problem: no single algorithm can correctly determine, for every program and input, whether that program will terminate or run forever. A faster processor doesn't solve this limit.
You can still determine whether a particular program terminates and analyze entire classes of programs. What fails is the promise of one method that correctly decides every case.
from logic to electricity, from electricity to feedback
Claude Shannon established a fundamental connection between logical operations and switching circuits. A condition that's true or false in algebra can correspond to an electrical configuration. Combinations of circuits can perform operations that, on paper, were symbolic relationships. His thesis, with a title page signed in 1937, documents that bridge.
Certain physical behaviors can implement formal operations. This lets us build chains of operations in hardware. Shannon was one contributor to a development involving many people and architectures.
Shannon also formalized a mathematical theory of communication in 1948. Here, information has a technical meaning involving uncertainty and message transmission. Measuring information doesn't measure wisdom, intention or understanding. A file can carry many bits and say little anyone cares about; that difference matters when, decades later, we discuss models processing enormous volumes of data.
Under the name cybernetics, Norbert Wiener organized the study of control, communication and feedback in machines and organisms, presented in his 1948 book. “Feedback” may sound like something from a meeting, but here it's a simple mechanical idea: observe the result of your action and use that observation to adjust the next action.
A thermostat is one example. It measures temperature, compares it with the target and controls heating. Is the room too hot? The system reduces or turns off the heat. Too cold? It acts again. Its response depends on the observed state of the environment. That's different from simply running a heater for two hours and hoping.
The thermostat adjusts its action according to what it observes. This cycle is an idea from cybernetics that runs through industrial control, robotics and learning, without requiring us to consider the thermostat intelligent. Later, agents will also read results and adjust plans, using different technology to organize a similar cycle.
neurons as a model, not a copy of the brain
In 1943, Warren McCulloch and Walter Pitts published work connecting networks of idealized neurons with logic. A neuron in that model was a mathematical simplification: receive signals and produce an output under defined conditions. Networks of those units could perform logical operations.
Connecting simple units could also produce computational behavior. There was no need to write each operation as a high-level rule. That didn't make the model a faithful reproduction of a brain. Biological neurons have dynamics and contexts that a threshold unit omits. That's where the inspiration for the name comes from. McCulloch and Pitts's original paper lets us examine those idealizations.
In 1949, Donald Hebb proposed a theory of changes in connections between neurons associated with experience: a connection's strength could change with activity. The familiar phrase “neurons that fire together wire together” is a later simplification. A copy of Hebb's book is preserved by the Max Planck Institute.
Think of a network of paths. If every connection's influence stays fixed forever, behavior changes only when someone changes the design. If those influences can adjust to examples or results, behavior itself can be modified through learning. We still need rules that make those adjustments work, but the possibility is there.
There are already lineages that will later be treated as competitors: operating on explicit symbols, reacting through control cycles, learning relationships from data and adapting networks of connected units. They weren't all born at one conference. They converged in an environment that now also had digital computers on which ideas could be tested.
One such experiment took physical form in 1951: SNARC, built by Marvin Minsky and Dean Edmonds. Circuits represented connections, and a reinforcement mechanism modified recently used paths. Minsky's own biography and his thesis document the work. It was an experimental machine: networks had physical implementations before Dartmouth, still far from reproducing a brain.
Turing changes the question
In 1950, Turing published Computing Machinery and Intelligence. To reframe the question of “thinking,” he began with a game involving a man, a woman and an interrogator, then asked what would happen if a machine took one of the roles. The best-known interpretation asks whether the interrogator could distinguish a machine from a person through textual answers.
We can observe the answers and describe the experiment even while disagreeing about what thinking means. The test that came to bear his name offers a way to discuss the question, not a definitive certificate of intelligence, consciousness or understanding.
A machine can be convincing because of the evaluator's limitations, conversational strategy, a narrow context or real language capability. And a system can solve an important scientific problem without conversing like a person. Being indistinguishable in a conversation is therefore evidence about a situation, not a universal measure of everything we call intelligence.
The paper also discusses learning. Turing didn't imagine only hand-writing every answer for an adult machine; he considered building something that could be educated. That brings the question of intelligence closer to the question of change through experience. The 1950 text is worth more than the one-sentence summary that usually circulates.
The connection with cryptography comes through this interest in procedures, constraints and inference. At Bletchley Park, the work against Enigma was collective: it built on contributions from the Polish mathematicians Marian Rejewski, Jerzy Różycki and Henryk Zygalski, as well as Turing and other British researchers. Exploiting constraints to rule out configurations is an example of structured search. This reveals a continuity of questions, but doesn't automatically turn cryptanalysis into machine learning.
AI will include methods that search for solutions by following rules and methods that adjust parameters from examples. Sometimes they work together. Representation, search and computation are meeting points between these areas, built by many people.
a field gets a name, and ambition grows
Dartmouth didn't start from nothing
On August 31, 1955, John McCarthy, Marvin Minsky, Nathaniel Rochester and Claude Shannon signed a proposal for research the following summer at Dartmouth. The phrase artificial intelligence appears in the document. In 1956, the meeting helped consolidate a name and scientific identity for questions that already had a history.
The document began with an ambitious conjecture: aspects of learning and intelligence could be described precisely enough for a machine to simulate them. The proposal included language, neural networks, abstraction and machine improvement. The original preserved in McCarthy's archive lets us see that optimism without relying on a promotional retrospective.
Naming a field has practical consequences. It helps bring researchers together, request funding, open laboratories, create courses and discuss an agenda. Work that previously seemed to belong to different traditions gains a banner under which it can organize.
That also creates disputes. Which work belongs under that banner? Which approach deserves money? Are a neuron-inspired network and a theorem-proving program trying to explain intelligence in the same way? The name unites a field but doesn't settle its internal differences.
The meeting helped organize the field, but the approaches continued to diverge. The participants didn't leave Dartmouth with a plan for the next seventy years.
- 1936Church and Turing7 yearsformalizing procedures and investigating their limits.
- 1943McCulloch and Pitts5 yearsnetworks of idealized neurons connected to logic.
- 1948Shannon and Wiener2 yearsinformation, communication, control and feedback.
- 1950Turing5 yearsa behavioral experiment beyond the debate about thinking.
- 1955the proposal1 yearartificial intelligence appears as a research program.
- 1956Dartmouth2 yearsthe meeting consolidates an identity for the discipline.
- 1958perceptronRosenblatt publishes a learning model based on adjusting weights.
the program that searched for a proof
Allen Newell, Herbert Simon and Cliff Shaw developed the Logic Theorist in the mid-1950s. The program worked on theorem proving. In simple terms, it received a goal and tried to find a sequence of operations connecting available statements to the desired conclusion. The 1956 report preserved by Carnegie Mellon documents this work.
A proof can be thought of as a path. You start from accepted premises, apply permissible operations and need to reach your destination. Beyond knowing the operations, you need to decide which to try, in what order, and when to abandon a path that's going badly.
If you've ever tried a jigsaw puzzle, you know the difference. Knowing that compatible pieces can fit doesn't tell you which of hundreds to choose next. A useful clue reduces attempts. In computing, a heuristic is a practical guide to a more promising search, without necessarily guaranteeing that a choice is perfect.
The Logic Theorist produced proofs by searching paths between representations: the operations were given; finding a useful sequence was the program's job.
Newell and Simon continued this work with the General Problem Solver. The ambition was to make the solution mechanism less specific: represent states, goals and differences, choosing actions that reduced the distance between the current and desired state. “General” in the name should be read as a research objective, not the ability to solve any everyday problem.
Imagine making coffee: the initial state contains cold water, ground coffee and a kettle; the goal is brewed coffee. Heating the water makes it possible to move on to brewing. But if the power is out, heating fails and the plan needs another condition or alternative, such as an available stove. This is a teaching example, not a historical GPS execution: explicit states and actions work in a prepared problem; discovering everything that matters in everyday life greatly increases the work of representation.
The early results impressed people because they achieved something previously impossible. The work needed to move beyond problems prepared for a demonstration still had to be measured.
the program that changed with experience
Another direction became clearer with Frank Rosenblatt's perceptron, described in his 1958 paper. Instead of representing an entire chain of human rules, the model combined inputs using adjustable weights and produced a decision.
A weight determines how much an input influences the result. Imagine assessing whether fruit is ripe. Color, firmness and smell can contribute differently. With features on the same scale, a weight larger in magnitude gives smell more influence in the numerical combination; its sign can support or oppose the output. The model has neither a nose nor a concept of fruit; it receives numbers someone chose or measured to represent the features.
The training process changes those weights using examples. If the desired output was “ripe” and the model answered something else, a procedure can adjust the values to reduce later errors. This is a different way to program: a person chooses the structure, examples and learning rule, but doesn't write every final decision directly.
During training, the parameters, adjustable values such as weights, change. During inference, the model executes its operations on an input with the available parameters to produce a prediction or answer. Here, “inference” names that execution, without requiring logical reasoning.
Changing the input can also change the answer without changing weights. This distinction will be fundamental to prompts: examples in a conversation guide that execution, without thereby incorporating a permanent skill into the model.
The perceptron had important limits, which we'll examine in an experiment later. We can already compare the two programs: the Logic Theorist searched for consequences and paths using explicit representations; the perceptron adjusted a decision function from examples. These are two ways of working on AI problems, both older than chatbots.
The models used in chatbots, known as large language models (LLMs), are neural networks with many layers. Networks are a family of machine learning, which is part of AI. The diagram places this piece within the whole field; layers and language come later.
why the early results seemed to promise more
A computer that proves a theorem can seem close to doing science by itself. A classifier that learns from images can seem close to recognizing any object. The early results encouraged expectations on that scale.
But a carefully prepared photograph and a poorly lit object in the street demand different things from a classifier. The same goes for conversing with expected phrases versus following a story full of implicit references. In theorem proving, the premises are already defined; in a social problem, deciding which premises represent the situation may be precisely the hard part.
Every result needs to be read within its conditions. Which inputs were used? Which parts of the task had the representation already solved? Who selected the examples? How much human work surrounded it? Those questions tell us how much of the task the program solved.
intelligence written as rules
representing a world and searching for a path
To manipulate symbols, researchers also needed suitable programming languages. John McCarthy began implementing Lisp in 1958; the formal paper on its recursive functions appeared in 1960. Lisp made lists and expressions easier to work with: a statement, a set of rules or part of a program could be represented as structures another program could examine. McCarthy's account distinguishes development from publication.
Imagine storing “Ana is Bia's mother” as a list with three roles, rather than just a loose sentence. The program can locate the relationship, substitute a name or combine the structure with another. Lisp helped build and transform these representations. Knowledge still had to be put into them. That usefulness helps explain its place in symbolic AI laboratories and, later, the Lisp-machine market.
The approach known as symbolic AI represents things explicitly: objects, relationships, conditions, actions and rules. “A is on top of B” can be a fact; “if A is on top of B, moving B first requires removing A” can be a rule. The program operates on these representations.
The rules make part of the reasoning visible. If the system says it needs to remove a box before pulling out a shelf, we can trace the path to that decision. The facts may still be wrong, but we can examine the operations.
Imagine three stacked boxes. You want to take the bottom one to another room, but can move only one box at a time and can't move through the others. There's an initial state, a goal and permissible actions. The solution involves a sequence: remove the top box, remove the middle one, move the bottom one. The program needs to find that sequence in the space of possibilities.
A state is a relevant description of a situation. An action transforms one state into another. A plan is a sequence of actions to reach a desired condition. A machine can use these concepts without wanting to carry a box or knowing what being in a room feels like.
Finding ways to achieve a goal and organizing actions were tasks associated with reasoning. Programs could perform parts of them, using mechanisms that could differ from ours.
The difficulty appears when possibilities multiply. If each state allows ten actions, two steps can open a hundred paths; three, a thousand. Ten steps can already produce an enormous number of combinations. Not every path is different or needs exploring, but the example shows why “just try the options” quickly stops being practical.
A heuristic can guide the search. On a map, straight-line distance to the destination suggests which city to visit first. It doesn't replace the actual road, but helps avoid very bad attempts. In planning, other approximate measures can play the same role. This reduces the number of paths the program needs to examine.
ELIZA: when conversation makes it seem someone is there
In 1966, Joseph Weizenbaum published a paper on ELIZA. The system transformed textual inputs using keywords and decomposition and recomposition rules. A familiar script imitated certain patterns of therapeutic conversation, often returning questions related to words in the input.
A sentence containing “my mother” could trigger an answer about family. A sentence with an expected structure could be rearranged into a question. This wasn't a neural network trained on books or a model with a general understanding of the situation being described.
The paper by Weizenbaum matters both for the mechanism and for the reaction it helps us discuss. People readily attribute intention and understanding to linguistic behavior. A seemingly caring answer can give the impression that the system understood someone's experience, even when it applied a very narrow transformation.
The tendency to see someone behind the conversation was already there. Today's language models use a different mechanism but encounter the same human reaction.
The version below searches for literal fragments and shows the rule it matched. It's a small adaptation so you can see the whole mechanism, not a reproduction of ELIZA.
simplified execution · local rules
rule-based reply
what makes you say you are sad?
matched rule
contains “sad” → return a question about sadness without analyzing negation
The answer may seem relevant because you supplied a word the script recognizes. But it can fail because that word appeared in a negation, quotation or unexpected context. The program doesn't need to identify all of that to produce a grammatical sentence.
There's also a human part to how this works. The person fills in gaps: interprets a vague question as interest, imagines continuity and attributes intention. The interface contributes to that reading. The same operation, presented as a text transformation in a technical panel, may seem much less human than it does in a conversation window.
SHRDLU and the advantage of a small world
Terry Winograd developed SHRDLU in the late 1960s and early 1970s. The system handled language in a blocks world: objects with properties and relationships that could be represented explicitly. You could request operations on those objects and ask questions within that context.
Imagine asking “put the red block on the blue one.” In a blocks environment, the system can have an object list, know which are red and blue, represent spatial relationships and choose an action. A later sentence can use “it,” and context helps determine which block is meant.
SHRDLU integrated language analysis, contextual memory and actions on the environment. Winograd's own account also explains the limit: the program worked in a universe carefully prepared for its mechanisms.
If I leave the blocks and say “tidy the house for a visitor,” the meaning opens up. Which visitor? What counts as tidy? Is the box on the floor in the way, or is it where someone keeps their medication? The common-sense knowledge a person uses without noticing can be much larger than the explicit list of objects and rules.
The closed blocks world was part of the solution. Outside it, expanding the list of nouns wasn't enough to give the program the knowledge it needed.
Not everyone accepted that more rules would be enough to extend those results. In a critique published by RAND in 1965, Hubert Dreyfus questioned the assumptions behind that ambition. Knowing a situation also involves tacit skills, context and bodily experience: recognizing irony isn't simply finding the word “irony.” The critique opened a philosophical dispute about what formal representations capture. It isn't a mathematical proof that machines could never learn, but it prevents treating a blocks world as a complete sample of human life.
Shakey brings the problem onto the floor
At SRI, Shakey brought perception, representation, planning and action together in a mobile robot, developed between 1966 and 1972. The situation wasn't just a symbolic description inside a program. The robot had to deal with a physical environment and do something in it. SRI's institutional archive preserves this history.
Moving an object involves more than choosing a sentence: locate the object, estimate the space, plan a sequence and execute movement. Each stage can have its own errors. If the representation says a path is clear and a camera misses an obstacle, the plan can be logical and still fail on the floor.
In a robot, each instruction depends on the body and environment: sensors, position, response time and motion. An action correct in the plan can fail when those conditions differ from what the program assumed.
This setting produced STRIPS, by Richard Fikes and Nils Nilsson, published in 1971. An action has preconditions, what must be true to apply it, and effects, facts it adds to or removes from the state. To move a box, the robot may need to be beside it; afterward, “the box is at the origin” no longer holds and “the box is at the destination” does. The original paper formalizes this way of searching for plans.
Logic programming opened another direction. Prolog, developed in 1972 by Alain Colmerauer, Philippe Roussel and colleagues in Marseille, with theoretical exchanges involving Robert Kowalski and researchers in Edinburgh, lets you write facts and relationships and ask the system to seek a proof for a query. The creators' account and Kowalski's history preserve the collaboration between building the language in Marseille and investigating proof procedures in Edinburgh. These are participant accounts, with their own perspectives.
In a family example, supply “Ana is Bia's mother” and “Bia is Caio's mother,” plus a rule about grandmothers. The system can search for a chain answering whether Ana is Caio's grandmother. A person describes relationships and a query; the mechanism seeks combinations that satisfy it. This tradition will connect directly with Japan's investment in knowledge processing in the 1980s.
These demonstrations worked under well-defined conditions. ELIZA depended on conversation patterns, SHRDLU on a blocks world and Shakey on the robot's perception and control. Extending the results to less prepared situations would require more work than the promises suggested.
promises, experts and winters
what cooled down, exactly?
“AI winter” is a useful phrase as long as it doesn't become a worldwide season with exact start and end dates. It usually names contractions in expectations, funding and markets. Fields and countries didn't all cool down together, nor did they stop researching.
In machine translation, early demonstrations and the Cold War context encouraged interest and investment. But translation involves ambiguity, context, idioms and subject knowledge. A demonstration with carefully chosen sentences doesn't measure performance on varied documents.
One concrete demonstration was Georgetown–IBM, on January 7, 1954: an IBM 701 translated Russian sentences into English using a controlled vocabulary and rules. IBM's record and the 1955 technical account describe its conditions. The system translated that set of sentences; how it would handle varied texts remained to be investigated.
Consider “he saw the bank.” It could mean a financial institution or the side of a river. “The bank was beside the river” helps one interpretation; “the bank approved the loan” helps another. Translating individual words and rearranging structures can work in simple cases and break when the choice depends on a larger story.
The 1966 ALPAC report evaluated machine translation in the context of United States investment. It had important effects on priorities and resources. That doesn't mean machine translation ended there: computational linguistics, supporting tools and other research continued.
In the United Kingdom, James Lighthill's 1973 report criticized AI's difficulties, including scalability. The assessment was associated with British retrenchment, but was challenged at the time. McCarthy's response shows disagreements over interpretation and criteria, not a unanimous verdict that intelligent machines were impossible.
When a field depends on funding, what counts as success also depends on institutions. Demonstrating a principle, delivering a useful tool and justifying military investment are different goals. Changed priorities can reduce resources despite scientific results; results falling short of promises can make such changes more likely.
Expectations grew, results fell short of promises and institutions reconsidered resources. This cycle happened at different times and in different countries, combining technical difficulties with funding choices.
the limit of a straight line
A famous part of this history is Perceptrons, by Marvin Minsky and Seymour Papert, published in 1969. The book studied limits of classes of perceptrons. Its best-known result in popular accounts involves linear separation.
Imagine red and blue points on paper. If you can draw a straight line leaving every red point on one side and every blue point on the other, the classification is linearly separable. If the colors alternate at the corners of a square, no straight line does the job.
That's the structure of XOR: two inputs, with output 1 when exactly one is on. “Neither on” and “both on” belong to one category; “only the first” and “only the second” to another. A single linear separator cannot correctly divide all four combinations.
The result applies to that linear separator, not every neural network. An architecture with intermediate units and nonlinear operations can build a different separation. To be useful, it also needs an effective training method.
The book's role in that retrenchment is a historical question, not a consequence of its theorem. Mikel Olazaran, in 1996, investigated how interpretations of the controversy related to symbolic AI's authority and resource allocation. Explaining the period also requires considering hardware, training and continuing research, without assigning one cause to the entire field.
knowledge of one field, rather than intelligence for everything
Expert systems narrowed the task's ambition: capture knowledge of one field and use it for specific problems, rather than start with a general solver.
DENDRAL worked on interpreting chemical structures. MYCIN investigated rules involving infections and treatments. XCON was used to configure Digital Equipment Corporation computer systems. “Expert” came from the scope and knowledge base; it didn't mean the system mastered every subject.
How does this work? Separate a collection of facts from a collection of rules. The facts describe the current case. Rules explain how certain conditions allow further statements. An inference mechanism selects and chains rules, sometimes handling degrees of certainty.
In an invented maintenance example, “the machine won't turn on” is a fact. A rule might say that if there's no electrical power, investigate the connection before dismantling the motor. Another rule may use that investigation's result. The system builds a path guided by recorded knowledge.
A well-organized base uses domain knowledge to avoid bad paths; adding rules alone doesn't solve this.
The book Rule-Based Expert Systems, by Buchanan and Shortliffe, documents MYCIN's architecture and debates. It's important to distinguish experimental studies from routine clinical deployment. Evaluating a program in research doesn't mean it became an autonomous doctor in hospitals.
who keeps the world up to date?
Expert systems become difficult when knowledge changes or one rule interacts badly with another. A single rule may seem clear; thousands can have dependencies, exceptions and conflicts.
Capturing a human expert's experience isn't simply asking “which rule do you use?” Many people recognize situations through practice without being able to describe a complete list. Extracting, formalizing, verifying and updating knowledge takes work.
Imagine a store with rules for recommending compatible parts. One manufacturer changes a connector, another launches a similar model, a product is discontinued and commercial names change. The base needs to keep up. Otherwise, the mechanism keeps correctly applying information that no longer matches the catalog.
That maintenance adds to infrastructure costs. During the commercial wave of the 1980s, specialized Lisp platforms and machines had their place. Changes in the computer market, costs and alternative systems' performance altered that business. A technology can lose commercial viability without all the science behind it being false.
Japan's Fifth Generation Computer Systems project, launched in 1982, invested in knowledge processing, logic programming and parallelism. The Information Processing Society of Japan's record describes eleven years and approximately 54 billion yen, through fiscal year 1992. This was a scientific policy with equipment and research, not just a product promise. Its ending doesn't erase its contributions or prove logic programming useless. ICOT ran the program with MITI support; the ICOT/AIST archive preserves its research and infrastructure. The dominant commercial transformation imagined in the initial enthusiasm didn't materialize.
In the late 1980s and early 1990s, commercial expectations and maintenance costs contributed to another contraction associated with “winter.” Meanwhile, speech recognition, statistics, control, optimization and networks continued advancing. These methods grew while expert systems occupied the commercial spotlight.
learning from examples
who writes the rule?
One question has kept returning: who puts knowledge into the machine? In a rule-based system, people write much of the structure linking conditions and consequences. In machine learning, many behaviors are estimated from data.
Someone still chooses a representation, model family, objective, data and adjustment procedure. The difference is that the result needn't be a collection of individually written decisions. The procedure seeks parameters that work well on the available examples.
Let's use a message filter. Writing “if it contains promotion, mark it as spam” is a manual rule. It may catch a scam and also a legitimate message from a store you follow. A learned approach receives categorized messages and searches for useful regularities: word combinations, sender patterns or other features.
The labels are the answers supplied during training: spam or legitimate message in this example. The model predicts, compares with the labels and is adjusted to improve according to a chosen measure. This is supervised learning: input examples come with a desired answer.
A label isn't a truth that appeared from nowhere. Someone classified the messages, with criteria, doubts and possible errors. If people disagree on what counts as spam, the machine inherits a version of that dispute. Data represents the world under particular conditions.
Other methods seek structure without receiving a category for every example, such as groups of similar items. This usually falls under unsupervised learning. In other methods, the data's own structure supplies the target: hide part of a text and try to reconstruct it, for example. We call many of these approaches self-supervised.
These are ways to formulate a learning problem, and a task can use more than one. The categories don't measure how intelligent a system is.
probability becomes part of the solution
Not every problem admits a deterministic answer based on complete facts. A sensor is noisy, a word has several interpretations and data covers only some possible situations. Statistics offers ways to estimate regularities without pretending to absolute certainty.
An idea associated with Bayes is updating a belief in light of evidence. Think of a coin that might be biased. Before observing tosses, you have hypotheses about it. The results change how compatible each hypothesis seems with what happened. Updating isn't “believing whatever I want”: it involves relating hypotheses, evidence and assumptions.
Judea Pearl and other researchers developed tools for organizing probabilistic relationships. A Bayesian network represents dependencies between variables through a graph. The diagram helps organize how an observation changes estimates about other conditions. Pearl's laboratory bibliography documents that lineage.
Statistical dependence doesn't establish cause: two values can vary together because a third influences both. Inferring causality requires additional assumptions; drawing an arrow doesn't provide them.
Hidden Markov models played an important role in speech recognition. “Hidden” means the system doesn't directly observe the state it wants to infer. It observes signals produced by a sequence of states and seeks a compatible explanation.
Imagine hearing someone behind a wall. You receive an imperfect signal, not a ready-made transcript. Certain sounds and transitions are more likely than others. A model can combine those probabilities to choose more plausible sequences. Lawrence Rabiner's 1989 tutorial systematized this family's problems and methods.
These pieces give uncertainty different roles: Bayes updates beliefs, networks organize dependencies and Markov models estimate sequences of states from signals. In speech or the ambiguous “bank” sentence, a system can compare alternatives without requiring complete facts.
trees, margins and combinations of models
In language, the change also involved grammars, sentence-structure analysis and probabilistic methods. A parser seeks relationships such as subject, verb and object; a language model can estimate the probability of a continuation. N-gram models do this by observing short consecutive sequences. Brown and colleagues' statistical translation work in 1990 sought regularities in paired translations and combined probabilities with search. It didn't eliminate linguistic structure: it changed how part of it was estimated, rather than relying exclusively on expert-written rules.
Not all machine learning involves a neural network. A decision tree organizes tests in sequence: a test's answer leads down a branch until a decision is reached. Unlike a hand-written tree, an algorithm can choose the tests from examples.
In a message filter, a tree can split data by one feature and then another, seeking better separation of categories. Quinlan's work on tree induction shows how a structure resembling rules can be learned, rather than supplied by an expert.
A tree fitted too closely to a few examples may memorize details. Combining trees built in diverse ways can reduce certain weaknesses. Random Forests, associated with Leo Breiman's work, use trees and random choices to combine predictions. Breiman's original page presents the method.
Methods called support vector machines, or SVMs, seek separation with a good margin between categories. Return to the points on paper. If several lines separate the data correctly, a line squeezed against the points may be more sensitive to small changes. The margin helps choose a boundary with distance from the examples most important in defining it.
With techniques called kernels, certain relationships can be treated as separations in another representation. Representation changes the kind of boundary a model can find, although the switch doesn't make every problem simple. Cortes and Vapnik's 1995 paper is a milestone in this work.
These methods remain relevant because many problems involve tables, moderate data volumes and cost constraints. A system predicting a quantity from a customer record doesn't necessarily need a network with billions of parameters. The right technique depends on the data, objective and conditions of use.
training doesn't prove it works outside training
Training and evaluating on the same examples creates a problem. A model can become excellent at reproducing that set and poor on new cases. A child who memorizes the order of answers on a worksheet hasn't necessarily learned the operation.
That's why separating training and test data matters. Training participates in adjustment. Testing seeks to measure behavior on examples not used directly to adjust the model. Other sets can help choose configurations during development; the caution is not to turn the final test into more training material through repeated attempts.
The term overfitting means fitting training details too closely, harming generalization. Training loss can fall without improving real use: on which data is the graph measuring performance?
There's also data leakage. If information available only after a decision enters training or evaluation, the result becomes artificially easy. Predicting tomorrow with data that exists only the day after tomorrow is a misleading demonstration, even if the algorithm performs every calculation correctly.
how a network adjusts its own weights
During training, a network tries, measures the difference from the target and adjusts its internal numbers. It combines inputs, weights and nonlinear operations; intermediate units feed other units. Let's name the parts of that cycle.
Training starts by defining a measure of error, the loss function. It compares the prediction with the target and assigns a cost. The training procedure seeks parameters that reduce that cost on the available examples.
But a network can have many weights. How do we know which to change, in which direction and by how much? The gradient describes the loss's sensitivity to small parameter changes. Backward propagation, or backpropagation, calculates those sensitivities through the layers using the relationships between operations.
The 1986 paper by Rumelhart, Hinton and Williams was central to popularizing learned representations in intermediate layers. It wasn't the absolute invention of all reverse differentiation: there were predecessors. What gained momentum was a practical way to train networks that could represent more than a simple separator.
Imagine walking downhill without seeing the whole landscape. The local slope indicates a downward direction. Small steps can reduce elevation but don't guarantee finding the landscape's lowest point. In training, the “landscape” is error as a function of parameters, and the slopes are calculated mathematically.
In the experiment below, choose AND or XOR and compare one neuron with a network containing four intermediate units. The network receives all four examples, calculates predictions and adjusts weights. Training is real, performed here in the browser, with the same initialization whenever you reset.
simplified execution · local training
rounds: 0 · mean loss: 0.8664
| inputs | expected | probability of 1 | decision |
|---|---|---|---|
| 0 / 0 | 0 | 31.5% | 0 ✓ |
| 0 / 1 | 1 | 38.8% | 0 ✗ |
| 1 / 0 | 1 | 14.5% | 0 ✗ |
| 1 / 1 | 0 | 19.0% | 0 ✓ |
output weights: -0.99 / 0.32 · output bias: -0.78
Mean loss is binary cross-entropy. Training uses all four examples in the table. Matching them does not measure generalization to other problems.
AND asks for “both on”; XOR asks for “exactly one on.” One neuron can learn a separation for AND. With XOR, trying harder doesn't remove the architectural limit. The hidden layer allows other combinations, and adjustment can reduce the error in this example.
The prediction is a probability; the table applies a threshold to decide the category. Different probabilities can produce the same decision, so counting correct answers and measuring loss answer different questions.
images, sequences and rewards call for different structures
A convolutional neural network, or CNN, exploits local relationships in images. A small filter moves across regions, using the same weights in different places. A learned pattern doesn't have to be relearned separately at every image coordinate. This gives the architecture a useful assumption about how images are organized.
The 1998 work by LeCun and colleagues documents networks and document-recognition applications before AlexNet. The path from pixels to a decision passes through learned representations; the architecture helps exploit spatial structure.
An important predecessor is the Neocognitron, introduced by Kunihiko Fukushima in 1980. Layers combined local-feature detection with tolerance to shifts: recognizing a stroke even when it appears a little farther left or right. Fukushima's paper helps explain the CNN lineage. It didn't use the backpropagation training of later convolutional networks; architectural inspiration and adjustment rules need to be distinguished.
In sequences, order matters. “The dog bit the man” and “the man bit the dog” contain the same words but different relationships. Recurrent networks maintain a state as they traverse inputs. One training challenge is preserving relevant information over many steps.
LSTMs, introduced by Hochreiter and Schmidhuber in 1997, regulate what enters, remains in and leaves an internal state. That's the information flow “memory” describes here.
In reinforcement learning, a system learns to choose actions from consequences and reward signals. A game-playing agent might receive a favorable result for winning and need to discover actions that increase that result's likelihood. The reward may arrive long after the choice; assigning value to intermediate actions is part of the difficulty.
Richard Sutton developed temporal-difference methods, and Watkins and Dayan's Q-learning became a reference. These methods learn value estimates and guide decisions. They don't presuppose natural language or depend on a user having a conversation.
In temporal-difference learning, systematized by Sutton in 1988, a prediction can be updated by comparing it with a recent reward and a new estimate of what will happen next. Imagine revising your arrival-time estimate after completing part of a journey, without waiting to arrive before learning anything. In games, this helps assign value to intermediate situations.
Q-learning learns action values in states and can update a target strategy using experience collected by another strategy; this distinction is called off-policy. Exploring an alternative doesn't require considering it the best future action. The 1992 convergence proof depends on assumptions about exploration, update rates and the environment. It doesn't promise that any agent will learn any task simply by receiving rewards.
Rewards can also be badly designed. A system can maximize a recorded number without achieving the objective a person intended. Learning to earn points isn't learning justice, prudence or human intention. Decades later, when human preferences and verifiers are used to adjust language models, this difficulty will reappear at another scale.
What to retain from these families: the problem type, model structure and learning signal are different choices.
| Question | Examples from this section |
|---|---|
| Which regularity should we seek? | trees learn splits; SVMs seek margins; probabilistic models represent uncertainty. |
| How should inputs be organized? | CNNs exploit image neighborhoods; recurrent networks and LSTMs traverse sequences. |
| Where does the adjustment signal come from? | labels in supervised learning, data structure in self-supervision, consequences in reinforcement learning. |
These choices can be combined. More data and computation would allow some of them to be tested at another scale.
data and computers change the scale
a chess victory without a chess player's brain
In 1997, Deep Blue defeated Garry Kasparov in a six-game match. The victory carried enormous symbolic weight: a computer beat one of history's greatest chess players in an activity used to exemplify human intelligence.
The score was 3.5 to 2.5. According to IBM, the system could examine about 200 million positions per second. That number measures search on that hardware. It doesn't convert to a player's "thoughts per second."
The system combined search, position evaluation, domain knowledge and specialized hardware. It wasn't a language model and didn't learn chess like later neural systems. IBM's preserved history documents the result and its engineering.
Think of a player looking a few moves ahead. Every action opens possible responses from an opponent. The combinations grow, and evaluating everything through the end of the game is impractical. A system can explore part of the tree, discard possibilities and estimate which positions are more favorable. Domain knowledge helps decide what to investigate and how to evaluate what it finds.
The victory shows that performance can be achieved through mechanisms different from a person's. We needn't attribute the human experience of enjoying chess, feeling pressure or having conscious intuition to recognize that the program played extraordinarily well.
It also shows the limit of a narrow task. Winning chess doesn't automatically confer the ability to drive, translate or understand conversation. The board has explicit rules, a representable state and a relatively clear objective. The world outside has very different conditions.
Reinforcement learning already offered another path in games. Gerald Tesauro's TD-Gammon used networks and temporal-difference learning to play backgammon, exploring game outcomes. His 1995 account documents the work. Search and learning continued developing and would later be combined in other systems.
why does a graphics card help train a network?
In 2006, Hinton, Osindero and Teh presented a deep-network training method with a layerwise pretraining strategy. The paper on deep belief networks helped revive interest in these networks. "Deep" refers to multiple layers of learned operations.
Training many layers was difficult for reasons of optimization and cost. An expressive architecture isn't very useful if the adjustment procedure can't find a good solution or requires unfeasible resources. Training methods and available resources were changing those conditions.
Some of those conditions came from GPUs, graphics processing units. Drawing a scene involves many similar operations on many elements. That work favors parallel processing. Neural networks also perform enormous numbers of multiplications and additions on groups of numbers.
A matrix arranges values in rows and columns. Such a table lets us collect relationships and calculate many combinations at once. When a layer combines several inputs with several weights, matrix operations provide an efficient language and implementation.
A GPU can execute many of these calculations at high throughput. The gain depends on memory, data layout, workload size, data movement and implementation. Adding powerful hardware to a program that spends its time waiting for data doesn't solve the whole problem.
A practical bridge was CUDA, announced by NVIDIA in 2006, with tools made available in 2007: researchers could use GPUs for computation beyond graphics. In a 2009 study, Raina, Madhavan and Ng reported gains of up to 55 times over a dual-core CPU. A network configuration with roughly 100 million parameters went from weeks to about one day. The number belongs to that experiment; the milestone is making larger experiments practical, not promising the same gain for every program.
ImageNet: data is infrastructure
A network needs examples, and evaluating progress requires comparable conditions. ImageNet, introduced in 2009 by Jia Deng and colleagues, organized a large image database by category. Fei-Fei Li played a central leadership role in that effort.
Building the dataset took work. Collecting, organizing and annotating images required design and human labor. People defined categories, selected examples and produced labels. The ImageNet paper documents its construction.
The 2009 presentation described 3.2 million images, 5,247 categories organized through WordNet and twelve major branches of that hierarchy. Some verification used Mechanical Turk workers. These figures describe that version, not every later version's size or each competition's subset.
A dataset is an organized collection of data used in a study. A benchmark is an evaluation setup that allows results to be compared. They may be related but aren't the same thing. One dataset can serve many experiments; an evaluation chooses data, tasks, measures and conditions.
Having a common benchmark changed vision research. Teams could compare methods on a shared task. This encourages measurable progress but can narrow incentives: improving that test's score doesn't necessarily solve every difficulty of vision in the real world.
In 2012, AlexNet, by Alex Krizhevsky, Ilya Sutskever and Geoffrey Hinton, demonstrated a striking advantage in the image-classification competition. The combination involved CNNs, GPUs, lots of data, and training and regularization choices. None of these ingredients can be erased from the explanation.
The original paper reports a top-5 error of 15.3% versus 26.2% in the 2012 competition. “Top-5” accepts the correct category among five suggestions. This isn't the error rate for any possible image, or the same measure as requiring one correct answer.
The 15.3% belongs to a combination of seven networks submitted to the competition. The network described in the paper had about 60 million parameters; on the ILSVRC-2010 test, the PDF reports 17.0% top-5 error. Distinguishing edition, set and model combination matters even for such a famous historical result.
With deep learning, a network also learns the representations used to solve the task. In many earlier approaches, people designed features manually: edge patterns, shapes, frequencies or combinations that seemed relevant. Deep networks began learning many of those transformations along with the final decision.
People still choose the dataset, objective, architecture and training. Some work shifts: instead of manually designing every useful feature, part of the representation can emerge from adjustment over examples.
words become positions, sequences become memory problems
In language, embeddings are vector representations: lists of learned numbers representing words, tokens or other objects. Word2Vec, associated with work by Mikolov and colleagues in 2013, made the usefulness of those representations especially visible.
Imagine a city map with many dimensions and coordinates learned from usage. Elements used in related contexts can acquire useful relationships in that space. The original work investigates efficient word representations. We needn't interpret every coordinate as “how happy this word is” or “how human it is”; the value lies in the whole representation and the operations it permits.
Vector analogies aren't universal semantic laws. The map reflects regularities in data, including inequalities and problematic associations.
In 2014, seq2seq models demonstrated a neural way to map one sequence to another, such as an input sentence to its translation. The paper by Sutskever, Vinyals and Le used LSTMs. One part encoded the input; another produced the output.
Compressing a long sentence's information into a fixed representation creates a bottleneck. You can grasp the difficulty without mathematics: read a paragraph, close the book and try translating everything using only what you retained in a very small summary.
Bahdanau, Cho and Bengio proposed an attention mechanism so the translation process could consult representations of input parts while producing output. The work was made available in 2014, before the Transformer. The translator learned to combine information from different positions, an operation we'll follow in the next section.
generating, going deeper and learning to play
Generative adversarial networks, abbreviated GANs, proposed by Goodfellow and colleagues in 2014, set up a game between two models. A generator produces examples; a discriminator tries to distinguish generated examples from the real dataset. Their objectives oppose each other, and training can improve generation.
You can compare it to a counterfeiter and an inspector: one tries to produce something convincing, the other to identify its origin. In the program, these are two functions adjusted through optimization. The GAN paper describes the construction, which also faces difficulties with stability and result diversity.
ResNets introduced residual connections: paths that combine a representation with a learned transformation of it. This helped train very deep networks. He and colleagues' work, released in 2015 and presented at CVPR in 2016, made clear that depth needed an architecture supporting information flow and adjustment.
In reinforcement learning, DQN combined deep networks with value learning to play Atari from pixels. The initial 2013 work preceded the 2015 Nature paper. A network could learn useful representations for acting without first receiving a manual list of every relevant visual feature.
AlphaGo combined policy networks, value networks and search. A policy guides actions; a value estimate helps assess positions; search explores alternatives. The January 2016 paper documents the victory over Fan Hui, and the match against Lee Sedol took place that March. The original paper makes the combination visible, not a victory of “networks alone” over everything else.
Sizes and conditions tell another part of the story: ResNet presented 152-layer networks; the 2015 DQN paper evaluated 49 games, training a separate agent for each game with the same general recipe. AlphaGo beat Fan Hui 5–0 in October 2015, before publication, and Lee Sedol 4–1 in March 2016. These weren't a single model that could play any game without training, or demonstrations outside their evaluation rules.
Transformers and reusable models
first, language has to become input
A computer doesn't receive a word as a ready-made idea. It receives a representation. In language models, text is usually split into tokens, units that may correspond to words, word fragments, punctuation or other sequences, depending on the tokenizer.
“Token” here means something different from the certificate token discussed in the cryptography post. It's a unit of text processing. The same word appears in several technical contexts; learning the specific concept prevents confusing unrelated functions.
Why split text this way? A vocabulary containing every possible word and variation would be enormous and still encounter new forms. Using only very small units makes sequences longer. Methods that learn frequent combinations offer a compromise: common sequences can become reusable units, while others are represented in pieces.
The byte-pair encoding algorithm, BPE, offers one way to build those combinations. In the experiment below, the algorithm starts with the text's bytes and merges repeating adjacent pairs. You choose how many merges to use and can reconstruct the text from the resulting tokens.
simplified execution · local merges
Bytes that do not yet form a UTF-8 character appear in hexadecimal (0x…). ␣ represents a space.
t + h → thth + e → thethe + ␣ → the␣
the cat saw the rat and the cat saw the house✓ decode(encode(text)) == text
This experiment teaches an operation but doesn't represent every commercial model's tokenizer. Vocabulary choice, character handling and training data matter. Portuguese, code, numbers and other text types can occupy different token counts for the same apparent amount of information.
After splitting, each token is associated with a numerical representation. Layers operate on those representations. These are learned values, used in layer calculations and transformed according to context. There's no dictionary definition attached to each token.
This also explains why small text edits can change behavior. Token boundaries can differ, positions change and relationships between representations are recalculated. A surface that looks almost identical to a person can produce a different input for the system.
attention is an operation, not a mental state
Return to the sentence: “the cat slept because it was tired.” To a person, “it” can refer to the cat. For a model, a useful question is how to let the representation at “it” combine information from other positions in the sequence.
In attention, scores calculated from representations are converted to weights, and those weights guide a combination of values. One position can use more information from a second and less from a third. In self-attention, the same sequence supplies the positions being queried.
“Attention” names this mathematical operation, not subjective concentration. Its weight map alone doesn't explain the network's entire behavior.
The visual below uses chosen weights to teach the mixture, without running a Transformer. It considers a reading of the complete sentence. In next-token models, masks restrict which positions can be consulted; a position cannot use a future it still needs to predict.
illustration · authored weights
choose the position that queries the others
1. separate positions
theposition 1catposition 2sleptposition 3becauseposition 4itposition 5wasposition 6tiredposition 7
each unit receives a representation, and position helps distinguish order. whole words are teaching units here; a real tokenizer may split them.
weights invented for this explanation; not measurements from a Transformer
what changed in 2017
The paper Attention Is All You Need, by Vaswani and colleagues, introduced the Transformer in 2017. The architecture used attention as its central mechanism in place of the recurrence organizing many earlier models. The original paper investigated translation tasks.
A recurrent network has a dependency between steps: the next step's state depends on the previous one. That makes many calculations difficult to perform simultaneously. The Transformer made it possible to process many positions in parallel during training, better exploiting the hardware becoming central to the field.
That parallelism applies during training. In autoregressive generation, each next token depends on context, including earlier tokens: the output remains sequential.
Order also needs to enter the representation, because mixing positions without order information would lose distinctions between sentences. The original Transformer uses positional information. Its architecture includes other operations, such as layers transforming representations and residual connections. The paper's title shouldn't be read as a literal inventory containing attention and nothing else.
Multiple attention heads allow different projections and combinations in parallel. One analogy is examining the same sequence through several views. But we shouldn't label a head “the head that understands pronouns” without investigating the model: distributed representations are more complicated than those labels.
Attention also has a cost. In the traditional dense version, combining every position with every other makes the work grow approximately with the square of sequence length. Doubling context doesn't necessarily cost only twice as much in that operation. Later architectures and techniques seek to reduce bottlenecks, but the limit explains why long context involves difficult engineering.
three ways to organize the same family
The Transformer opened several model families. One way to follow them is to distinguish the roles of input and output.
An encoder builds representations of an input. BERT, introduced by Devlin and colleagues in 2018 and published in 2019, made pretraining representations with context from both sides especially effective. One important task was reconstructing masked parts of text. The BERT paper documents the approach and adaptation to later tasks.
An autoregressive decoder produces sequences by successively predicting the next token, with access to the permitted context. The GPT lineage explored this direction from 2018, as described in OpenAI's initial work. To produce “the cat slept,” the system operates on context, selects a continuation and uses the result to continue.
An encoder-decoder architecture represents an input and generates an output conditioned on it. T5, by Raffel and colleagues, organized many tasks as “text-to-text”: a textual input is transformed into another textual output. The T5 work systematizes comparisons of data, objectives and transfer.
These are architectural categories; a product can combine several with tools. Its commercial name doesn't reveal that composition.
a broad base, adaptable later
Pretraining is a broad learning phase before later adaptations. In a large language model, the task of predicting or reconstructing text can be built from the corpus itself. A person doesn't need to write the ideal answer to every possible future question.
Fine-tuning, a stage of further training, adapts a model to a task, domain or behavior. Here, parameters change. Putting instructions and examples in context changes the input with parameters fixed, although the resulting behavior may change substantially.
GPT-3, described by Brown and colleagues in 2020, made this distinction especially visible. The largest model in the study had 175 billion parameters and could perform several tasks from instructions and examples in its context. The GPT-3 paper documents conditions, results and limits.
Showing two translations and requesting a third lets the model use their pattern in that execution: this is in-context learning, with fixed weights, as in the earlier distinction between input and training.
Interest in scaling laws grew with empirical regularities between data quantity, model size, computation and loss. Kaplan and colleagues' 2020 work documents these relationships. They're useful experimental relationships for planning resources, not guarantees of equal gains in every quality measure.
In 2021, Stanford researchers proposed foundation model for bases trained on broad data and adaptable to many tasks. Bommasani and colleagues' report discusses opportunities and risks: reusing a base can spread capabilities and also propagate its failures across applications.
beyond text, beyond conversation
CLIP, by Radford and colleagues, learned relationships between images and textual descriptions. The 2021 paper shows how representations of the two modalities can be aligned. This offers another bridge: language can help organize vision tasks without being the system's only input.
Training used 400 million image–text pairs. The contrastive objective brings matching representations closer relative to alternatives: a description should match its image better than another. This enabled evaluation of zero-shot transfer, without retraining for that specific task, using textual category descriptions. Zero-shot doesn't mean the model never encountered related concepts during pretraining.
Multimodality means working with more than one information type, such as text, images, audio or video, learning relationships according to architecture and training.
AlphaFold offers a path different from general-purpose conversation. It used neural methods for protein-structure prediction, with striking results in scientific evaluation. Jumper and colleagues' 2021 paper documents the approach and experiments.
Predicting a structure helps with important scientific problems. It still differs from automatically knowing every biological function of a protein or dispensing with experiments. This caution preserves the achievement's scale without making it an explanation of all biology.
These applications already extended beyond language: relating images and descriptions, adapting a base to different tasks and predicting protein structures. In 2022, the conversational interface would make some of this research much easier to use.
So far, three choices help locate the models: BERT represents an input, GPT generates continuations and T5 transforms an input into another sequence. Pretraining produces a base; fine-tuning changes its parameters; examples in context guide an execution with fixed parameters. Multimodality expands input and output types. The family map gathers these relationships for reference.
AI enters everyday life
from predicting text to answering a person
Predicting the next token can teach useful language regularities, but that objective doesn't directly equal answering a question well. An internet text can continue a sentence with sarcasm, fiction, error or quotation. An assistant needs more specific behavior.
The process of instruction tuning uses examples of requests and desired responses to guide that behavior. Asking “explain photosynthesis to a child” differs from merely requesting the continuation of a textbook passage. The model needs to respond to the request, and training can emphasize that pattern.
InstructGPT, described by Ouyang and colleagues in 2022, combined human demonstrations, response comparisons and subsequent adjustment. In one stage, people wrote examples. In another, they compared alternatives, and those preferences helped train a reward model. The language model was then optimized to produce better-rated answers.
This process is a form of reinforcement learning from human feedback, or RLHF. The InstructGPT paper documents the stages. What changed was the objective: predicting text was complemented by signals about desired behavior in an interaction.
In the study, a tuned 1.3-billion-parameter model was preferred to 175-billion-parameter GPT-3 on the evaluated distribution. This teaches an important distinction: size, prediction quality and usefulness to a user aren't the same measure. A larger model may be less prepared to follow the kind of request it received.
A confident, brief or agreeable answer can please people while being wrong. Human evaluation depends on instructions, knowledge and criteria, so approval and factual truth can diverge.
That's why “alignment” shouldn't become a word that ends the discussion. It can mean following instructions, respecting policies, avoiding certain behaviors or serving social values. These objectives can conflict and require continuous evaluation. RLHF addresses parts of the problem; it doesn't settle the whole relationship between a machine and human interests.
Constitutional AI, associated with Anthropic's research, investigated another combination: written principles guide criticism and revision, and model-generated feedback can participate in training. The original research describes a procedure; “constitution” names the principles used, not a guarantee that a system has ethics of its own or perfectly applies any value.
the interface changed the technology's reach
Human feedback also has predecessors: 2019 experiments with GPT-2 already used preferences to adjust behaviors such as summarizing. In 2022, training and public access would bring these techniques to many more people.
ChatGPT launched on November 30, 2022. The original announcement described its relationship to GPT-3.5 models and human-feedback training. The conversation window made it much easier to try a technology that had previously reached many people through demonstrations, papers or less visible integrations.
You could write a question, watch an answer, request a revision and continue in the same thread. This reduces the distance between curiosity and using the system. No programming language was needed to try a summary, explanation or draft.
A new interface can be an enormous historical change even when it combines earlier techniques. A product's importance isn't measured only by whether it invented an architecture. Distribution, access, integration and user experience change who can do what.
Conversation context also lets a later request refer to an earlier one. “Make it shorter” means little in isolation and a lot when the earlier answer is available. This can look like personal memory, but we need to distinguish history presented to the model from permanent changes to its parameters.
In 2023 and 2024, products from several organizations expanded public use of language, code and multimodal models. GPT-4, Claude, Bard/Gemini, Llama and Mistral illustrate paths with different access and distribution regimes. These models entered everyday tools through different forms of access.
That's when chatbots came to occupy so much of the conversation about AI. That was the frustration behind the previous post: using one of these tools began to be confused with knowing the whole field.
A few dates help separate model from interface. GPT-4 appeared on March 14, 2023; its report omitted details of architecture, hardware and training data. Claude 2 arrived in July, Mistral 7B in September and Mixtral 8x7B in December. Google introduced the Gemini family in December 2023, before renaming the Bard interface to Gemini in February 2024. Product name, model family, license and availability are different pieces of information.
hallucination: the sentence fits, the fact may be missing
A language model can produce a fluent answer that doesn't match facts or available sources. The field calls many such cases hallucinations. The term is a metaphor for system output, not a human diagnosis.
Consider asking for a paper's name and reference. The model knows patterns of titles, authors, journals and dates. It may produce a combination resembling a bibliography that doesn't correspond to an existing document. The form can be convincing precisely because training taught regularities of that form.
The model may have learned useful information and still produce an incorrect reference. Fluency doesn't check whether a paper exists; that check needs to enter the answer's evaluation.
Getting a calculation wrong, citing a nonexistent source, omitting a condition and following an improper instruction are different failures. The general category helps discuss a problem, but evaluating a system requires separating failure types. One percentage can hide very different behaviors.
Nor is “don't hallucinate” enough. The instruction is part of the input, but doesn't create evidence or guarantee the model recognizes its gaps. More reliable systems combine training, suitable data, tools, evaluation and workflow design.
consulting documents changes the input
A high score can hide benchmark contamination: if evaluation questions or answers were in training material, the test no longer measures only performance on new examples. Format, tools, attempt counts and inference budgets also need to be comparable. A familiar exam doesn't demonstrate general intelligence, and scaling doesn't guarantee eliminating hallucinations.
The same caution applies to so-called emergent abilities. A skill seems to appear suddenly when a score jumps beyond a certain size. But an “entirely right or entirely wrong” metric can hide gradual improvements in individual steps. A 2023 study showed this effect in specific evaluations. Measurement can create the appearance of a leap. The study doesn't justify dismissing every new capability as illusory.
One way to bring in current or specialized information is to retrieve documents and place them in context. RAG, retrieval-augmented generation, combines a retrieval stage with generation conditioned on the retrieved material. Lewis and colleagues' 2020 paper is a reference for this approach.
Imagine asking for a museum's opening hours. The model may have seen outdated information during training. An application can consult the current page, select a passage and supply it with the question. The answer now has a source available in that execution.
The lookup adds information to context, like the earlier examples, without updating weights through that operation. The document needs to be available in the execution where it'll be used.
RAG also doesn't guarantee that the application found the correct document or interpreted it well. Search may select another museum branch, a passage may omit a holiday and generation may confuse conditions. Retrieval and the answer need evaluation, along with the source's quality.
learning to remove noise to generate images
The popularization of image generation has its own technical history. Diffusion models learn operations related to a process that adds noise to data and a generative path that progressively removes noise.
During training, we can start with an image and add known levels of noise. The model receives perturbed versions and learns an estimation task associated with that process. During generation, we start from noise and apply learned transformations to construct a sample.
The 2020 work by Ho, Jain and Abbeel is a milestone in this family. Generation produces a new sample using learned regularities, conditioned or not on information such as text. It doesn't reveal a photograph that was already hidden in the noise.
The visual is schematic: it shows a drawing of a house becoming visible as a programmed noise layer is reduced. It illustrates a path but doesn't execute a diffusion model's mathematical procedure or generate a new image from a prompt.
illustration · fixed drawing
1. noise: in a real generative process, the sample starts from a noise distribution. this visual uses a reproducible pattern.
go back: add noise · The drawing becomes clearer in six stages. The final image is programmed: no model generates images here.
In latent diffusion, models perform part of this work in a compressed representation rather than always operating directly on every pixel. Rombach and colleagues' paper, made available in 2021 and published in 2022, explains this combination of efficiency and conditioning.
DALL-E 2, Stable Diffusion and Midjourney helped make text-to-image generation a public activity in 2022. They brought together generative methods, language representations, data, hardware and interfaces. A beautiful image, like a fluent sentence, needs its own evaluation: fidelity to the request, diversity, rights, biases and possible reproduction of training examples.
Visual generation also has different paths. The original DALL-E, from January 2021, used an autoregressive Transformer, not a diffusion model. Diffusion became especially visible to the public in 2022, including through Stable Diffusion. Generative video added the need to maintain relationships over time: producing a convincing frame doesn't guarantee an object keeps its position and identity in subsequent frames.
adapting and reducing cost
As large models became reusable bases, demand grew to adapt them without repeating all of training. LoRA, proposed by Hu and colleagues in 2021, learns lower-dimensional updates to certain operations. The original paper explains how to reduce the set of adjusted parameters.
Quantization represents values with lower numerical precision. This can reduce storage and memory requirements, with consequences depending on the model and technique. QLoRA, described by Dettmers and colleagues in 2023, combines quantization and low-rank adaptation to make certain adjustments more accessible. These are cost reductions at specific stages; training still requires resources.
Distillation trains one system to reproduce another's behavior or signals. It can produce a smaller model retaining some utility, though not automatically every capability. It's a way to transfer behavior under an objective and a collection of examples.
Adapting a model and reducing its memory requirements helps when the question becomes "how much does putting this into an application cost?" Cost and latency also depend on engineering around the network.
reasoning, tools and agents
spending computation while solving
If you entered here, it's worth revisiting training and inference and document retrieval. The question now is: how much work does a system do after receiving a problem and before delivering an answer?
There are several ways to spend more computation at this stage. Producing candidates, comparing alternatives, revising an attempt, searching and checking are examples. The goal is to improve a solution using a larger processing budget during execution.
Requesting intermediate steps in a prompt was already a research direction before 2024. The later change involves combining that possibility with training and resource-allocation strategies. Test-time compute names this axis of computation during problem solving.
The 2024 work by Snell and colleagues studied tradeoffs between model size and processing during problem solving under specific tasks and conditions. Gains depended on the task and the distribution of processing. The comparison opened another option beyond increasing model size, without establishing universal superiority.
In certain comparisons with equivalent operation budgets, inference strategies outperformed simply using a model 14 times larger. Problem difficulty and processing allocation changed the result. The number describes an experimental comparison, not a substitution rule between any pair of models.
OpenAI o1, introduced in September 2024, made this regime especially visible in products. The company described reinforcement training and gains from greater computation during problem solving. The announcement is a source for the launch and reported results; performance comparisons need to preserve their conditions and origin.
DeepSeek-R1, introduced in January 2025, broadened access to models and distillations associated with reinforced reasoning. The technical paper distinguishes R1-Zero, R1 and distilled models. These variants shouldn't be treated as the same procedure under interchangeable names.
“Reasoning” here names capabilities and strategies investigated on problems. Longer steps can contain errors, and a generated explanation doesn't necessarily reveal the internal process leading to the result.
verification changes the game
In reinforcement learning with verifiable rewards, sometimes abbreviated RLVR, an answer can receive a reward for passing tests or reaching a verifiable result. Verification reduces dependence on someone comparing every solution, but the test must represent the task. FastCuRL, from 2025, investigated this approach with a 1.5-billion-parameter model and eight GPUs, adjusting example difficulty and solution length. The example shows a smaller scale than the largest industrial training runs, under the evaluated task's conditions.
If the system generates code, a tool can run tests. If it proposes a move, an environment can measure the result. If it answers a problem with a verifiable answer, there's a clearer signal for comparing attempts.
This makes training and candidate selection easier. A verifier provides information the answer's appearance alone doesn't. An elegant program failing a test needs correction; a less elegant alternative may satisfy the measured condition.
But a verifier checks only what was defined. Incomplete tests can accept a buggy program. A numerical answer may be right through an invalid path, depending on the task. A solution can pass a test and fail when requirements change.
For open-ended topics, such as explaining a historical event or advising an organization, quality is harder to condense into an automatic reward. Sources can disagree, conditions can be missing and values can conflict. Progress in mathematics cannot simply be declared transferable to every form of human judgment.
a tool provides access beyond the weights
A model can produce a structured request for software to perform an action. That action may query a database, run a calculation, open a document or operate another application. The external program executes and returns a result, which enters the context.
When an application consults a calculator and returns the calculation to the model, that's tool use. To evaluate the system, we need to know which result came from the tool and how the model used it, rather than attribute the entire calculation to the network.
An agent, in the sense used by many current systems, puts these operations into a cycle: observe, choose an action, execute a tool, read the result and decide how to continue. “Agent” has a history before LLMs; the term wasn't invented for a chatbot calling a tool.
Let's follow an example: find two museums' opening hours and create a sourced table. The simulation below shows both a path obtaining the information and another with an incomplete result. It doesn't consult real museums, execute tools or contain information you can use to plan a visit.
flow simulation · fictional results
- 1observe
- 2plan
- 3retrieve
- 4read results
- 5verify
- 6answer
observed result
fictional request: create a table of opening hours for Museum A and Museum B
the system receives the task and conditions: two museums, opening hours and verifiable sources.
local simulation: no tool executes and no external information is fetched
A tool also has permissions. Knowing how to write an action request doesn't automatically grant access to the world. The application defines which tools exist, which data can be seen and which operations are allowed.
Anthropic announced the Model Context Protocol, MCP, in November 2024 as a protocol for connecting AI applications to sources and tools. The original announcement documents the proposal. A common protocol simplifies connections; it doesn't itself provide memory, competence, safety or unrestricted authorization.
context is part of the engineering
The model receives input organized by the application: instructions, history, documents, tool results and task state. Context engineering describes selecting and organizing that material.
If important information was left out, the model can make a poor decision even if it could use that information when provided. If context mixes a trusted instruction with external text trying to command actions, the application needs to distinguish their roles.
A prompt injection exploits that boundary: text found in a document or page tries to be treated as an instruction to the system. The problem involves integration and control as well as model behavior. A document an agent reads shouldn't inherit the authority of whoever requested the task.
Errors can also accumulate in long tasks. A search returns the wrong page, a summary loses a condition and an action uses that summary. The final result can look well organized while carrying a failure from three steps earlier.
A large context window says how many tokens can fit, not that they're all used equally well. In Lost in the Middle, from 2023, some models had more difficulty when relevant information was in the middle of long texts. Imagine handing over a whole folder and asking for a date hidden on page 87: fitting in the folder and finding the date are different things. The result needs reassessment for each model, version and task, not a universal condemnation of long context.
the frontier in October 2026
At the October 10, 2026 cutoff, variants prioritizing capability, speed and cost coexist with multimodal systems and products integrating tools. Access comes through conversational interfaces, application programming interfaces (APIs, used by other software) and distributed weights, under different conditions. The announcements and access table retains examples and sources; it's a dated snapshot, not a ranking.
Distributed weights, available code, published data and a reproducible training recipe are different dimensions of openness. The specific artifact's license also matters. “You can download it” doesn't settle all these questions.
The OSI Open Source AI Definition specifies freedoms to use, study, modify and share, and requirements for components. Open weights conveys something narrower. Weights can be distributed with restrictions or without sufficient information to study and modify the system under that definition.
Smaller models and local execution coexist with large-scale services. Quantization, distillation and specialization can reduce requirements. In mixture-of-experts, or MoE, architectures, different parts of the model activate during processing; total parameters and parameters used in an operation needn't coincide. “Experts” here names architectural components, not human professionals with defined disciplines.
Gemma and Ministral, along with Qwen variants and R1 distillations, exemplify this direction. On-device execution can reduce latency, enable use without a constant connection and keep certain data local. Those benefits depend on the application and its other components: downloading a model doesn't guarantee a private end-to-end workflow or compatibility with every phone.
In programming, the system around a model is often called a harness. It supplies an editor, terminal, tests, execution limits and context assembly. An agent can edit, test, observe a failure and revise. Grok Build opened components of this system in July 2026, including tools, MCP and subagents; that isn't publishing model weights. Subagents are processes receiving subtasks, unlike internal “experts” in an MoE architecture. Coordinating processes adds communication and completion criteria, not an automatic guarantee of correctness.
The field's current state combines networks, search, representation, external memory, tools, verifiers and infrastructure. Some pieces are recent; others are decades old. Systems can do more because the pieces are connected, but can also fail at their boundaries. The connections need evaluation too.
the history beyond models
We've reached current systems by following methods. Now let's examine the other axis announced at the beginning: applications, institutions, infrastructure and impacts — where systems were already used, who builds them and what sustains them. This work was present in earlier periods, even when the narrative followed an algorithm or demonstration.
the AI you already used without calling it AI
You probably used other forms of AI before opening a chatbot: receiving a movie recommendation, using speech recognition or searching for something in an image.
Recommendation systems organize films, products, music and posts. One familiar approach seeks regularities in people's and items' preferences: those who chose similar things may be interested in other related things. Others learn representations and predictions from interactions.
This includes collaborative filtering and matrix factorization. Imagine a table whose rows are people and columns are films, with most ratings missing. Factorization learns smaller representations of people and films that help estimate missing values. It needn't consciously know why someone likes a film to find useful regularities; nor can it treat an estimate as a guaranteed preference.
The chosen objective influences behavior. Maximizing clicks isn't the same task as increasing diversity, lasting satisfaction or information quality. A system can improve its recorded metric while degrading something it didn't measure.
There's also a cycle: the system selects what a person sees, the person reacts to the selection and the reaction becomes new data. The data records responses to options the system showed, not every option the person could have chosen. This cycle also occurs outside social networks.
Recognition and synthesis of speech have their own histories, from statistical models to neural and multimodal systems. Transcribing audio, producing a voice and interpreting a spoken request are distinct tasks, though an interface may combine them. An underrepresented accent or background noise can change part of the workflow before the question even reaches the language model.
In older systems, acoustic and language models were separate components. Later neural approaches expanded end-to-end training, mapping audio directly to text and also audio to audio. This reduces some divisions in the workflow; it doesn't remove the need to evaluate transcription, content, voice and conditions of use.
In computer vision, locating objects, segmenting an image, classifying a scene and relating images to text are also different problems. Improving a classification measure doesn't automatically solve perception in traffic, industrial inspection or scientific imaging. We need to know which task was evaluated.
Beyond CNNs, the Vision Transformer, released in 2020, divided images into patches and treated their representations as a sequence. Hand-designed descriptors, CNNs and Transformers seek useful representations through different paths to solve vision problems.
In robotics, the tradition of control and feedback remains essential. A vision-language-action model seeks to connect perception, instruction and physical behavior. But moving an arm requires sensors, localization, control and contact with objects. Error tolerance depends on the situation, and a plausible sentence doesn't replace a physically safe action.
In the 1980s, Rodney Brooks explored layers of reactive behavior: a robot could respond to obstacles without first building a complete symbolic description of everything. Another path probabilistically estimated where a robot was and what its environment looked like. Work by Thrun, Fox and Burgard linked simultaneous localization and mapping, usually abbreviated SLAM. A sensor is uncertain; observing and updating estimates can be more useful than pretending to have a perfectly known map. These approaches coexist with planning and control.
VLA, from vision-language-action, names the connection between vision, language and action. A model such as Qwen2.5-Omni, from March 2025, combines text, images, audio and video without thereby controlling a robot. Qwen3, from April, emphasized direct-answer and deliberative-processing modes. “Multimodal” alone doesn't tell us which inputs, outputs and actions a model supports.
In science and healthcare, models can help analyze images, predict structures, organize documentation and support research. Required evidence varies with the use. A research result, regulatory authorization and demonstrated benefit in clinical conditions are different categories; none can silently stand in for another.
AlphaFold 3, introduced in May 2024, extended the problem to interactions between proteins, DNA, RNA and other molecules. Genomics and cellular models also seek regularities in large biological datasets. Predicting a structure or relationship is a scientific contribution; demonstrating that a treatment improves patients' lives requires another evidentiary path.
The AI Index 2026 recorded 258 FDA authorizations for AI-enabled devices in 2025 through September. In a different population, a study published in JAMA in 2025 examined 903 devices authorized through August 2024: 505 had publicly described clinical studies, and 12 of those 505, or 2.4%, included randomized trials. That denominator matters. It doesn't mean 2.4% of the 258 devices from 2025, or that missing public descriptions prove the absence of all clinical evidence.
In 2024, the Nobel Prize in Physics recognized work by John Hopfield and Geoffrey Hinton related to neural networks, and part of the Chemistry prize recognized Demis Hassabis and John Jumper for protein-structure prediction, alongside David Baker's prize for computational protein design. The Physics and Chemistry announcements document that recognition. It encompassed neural networks and scientific applications far beyond chatbots.
a history of countries and institutions
United States companies occupy much of the recent conversation, but we also need to consider research in Europe, Japan, the Soviet Union and China.
Europe appears in the precursors of logic and computing, continues through language, logic programming, statistics and robotics, and remains present in laboratories and companies. Japan's fifth-generation project shows a different industrial and scientific policy, investing in knowledge and parallel computing in ways that influenced international discussions.
The Soviet Union had its own trajectory in computing and cybernetics. Cybernetics' position changed through political and institutional disputes, from a contested subject to a language of modernization in certain periods. Slava Gerovitch's historical study helps explain the relationship between science and political discourse. This history can't simply be translated into being ahead or behind in a single race.
China is central to today's ecosystem, with universities, companies, robotics and model families such as Qwen and DeepSeek. These lines of work show that ideas, skills and infrastructure aren't restricted to one country. Comparing countries requires distinguishing scientific output, industrial capacity, adoption, patents, hardware access and available models.
Patents, released models and investment measure different things. A promised investment, for example, may still be far from delivered equipment. None of these counts alone summarizes the quality of a country's research.
There's also circulation: researchers study and work in different countries, papers cross institutions and implementations reuse published knowledge. Countries and companies are useful units for discussing resources and policy, but aren't closed boxes where an idea belongs forever.
Two measures convey China's scale without conflating activities: the AI Index 2026 attributes 74.2% of 2024 AI patent grants in its database to China; the International Federation of Robotics records 54% of new industrial-robot installations in 2024, around 295,000. Patents and installations measure different activities, and neither summarizes all of a country's research quality.
Brazil didn't enter this history yesterday
Brazil's AI community has a history preceding the generative wave. The SBIA memorial published by the Brazilian Computer Society, SBC, records a first symposium in Porto Alegre in November 1984 and the building of a research community in subsequent decades.
Universities and groups worked on knowledge representation, neural networks, optimization, language, vision and intelligent systems. Institutions associated with this history include UFRGS, USP, Unicamp, UFRJ/COPPE, UFPE, PUC-Rio, ITA and others. The diversity of work exceeds what a short list can represent.
BRACIS resulted from bringing artificial-intelligence and neural-network communities together. The 2025 organizers explain the merger of SBIA and SBRN. The conference brings together communities researching AI and neural networks long before today's assistants.
An important intermediate record is the first National Workshop on Neural Networks and first Neural Networks School, in 1992. BRACIS 2025 identifies itself as the 35th edition in these communities' continuity. This research calendar is much older than the commercial chatbot release calendar.
- 1984first recorded symposium26 yearsPorto Alegre: organization of the community documented in the SBIA memorial.
- 2010SBIA memorial10 yearsthe community records its own history, people and institutions.
- 2020C4AI4 yearsa research center begins with challenges in Portuguese, science and society.
- 2024PBIA 2024–20281 yeara plan for education, infrastructure and applications; targets still require execution and evaluation.
- 2025BRACISthe conference records continuity and convergence between scientific communities.
C4AI, established by USP, IBM and FAPESP, began operating in 2020, addressing Portuguese language, health, environment and work. USP's announcement and FAPESP's page document its formation. It's one example, not the only center or an exclusive national birthplace.
Brazilian Portuguese matters as a research problem. Evaluation in English doesn't establish the same result in Portuguese, and formal written Portuguese doesn't cover every accent, register and context of use. Data and criteria need to represent those who will use the system.
The Brazilian Artificial Intelligence Plan 2024–2028 addresses infrastructure, education and applications. It's a planning document: targets and planned investment must be distinguished from implementation and measured results.
Brazilian records show many institutions and contributions but are less systematic for some periods. Choosing a single "founder of Brazilian AI" would require historical investigation these documents don't support.
the collective work hidden behind a surname
Names help us follow ideas but can distort the story if they hide teams and less visible work. A network trained on millions of examples depends on whoever created, organized, annotated and evaluated them. A product depends on researchers, engineers, operators and people producing preference and safety signals.
Women appear in computing's history from Ada Lovelace onward. Karen Spärck Jones made fundamental contributions to information retrieval and language. Her work on the importance of terms in documents helps explain why a rare word in a collection may convey more than one appearing almost everywhere. The 1972 paper and Cambridge archive preserve that history.
Fei-Fei Li appears in ImageNet's construction; Kristina Toutanova coauthored BERT. In Brazil, the SBC memorial records researchers such as Rosa Maria Viccari and Maria Carolina Monard. Telling these stories through one researcher's name would erase some of the people who did the work.
In impact evaluation, Joy Buolamwini, Timnit Gebru, Margaret Mitchell, Inioluwa Deborah Raji and other researchers helped make questions about disparities, documentation and responsibility explicit. Scientific work includes choosing which errors to seek, not merely lowering an existing average error.
Gender Shades, by Buolamwini and Gebru, examined intersectional disparities in commercial gender-classification systems using images. The 2018 paper has a specific task, sample and conditions. Its result applies to the systems and conditions studied. The question exposes an evaluation problem: a good average can hide much worse performance for certain groups.
Model cards, proposed by Mitchell and colleagues, organize information about a model's purpose, evaluation and limitations. The original work shows that documentation is also part of evaluating technology. An isolated score doesn't tell us for whom, under which conditions and with which risks a system was tested.
Rediet Abebe and colleagues add another question: what can computing do within processes of social change? Roles for Computing in Social Change examines roles and limits of technical contributions. A more accurate model doesn't by itself resolve power distribution, access or institutional decisions. A technical metric may omit those conditions.
the datacenter is part of the model you use
“An algorithm improved” is an incomplete explanation when scale depends on semiconductors, memory, networks and energy. Distributed training needs to move data and coordinate many machines. Fast processing doesn't help if machines spend their time waiting for information or memory can't hold the workload.
GPUs, TPUs and other accelerators offer different computing capabilities. High-bandwidth memory helps feed those operations. Interconnects help machines exchange values. Software must organize the whole system. Bottlenecks change with architecture and task size.
Training cost also differs from usage cost. Expensive training can be amortized across many applications. Cheaper inference can increase use. At the same time, competition at the frontier may demand even larger training runs and infrastructure.
This helps explain why published knowledge and the ability to perform an experiment aren't distributed in the same way. Reading an architecture doesn't give a university the equipment, energy and teams to repeat any industrial training run. Open publication helps ideas circulate, but infrastructure imposes material conditions.
In its 2025 report, the International Energy Agency estimated that all datacenters consumed around 415 TWh of electricity in 2024. Its central scenario projected about 945 TWh for 2030. The energy-demand chapter explains assumptions and scenarios. These figures aren't exclusive to AI, and the 2030 value is a projection from that report.
The 415 TWh represented about 1.5% of worldwide electricity. A relatively small global share can coexist with substantial local pressure when equipment concentrates in one region.
Efficiency per task and total consumption can also move in different directions. If each query uses less energy but query volume grows substantially, the total can rise. A promise of savings needs to specify its comparison.
Locally, large datacenter concentrations can strain electrical grids and other resources even when their global share seems smaller. The "cloud" depends on physical equipment, and its location changes who deals with those costs.
bias, privacy and authorship enter the same history
Bias can arise in data selection, categories, objectives and usage context. An imbalanced set can underrepresent a population. A poorly chosen category can compress different situations into one label. Average accuracy can conceal disparities.
Addressing this takes more than filtering an offensive word. We need to know the task, the groups and conditions represented, and which errors have consequences. Evaluation criteria are also human choices.
Privacy involves collection, access, retention and the possibility of inferring information. A model can memorize certain training examples, and an application can expose documents through poorly configured permissions. These are different mechanisms; calling everything “the model leaked” can hide where a fix is needed.
Copyright involves distinct questions: how material was used in training, whether output reproduces protected expression, who can claim authorship and which license conditions apply. The discussion varies by jurisdiction and still requires case-specific analysis. U.S. Copyright Office reports distinguish, for example, authorship of generated material from training questions. This documentation isn't a single rule for every country.
Human labor doesn't disappear because an interface generates on its own. Building datasets, annotating examples, comparing answers, moderating content and investigating failures help construct the system. That work often remains outside the interface we use.
These decisions influence the system itself: what enters the data, the training objective, who can access tools, how errors are evaluated and who receives benefits.
employment: tasks, jobs and institutions
An occupation comprises many tasks. Automating some can change a routine without immediately eliminating the job. It can also enable team reorganization, increased production or a shift toward checking and correcting outputs.
That's why exposure to AI isn't the same measure as predicted unemployment. A study can identify tasks potentially achievable by a technology; actual outcomes depend on cost, reliability, adoption, organization and economic decisions. The ILO's 2025 study examines occupational exposure and transformation potential.
The AI Index 2026 reports that 88% of respondents in a 2025 survey said their organizations used AI in some function, and 79% reported regular generative-AI use in at least one business function. These are self-reported survey answers, not a census of every company worldwide. Agent use at scale, per function, was much less widespread in most cases. The report, section 4.3, spells out those conditions.
Solving a task, organizational adoption and distributing benefits are different outcomes requiring their own measures.
In the same survey, 32% of respondents expected workforce reductions the following year because of AI, while 43% expected stability. Self-reported expectations aren't counts of actual layoffs. Confusing task exposure, managerial expectations and actual employment changes manufactures certainty the data doesn't provide.
There's also a question of human learning. If someone stops practicing tasks that taught them to check results, they may become more dependent on the system precisely when they need to judge a failure. This isn't inevitable; it's a choice about organizing use, education and review.
Productivity gains also need context. Generative AI at Work, by Brynjolfsson, Li and Raymond, studied customer-support assistance and found heterogeneous benefits, larger for less experienced workers in that setting. Task, organization and experience level change the result. This provides evidence for a concrete application; it doesn't by itself measure the whole economy's productivity or every profession's future.
intelligence, understanding and consciousness aren't one test
Success on tasks reopens old philosophical questions. What counts as intelligence? Performance, learning, adaptation, understanding, general capability? An unspecified definition leaves two people arguing over words while thinking of different criteria.
John Searle formulated the Chinese Room argument in 1980. Imagine a person following rules to manipulate symbols in a language they don't understand. The resulting answer can look suitable from outside. For Searle, this challenges the conclusion that correct symbol manipulation suffices for understanding. The original paper also includes discussion and objections.
In Searle's distinction, weak AI can be a tool for studying cognition; strong AI holds that the appropriate program constitutes understanding. “Strong” here doesn't simply mean a high score or more parameters. Nor is it a precise synonym for AGI: general capability and understanding are different questions.
The argument is philosophical and remains disputed; it wasn't an experiment settling the question. Critiques concern the whole system, representation and its relationship to the world. Traditions that don't fully agree continue to debate the difference between behavior and experience.
LLMs reopen the dispute because they learn representations and demonstrate capabilities beyond fixed scripts. Those capabilities need investigation. Still, an answer saying “I feel” doesn't establish subjective experience: the system was trained to produce language in which people say such things.
A 2023 interdisciplinary analysis of AI consciousness examined indicators derived from consciousness theories. Its conclusion about the systems studied then shouldn't become universal proof about every future model. The question requires criteria, theory and evidence, not an impression created by conversation.
AGI, artificial general intelligence, also depends on a definition and a way to evaluate it. An isolated benchmark, laboratory promise or impressive task doesn't resolve the whole dispute. We need to know the required scope, learning conditions, transfer and reliability.
For governance, initiatives such as the NIST AI Risk Management Framework and the UNESCO recommendation make evaluation and responsibility an ongoing practice. The problem exceeds labeling a technology good or bad in the abstract: it involves purposes, institutions, evidence and consequences.
History demonstrates a sequence of capabilities built, tested, expanded and sometimes overestimated. It doesn't demonstrate that consciousness, general intelligence or automatic replacement of all human activity is an inevitable destination.
The same holds for systemic risks: concentrated power, surveillance, disinformation and institutional dependence aren't reducible to a chatbot getting a sentence wrong. Adversarial testing, or red teaming, deliberately seeks failures; safety evaluations need to track capabilities and uses. The December 2025 Foundation Model Transparency Index recorded a mean of 41 points, versus 58 in the previous edition. Criteria and participants changed, so the comparison needs that caveat. Publishing more benchmarks isn't the same as transparency about data, risks and operations.
what changed from one end to the other
Our path began with forms of reasoning that could be described. Symbols and procedures made those forms representable; computers made it possible to execute them and test programs.
Search and rules worked on prepared tasks, but knowledge and possible alternatives grew quickly beyond them. Learning from examples shifted some of that work. Deep networks began learning representations too, and data, hardware and software enabled training at another scale.
The Transformer helped exploit parallel processing. Pretraining made a base reusable, and instruction and preference tuning changed its behavior as an assistant. With retrieval, tools and verifiers, the application began consulting information and executing operations beyond weights. The conversation interface brought this to many more people.
Throughout these changes, results kept depending on the task, representation and conditions. ELIZA seemed to understand through conversation. SHRDLU operated in a narrow world. Expert systems faced maintenance. Networks needed data and adjustment methods. Language models and agents still need evaluation and well-organized surrounding systems.
A promise of general capability needs to show how it escaped those specific conditions. Succeeding at one task still doesn't give a system authority over every other task.
A token, a weight and a plan now occupy different places in this history. You can revisit the examples and play with the experiments: which values change when the network trains? Where did the agent's answer come from? Which rule made ELIZA ask about family?
That's the step I wanted to take after the previous post. Using the tool can be useful, but studying the subject requires opening these questions and examining what happens inside.
for later reference
The narrative ends above. This section can wait until a question arises: the family map locates methods; the chronology supplies dates; 2026 announcements describe access conditions; the glossary explains terms; common shortcuts check interpretations; and further reading offers depth.
a chronology of changes
Dates of development, demonstration, paper and launch can differ. One milestone here doesn't necessarily carry the same weight as another. Historical links are in the corresponding explanations and readings; recent releases have their own links.
| Date or period | Milestone and significance |
|---|---|
| Antiquity | Aristotle systematizes forms of syllogistic inference, a conceptual ancestor of formal logic. |
| 17th century | European mechanical automata embody the idea of machines imitating complex actions. |
| 1640s | Pascal builds mechanical calculators, part of the long history of arithmetic automation. |
| 1670s | Leibniz develops a calculating machine and articulates ambitions for universal symbolic calculation. |
| 1700s | Leibniz's calculus ratiocinator remains a historical reference for mechanizing reason. |
| 1830s | Babbage designs the programmable Analytical Engine. |
| 1843 | Ada Lovelace publishes notes on the Analytical Engine and discusses symbolic manipulation beyond mere numbers. |
| 1847–1854 | George Boole develops the algebra of logic. |
| 1879 | Frege publishes Begriffsschrift, a milestone in modern logic. |
| 1900 | Hilbert formulates problems helping structure mathematics' formalist program. |
| 1920s | Hilbert's program intensifies the search for formalization and decision procedures. |
| 1931 | Gödel publishes incompleteness theorems, revealing limits of formal systems. |
| 1936 | Church formalizes computability through lambda calculus. |
| 1936 | Turing introduces abstract machines and characterizes computability. |
| 1937 | Equivalences between formalisms support what became known as the Church–Turing thesis; the thesis about effective procedures is distinct from those proofs. |
| late 1930s | Shannon connects Boolean algebra and switching circuits. |
| 1943 | McCulloch and Pitts publish formal neurons capable of logical operations. |
| 1948 | Shannon publishes a mathematical theory of communication. |
| 1948 | Wiener publishes Cybernetics, connecting feedback, control and communication. |
| 1949 | Hebb publishes a theory of learning through associative synaptic modification. |
| 1950 | Turing publishes Computing Machinery and Intelligence and the imitation game. |
| 1951 | Minsky and Dean Edmonds build SNARC, a network experiment in hardware. |
| 1954 | The Georgetown–IBM demonstration draws attention to machine translation. |
| 1955 | Newell, Simon and Shaw develop Logic Theorist. |
| Aug. 31, 1955 | McCarthy, Minsky, Rochester and Shannon submit the Dartmouth Summer Research Project proposal. |
| summer 1956 | The Dartmouth meeting consolidates “Artificial Intelligence” as a research identity. |
| 1956 | Logic Theorist is demonstrated as an automated proof system. |
| 1957 | Rosenblatt develops the perceptron. |
| 1958 | McCarthy begins LISP, which will become central to symbolic AI. |
| 1958–1959 | Perceptrons receive substantial public and military attention. |
| late 1950s | Newell and Simon advance general problem solvers. |
| 1960s | Laboratories at MIT, Stanford, Carnegie Mellon and Edinburgh expand symbolic AI. |
| 1960s | DENDRAL begins exploring systems based on scientific knowledge. |
| 1965–1966 | Weizenbaum develops and publishes ELIZA. |
| 1966 | The ALPAC report criticizes the results of available machine translation. |
| 1966 | The Shakey project begins at SRI. |
| 1969 | Minsky and Papert publish Perceptrons. |
| 1970–1971 | Winograd develops SHRDLU in the blocks world. |
| early 1970s | STRIPS formalizes planning actions through preconditions and effects. |
| 1972 | Early development of MYCIN at Stanford. |
| 1972–1973 | The Lighthill report criticizes British AI's scalability. |
| 1970s | Funding declines in some AI research in the US and UK: the first “AI winter.” |
| 1970s | Prolog consolidates logic programming through French and European work by Colmerauer and Roussel and influences from Kowalski. |
| late 1970s | Expert systems attract renewed commercial interest. |
| 1980 | Fukushima introduces the Neocognitron, an important conceptual precursor to modern CNNs. |
| 1980 | XCON begins demonstrating expert systems' commercial value. |
| 1982 | Japan launches Fifth Generation Computer Systems. |
| 1980s | The Lisp-machine market grows with expert systems. |
| 1986 | Rumelhart, Hinton and Williams popularize backpropagation for distributed representations. |
| 1987–1990 | The Lisp-machine market and commercial expectations for expert systems collapse. |
| 1988 | Sutton systematizes temporal-difference learning. |
| 1988 | Judea Pearl's work consolidates Bayesian networks as a framework for probabilistic reasoning. |
| 1989 | Rabiner publishes a classic HMM tutorial. |
| late 1980s | A second “AI winter” affects companies and funding in parts of the field. |
| early 1990s | Statistical methods gain strength in speech, NLP and pattern recognition. |
| 1992 | Q-learning receives a formal convergence proof under specific conditions. |
| 1992 | Brazil holds its first National Workshop on Neural Networks and first Neural Networks School. |
| 1992 | FGCS ends its eleven-year cycle in fiscal year 1992. |
| 1992–1995 | TD-Gammon demonstrates self-play learning at an extraordinary level. |
| 1995 | Cortes and Vapnik publish SVMs in Machine Learning. |
| 1997 | Hochreiter and Schmidhuber publish LSTM. |
| May 1997 | Deep Blue defeats Kasparov 3.5–2.5. |
| 1998 | LeCun and colleagues publish an influential account of gradient-based learning/CNNs for documents. |
| 2001 | Breiman publishes Random Forests. |
| early 2000s | Digital data, the internet and clusters expand machine learning's material base. |
| 2006 | Hinton, Osindero and Teh publish fast training for deep belief nets. |
| 2006–2007 | CUDA and general GPU programming broaden researchers' access to parallel computation. |
| 2009 | ImageNet is introduced with millions of hierarchically organized images. |
| 2009 | Raina, Madhavan and Ng demonstrate major GPU speedups in deep learning. |
| 2012 | AlexNet dominates the ImageNet competition, catalyzing deep learning in vision. |
| 2013 | Word2Vec popularizes efficient neural word embeddings. |
| 2014 | Sutskever, Vinyals and Le present LSTM-based seq2seq. |
| 2014 | Bahdanau, Cho and Bengio introduce learned attention in neural translation. |
| 2014 | Goodfellow and colleagues introduce GANs. |
| 2015 | DeepMind publishes DQN in Nature. |
| 2015 | ResNet wins vision competitions using residual connections. |
| Jan. 2016 | The AlphaGo paper is published; the system had already defeated Fan Hui. |
| Mar. 2016 | AlphaGo beats Lee Sedol 4–1. |
| 2017 | Vaswani and colleagues publish Attention Is All You Need. |
| June 2018 | OpenAI introduces Transformer-based generative pretraining. |
| 2018 | BERT is released, later published at NAACL 2019. |
| 2019 | T5 proposes a unified text-to-text framework. |
| 2019 | OpenAI experiments already use human feedback to tune GPT‑2. |
| Jan. 2020 | Kaplan and colleagues publish scaling laws for language models. |
| May 2020 | GPT‑3 demonstrates strong few-shot/in-context performance at large scale. |
| 2020 | C4AI USP–FAPESP–IBM begins operating in Brazil. |
| 2020 | AlphaFold2 achieves a historic result at CASP14; detailed publication follows in 2021. |
| Jan. 2021 | OpenAI introduces DALL‑E. |
| 2021 | CLIP demonstrates contrastive image–text pretraining on 400 million pairs. |
| July–Aug. 2021 | AlphaFold2 is published in Nature. |
| Aug. 2021 | Stanford publishes the report consolidating “foundation model.” |
| 2022 | InstructGPT demonstrates the strength of instruction tuning + RLHF. |
| 2022 | Diffusion models and text-to-image systems become a public phenomenon. |
| 2022 | Stable Diffusion accelerates the visual-generation ecosystem with accessible weights. |
| Nov. 30, 2022 | ChatGPT launches as a research preview. |
| early 2023 | Anthropic expands access to Claude. |
| Mar. 14, 2023 | OpenAI releases GPT‑4. |
| July 2023 | Anthropic releases Claude 2. |
| Sept. 2023 | Mistral releases Mistral 7B under Apache 2.0. |
| Dec. 2023 | Google introduces Gemini and integrates it into Bard. |
| Dec. 2023 | Mixtral 8x7B reinforces sparse mixture-of-experts use. |
| Feb. 8, 2024 | Google renames Bard to Gemini. |
| 2024 | Generative video and advanced multimodality broaden the generative race. |
| 2024 | AlphaFold 3 extends biomolecular modeling to broader interactions. |
| Aug. 2024 | Work on optimal test-time compute scaling quantifies new inference/model tradeoffs. |
| Sept. 12, 2024 | OpenAI introduces o1-preview, making “reasoning models” a commercial category. |
| late 2024 | MCP emerges as an open protocol connecting models to data and tools. |
| Jan. 20, 2025 | DeepSeek releases R1, broadening access to reasoning models. |
| Mar. 2025 | Qwen2.5-Omni exemplifies integrated text, image, audio and video input. |
| Apr. 2025 | Meta releases Llama 4 Scout and Maverick, multimodal MoE models with accessible weights. |
| Apr. 2025 | Qwen3 introduces a hybrid line with thinking and direct-answer modes. |
| 2025 | Reinforcement learning for reasoning spreads rapidly in open research. |
| 2025 | Coding agents become an important commercial and research category. |
| Feb. 2026 | Anthropic releases Sonnet 4.6, emphasizing coding, computer use and agents. |
| Mar. 2026 | OpenAI release notes record GPT‑5.4 Thinking and a reorganization of the 5.x line. |
| Apr. 2026 | Meta introduces Muse Spark on its website and app; the API was in private preview. Don't confuse each interface's availability. |
| May 2026 | Google announces the Gemini 3.5 family and Managed Agents infrastructure. |
| July 21, 2026 | Google introduces Gemini 3.6 Flash, distinguishing model iteration from agent infrastructure. |
| July 2026 | xAI opens Grok Build harness components for coding agents. |
| July 2026 | xAI makes Grok 4.5 available in a coding integration; quality claims remain self-reported. |
| July 2026 | OpenAI announces the GPT‑5.6 family in retrieved official documentation. |
| Aug.–Sept. 2026 | Google continues the Gemini 3.7/3.8 cycle. |
| Sept. 22, 2026 | Anthropic documentation records Claude Opus 5.5. |
| Oct. 6, 2026 | Mistral announces Large 4 in public API preview; weights are promised for after this article's cutoff. |
| Oct. 7, 2026 | Anthropic announces Haiku 5.5. |
| Oct. 8, 2026 | Google announces a Gemini agent integrated for enterprise work. |
| Sept.–Oct. 2026 | The GPT-6 documentation records expanded access. A September 29 update confirms earlier announcements without by itself establishing the first launch date. |
| Oct. 10, 2026 | The frontier features reasoning, multimodality, agents, tools and competition between large and small models, without consensus on AGI. |
announcements and access at the 2026 cutoff
These are examples announced by October 10, 2026. A manufacturer's page documents the launch and access conditions; capability claims require evaluation. Don't use this list as a ranking.
| Ecosystem | Example documented at the cutoff | What it helps illustrate |
|---|---|---|
| OpenAI | GPT-6.1 Sol and GPT-6 access expansion | models, interfaces and tool use are developed as parts of products. |
| Anthropic | Opus 5.5 and Haiku 5.5 | variants address different capability, speed and cost constraints. |
| Gemini 3.5 family | language, modalities and action appear in the same systems agenda. | |
| Alibaba | Qwen ecosystem | Chinese families include language, image and other modalities. |
| DeepSeek | V4 preview and V4.1-Flash work | papers and previews must be read with their availability conditions. |
| Mistral | Large 4 public preview, October 6 | the announcement offers API testing and promises weights later; a promise isn't verified availability. |
| xAI | Grok 4.6 | long-running tasks and agents appear as commercial priorities. |
| Meta | Llama 4, announced in 2025 | a milestone in multimodality and weight distribution; this row doesn't claim to describe the company's latest release. |
a glossary for when a word slips away
| Word | Meaning used here |
|---|---|
| AI | a field investigating systems capable of tasks associated with intelligence, through several traditions and methods. |
| Symbolic | working with explicitly represented objects, relationships and rules. |
| Search | exploring alternatives to find a path or solution. |
| Heuristic | practical guidance for choosing which alternatives to explore. |
| State / plan | a relevant description of a situation / a sequence of actions to reach a goal. |
| Machine learning | adjusting behavior from examples, data or consequences. |
| Dataset / benchmark | an organized data collection / a task and conditions for comparable evaluation. |
| Parameter / weight | a value adjusted by training / a parameter modulating an operation or connection. |
| Training / inference | an adjustment stage / executing the model to obtain an output. |
| Loss | a measure of predictions' cost relative to the chosen objective. |
| Gradient / backpropagation | sensitivity of loss to parameters / calculating those sensitivities through operations. |
| Generalization / overfitting | working on new examples / fitting too closely to training details. |
| Supervised / self-supervised | learning from supplied targets / obtaining targets from the data's own structure. |
| Deep learning | learning with multilayer networks that transform representations. |
| CNN / RNN / LSTM | architectures exploiting local structure, recurrence and control of sequence memory, respectively. |
| Reinforcement learning (RL) / policy | learning from reward signals / behavior guiding action selection. |
| Token / embedding | a discrete unit being processed / a learned numerical representation. |
| Attention / self-attention | a weighted combination of information / a combination among positions within the same sequence. |
| Transformer | a family of architectures with attention as a central mechanism. |
| Autoregressive | generating a sequence by conditioning each continuation on permitted context. |
| Pretraining / fine-tuning | broad initial learning / subsequent training to adapt behavior. |
| Context / context window | information made available to the model during an execution, with limited processing capacity. |
| In-context learning | using supplied instructions and examples without necessarily changing weights. |
| LLM / foundation model | a large language model / a broad base adaptable to multiple tasks and modalities. |
| Multimodal | working with more than one information type, such as text, images and audio. |
| GAN / diffusion | generation through adversarial objectives / generation associated with learned denoising transitions. |
| RLHF | reinforcement training using signals associated with human preferences. |
| RAG | retrieving external information and including it in answer generation. |
| LoRA / QLoRA | adaptation with lower-dimensional updates / combining that adaptation with quantization. |
| Quantization / distillation | reducing numerical precision / transferring behavior or signals between models. |
| MoE | an architecture selecting subsets of components for certain operations. |
| Test-time compute | computation invested during solving after receiving a problem. |
| Chain of thought | intermediate steps expressed during solving; neither a correctness guarantee nor faithful access to the internal process. |
| VLA | a vision-language-action model linking perception and instructions to actions; more specific than multimodality. |
| Verifier | a component testing a condition or evaluating a candidate under defined criteria. |
| Tool use / agent | external software executing operations / a system deciding and acting through observation cycles. |
| MCP | a protocol connecting AI applications, sources and tools. |
| Hallucination | plausible output that doesn't match facts or relevant evidence. |
| AGI / consciousness | distinct questions of general capability and subjective experience, requiring criteria and investigation. |
where to continue reading
Sources are linked throughout. To continue, I'd start with papers' abstracts and figures, trying to understand which problem each solved. You don't need to understand all the mathematics on the first pass.
- To understand the original question: Turing, 1950, and the Dartmouth proposal, 1955. Read them as documents of their time, with questions and expectations still open.
- To see the mechanism behind conversation: ELIZA, 1966, and Winograd's account of SHRDLU. Compare the apparent result with the world supplied to the system.
- To understand learning and representations: backpropagation, 1986, CNNs for document recognition, 1998, ImageNet, 2009, and AlexNet, 2012. These four documents show the interval between an idea and the conditions needed to scale it.
- To follow the language turning point: attention in translation, Transformer, GPT-3, and InstructGPT. Architecture, scale and assistant behavior are different steps.
- To explore visual generation and adaptation: diffusion, latent diffusion, LoRA and QLoRA. Notice which costs each work seeks to reduce and under which conditions.
- To consider systems beyond weights: RAG, computation during solving and DeepSeek-R1. Ask which information comes from training, context and external verification.
- To look beyond average accuracy: Gender Shades and Model Cards. Evaluation includes groups, contexts and limitations, not just choosing a high number.
- To situate Brazil: the SBIA memorial and BRACIS history. They offer institutional records of a community that existed before chatbots.
- For the material and social dimensions: AI Index 2026, the IEA's Energy and AI, and the ILO's occupational exposure study. Preserve the year, population, methodology and distinction between observation and projection.
I used a documentary survey of AI history as a starting point and checked events against papers and historical documents. The recent overview runs through October 2026. Manufacturers' comparisons remain identified as their own results, with the conditions and limitations accompanying each announcement.
No post "você não é especialista em IA", eu prometi contar a história da IA do começo, no mesmo formato do de criptografia. Aquele já passava por Turing. Faltava seguir daí até as redes neurais, os modelos de linguagem e os agentes que usamos hoje.
O incômodo era o mesmo: "IA" virou sinônimo de chatbot, e saber usar a ferramenta passou a valer como conhecer o assunto. Só que abrir o ChatGPT não explica como uma máquina aprende, por que precisa de tantos dados ou por que consegue escrever uma resposta convincente e errada.
Eu continuo estudando isso por conta própria. Não sou historiador da computação nem pesquisador de IA; as fontes estão nos links ao longo do texto. Tem muita gente e muitos caminhos nessa história, e vou explicar cada ideia antes de usar a sigla. Você não precisa saber programar ou conhecer a matemática pra acompanhar.
A primeira parte acompanha os antecedentes da área: como representar conhecimento, executar procedimentos e, depois, aprender com exemplos. Dartmouth marca a formação de uma agenda comum, mas essas perguntas já vinham de caminhos diferentes. Vamos seguir tanto os métodos quanto as pessoas, instituições e recursos que os tornaram possíveis.
Dá pra ler na ordem ou entrar por aprender com exemplos, modelos de linguagem e agentes ou instituições, recursos e impactos. Os blocos "pra ir além" ficam abertos; o link "pular aprofundamento" leva ao trecho seguinte. No fim, mapa, cronologia e glossário servem para consulta. As experiências indicam junto aos controles o que calculam de verdade e o que apenas ilustram.
A pergunta que acompanha o post é esta: o que a máquina faz, como consegue fazer e o que isso ainda não demonstra? Ela serve pra uma calculadora do século XVII, pra uma rede neural e pra um agente de 2026.
antes da IA: transformar raciocínio em alguma coisa manipulável
a forma de uma ideia
Antes de haver computadores, já havia gente tentando descrever a estrutura de um raciocínio. Se ela pudesse ser repetida, talvez raciocinar não dependesse de ter uma boa ideia a cada tentativa.
Pense nestas duas frases: “todo mamífero é um animal” e “todo golfinho é um mamífero”. Elas permitem concluir que todo golfinho é um animal. Você não precisa conhecer cada golfinho do oceano pra chegar lá. A conclusão depende da relação entre as categorias, não de uma pesquisa de campo feita naquele momento.
Agora troque os nomes: “toda coisa da categoria A está na categoria B” e “toda coisa da categoria C está na categoria A”. Continua sendo possível concluir que C está em B. O conteúdo foi embora e uma forma de raciocínio sobrou. A lógica estuda esse tipo de estrutura: quais conclusões seguem de quais premissas e sob quais condições.
Aristóteles estudava essa forma das inferências muito antes de existir IA como área de pesquisa. Chamar o trabalho dele de inteligência artificial seria anacronismo, mas a pergunta já estava ali: o que permite passar de uma afirmação pra outra? Se a forma for descrita com precisão, talvez uma operação mecânica consiga executar uma parte dela.
Só que uma conclusão pode seguir corretamente de premissas falsas. Se eu disser que todos os pássaros moram em Marte e que uma arara é um pássaro, a regra entrega uma conclusão absurda sem ter cometido um erro na passagem entre as frases. Validade do raciocínio e verdade sobre o mundo são perguntas diferentes. Uma máquina que aplica regras impecavelmente não ganha, por isso, acesso mágico a fatos corretos.
Um sistema especialista pode aplicar uma regra correta a um fato errado. Mais adiante, vamos encontrar um problema parecido nas respostas dos modelos de linguagem e nas ações dos agentes.
e se discutir pudesse virar calcular?
No século XVII, Gottfried Wilhelm Leibniz imaginou algo ambicioso: uma linguagem de símbolos capaz de representar ideias com precisão e um cálculo capaz de operar sobre elas. Em vez de duas pessoas se perderem em palavras que significavam coisas diferentes, poderiam esclarecer a representação e calcular as consequências.
Essa ambição tinha duas metades. A primeira era representar conhecimento. O símbolo de “animal”, por exemplo, precisaria dizer alguma coisa suficientemente definida. A segunda era estabelecer operações permitidas sobre os símbolos. Uma coleção de etiquetas, sozinha, não raciocina; precisa de relações e regras.
Leibniz também trabalhou com calculadoras mecânicas. O projeto de raciocínio universal ficou como uma ambição, bem distante de um computador moderno. Leibniz queria estender o cálculo pra além de operações aritméticas. Talvez o raciocínio pudesse ter partes tratáveis como cálculo. A história de seu trabalho na Stanford Encyclopedia of Philosophy situa essa ambição em seu contexto intelectual.
No século XIX, George Boole deu uma forma algébrica a operações lógicas. Pra uma primeira aproximação, imagine duas condições: “a porta está fechada” e “o alarme está ligado”. Cada uma pode ser verdadeira ou falsa. A operação E exige as duas; a operação OU aceita pelo menos uma; NÃO inverte uma condição.
Isso é familiar mesmo pra quem nunca programou. Pra uma promoção valer, talvez você precise ser cliente cadastrado e comprar acima de certo valor. Para um alarme disparar, pode bastar a porta abrir ou um sensor detectar movimento. A lógica torna essas combinações explícitas. Boole deu a essas operações um tratamento matemático sistemático. A referência histórica sobre Boole também distingue seu trabalho das formulações posteriores da álgebra booleana.
Gottlob Frege ampliou o alcance da lógica formal com sua Begriffsschrift, publicada em 1879. A diferença que nos interessa é passar de combinações simples pra uma linguagem que consiga falar de objetos, propriedades, relações e quantidades: “existe alguém”, “para todo objeto”, “essa pessoa é mãe daquela”. Uma linguagem mais expressiva representa mais coisas, mas também dá mais trabalho pra quem precisa operar sobre ela. A referência sobre Frege documenta essa contribuição.
A sequência até aqui é essa: reconhecer uma forma de inferência, escrever a forma em símbolos e definir as operações permitidas. Com isso, já dá pra perguntar se um procedimento consegue fazer parte do trabalho.
Também torna visível um problema que nunca saiu da IA: representar o mundo custa trabalho. “O copo está na mesa” parece uma frase simples. Mas o que conta como copo? Qual mesa? Está em cima, apoiado na borda, dentro de uma caixa que está sobre a mesa? Representações boas simplificam uma tarefa. Representações ruins escondem justamente o detalhe que importa.
a máquina que não precisava fazer sempre a mesma coisa
Também havia máquinas construídas para imitar ações, muito antes de alguém chamar isso de IA. O autômato de Diana sobre um cervo, de cerca de 1620, podia mover-se sobre uma mesa. Engrenagens produziam uma sequência preparada; a aparência de ação não demonstra aprendizagem. Essa tradição ajuda a separar três coisas que continuaremos encontrando: automatizar, imitar e aprender.
Outra tradição corria em paralelo: construir máquinas que executassem trabalho. Calculadoras mecânicas de Pascal e Leibniz automatizavam operações aritméticas, mas automatizar uma operação é diferente de ter uma máquina cujo comportamento possa ser descrito por um programa.
Uma caixa de música é uma boa comparação. Ela tem um mecanismo e uma sequência que determina o que toca. Trocar a sequência muda a música sem exigir que você invente novamente as engrenagens. A máquina continua a mesma; o que muda são as instruções.
Nos anos 1830, Charles Babbage projetou a Máquina Analítica. O projeto distinguia armazenamento, operações e controle das instruções; cartões perfurados ajudariam a comandar o trabalho. Há ali parentes conceituais da memória, do processador e do programa que encontramos em computadores atuais. Mas a máquina completa não foi construída por Babbage. A distinção entre projeto e máquina funcionando importa aqui. O Computer History Museum ajuda a separar essas duas coisas.
Ada Lovelace, nas notas publicadas em 1843 sobre a Máquina Analítica, percebeu que o projeto permitia trabalhar com outras coisas além de números. Se uma coisa pudesse ser representada por símbolos, uma máquina que manipulasse símbolos talvez pudesse trabalhar com mais do que quantidades numéricas. Música é um dos exemplos associados às notas: relações entre sons poderiam, sob condições adequadas de representação, entrar nesse universo de operações.
Pra trabalhar com música, a máquina precisaria de uma representação dos sons e de operações sobre ela; a experiência de um músico é outra coisa. Ao mesmo tempo, Lovelace discutiu os limites do que a máquina poderia originar por conta própria. Operar conforme instruções e produzir um resultado que surpreende quem as escreveu já eram questões antes do computador eletrônico.
Um exemplo: Um número pode representar uma nota musical, uma cor ou uma letra. A operação “mudar esse número” ganha significados diferentes dependendo da representação. Se o símbolo 65 representar a letra A, somar um pode apontar para B. Se representar intensidade de um pixel, somar um clareia uma parte da imagem. O mecanismo opera sobre números; o significado depende do sistema em que esses números foram colocados.
Isso ajuda a entender por que um computador pode lidar com imagens, texto, áudio e dinheiro. Ele não precisa ter uma engrenagem física diferente pra cada assunto. Precisa de uma forma de representá-lo e de um procedimento adequado. Essa generalidade será decisiva pra IA: ideias sobre linguagem, jogos, lógica e aprendizagem poderão ser experimentadas numa mesma classe de máquina.
Mas quais problemas uma máquina consegue resolver seguindo instruções? Ter um programa ainda não responde isso.
o que uma máquina consegue fazer
receita, demonstração e limite
Um procedimento é uma sequência de passos que não depende de inspiração a cada tentativa. A receita precisa dizer o suficiente pra que alguém consiga seguir. “Faça uma massa boa” não é uma receita; “misture essas quantidades por esse tempo” começa a ser.
Na matemática, há uma versão mais exigente dessa pergunta: existe um procedimento que sempre termine e decida corretamente uma classe de problemas? Resolver alguns exemplos não basta. Uma regra que funciona quando eu escolho casos favoráveis não é uma solução geral.
David Hilbert esteve no centro de um programa que buscava fundamentos formais seguros para a matemática. Entre as perguntas desse ambiente estava a possibilidade de procedimentos gerais para decidir determinadas questões lógicas. Se todo raciocínio matemático pudesse ser transformado em símbolos e regras, talvez desse pra automatizar a decisão sobre o que se segue desses símbolos.
Kurt Gödel mostrou, em 1931, limites de sistemas formais suficientemente expressivos. As condições são bem específicas: os resultados não dizem que "nada pode ser provado" nem que "toda opinião vale". Os teoremas de incompletude mostram que determinados sistemas consistentes e efetivamente axiomatizados não conseguem demonstrar todas as verdades aritméticas expressáveis neles, e estabelecem um limite para provar a própria consistência sob hipóteses precisas. A explicação dos teoremas na Stanford Encyclopedia of Philosophy explicita essas condições.
Mesmo sem entrar na demonstração, dá pra acompanhar a consequência: escrever regras poderosas não garante que elas encerrem todas as perguntas possíveis sobre si mesmas. A história da formalização encontrou limites internos, e esses limites não desapareceram quando a eletrônica ficou mais rápida.
Alonzo Church e Alan Turing, na década de 1930, deram maneiras rigorosas de descrever computação. Church trabalhou com o cálculo lambda, uma linguagem matemática de funções. Turing descreveu uma máquina abstrata com uma fita, símbolos, estados e regras de movimento. Os formalismos mostraram-se equivalentes. Já a afirmação de que capturam todo procedimento efetivo é a tese de Church–Turing, não um teorema sobre uma definição informal de computação.
A máquina de Turing era um modelo matemático pra estudar procedimentos, bem mais simples que um computador físico. Imagine uma fita dividida em casas e uma cabeça que lê uma casa por vez. Dependendo do símbolo e do estado em que está, ela escreve algo, anda e muda de estado. É simples o bastante pra analisar e geral o bastante pra representar computações complexas.
Turing demonstrou que há problemas para os quais não existe um decisor geral desse tipo. Um resultado conhecido é o problema da parada: não há um único algoritmo que, para todo programa e toda entrada, determine corretamente se aquele programa terminará ou continuará executando para sempre. Aumentar a velocidade do processador não resolve esse limite.
Você ainda pode descobrir se um programa particular termina e analisar classes inteiras de programas. O que falha é a promessa de um único método que decida corretamente todos os casos.
da lógica à eletricidade, da eletricidade ao feedback
Claude Shannon criou uma ligação fundamental entre operações lógicas e circuitos de comutação. Uma condição que na álgebra aparece como verdadeira ou falsa pode corresponder a uma configuração elétrica. Combinações de circuitos conseguem executar operações que, no papel, eram relações simbólicas. Sua dissertação, com folha de rosto assinada em 1937, documenta essa ponte.
Certos comportamentos físicos podem implementar operações formais. Isso permite montar uma cadeia de operações em hardware. Shannon foi uma das pessoas nessa construção, que teve muitos participantes e arquiteturas.
Shannon também formalizou uma teoria matemática da comunicação em 1948. Aqui, informação tem um sentido técnico ligado à incerteza e à transmissão de mensagens. Medir informação não é medir sabedoria, intenção ou compreensão. Um arquivo pode carregar muitos bits e dizer muito pouco que interesse a alguém; essa diferença importa quando, décadas depois, falamos em modelos que processam enormes volumes de dados.
Norbert Wiener organizou sob o nome de cibernética um estudo de controle, comunicação e feedback em máquinas e organismos, apresentado em seu livro de 1948. “Feedback” pode soar como palavra de reunião, mas aqui é uma ideia mecânica bastante simples: observar o resultado da própria ação e usar essa observação pra ajustar a ação seguinte.
Um termostato é um exemplo. Ele mede a temperatura, compara com a desejada e controla o aquecimento. A sala ficou quente demais? O sistema reduz ou desliga. Ficou fria? Atua de novo. Uma resposta depende do estado observado do ambiente. Isso é diferente de simplesmente ligar um aquecedor por duas horas e torcer.
O termostato ajusta a ação conforme o que observa. Esse ciclo é uma ideia da cibernética que atravessa controle industrial, robótica e aprendizagem, sem exigir que o termostato seja considerado inteligente. Mais adiante, os agentes também vão ler resultados e ajustar planos, usando outra tecnologia para organizar um ciclo parecido.
neurônios como modelo, não como cópia do cérebro
Em 1943, Warren McCulloch e Walter Pitts publicaram um trabalho que aproximava redes de neurônios idealizados e lógica. O neurônio desse modelo era uma simplificação matemática: receber sinais e produzir uma saída conforme condições definidas. Redes dessas unidades podiam realizar operações lógicas.
Conectar unidades simples também podia produzir comportamento computacional. Não era preciso escrever cada operação como uma regra de alto nível. Isso não fazia do modelo uma reprodução fiel de um cérebro. Neurônios biológicos têm dinâmicas e contextos que uma unidade de limiar deixa de fora. Daí vem a inspiração do nome. O artigo original de McCulloch e Pitts permite examinar essas idealizações.
Em 1949, Donald Hebb apresentou uma teoria sobre mudanças nas conexões entre neurônios associadas à experiência: a intensidade de uma conexão podia mudar conforme a atividade. A expressão popular “neurônios que disparam juntos se conectam” é uma simplificação posterior. Uma reprodução do livro de Hebb está preservada pelo Instituto Max Planck.
Pense numa rede de caminhos. Se todas as conexões tiverem influência fixa para sempre, o comportamento só muda quando alguém altera o desenho. Se as influências puderem se ajustar conforme exemplos ou resultados, o próprio comportamento poderá ser modificado por um processo de aprendizagem. Ainda precisamos de regras que façam esse ajuste dar certo, mas a possibilidade está posta.
Aqui já existem linhagens que depois serão tratadas como concorrentes: operar com símbolos explícitos, reagir por ciclos de controle, aprender relações a partir de dados e adaptar redes de unidades conectadas. Elas não nasceram todas em uma conferência. Foram se aproximando num ambiente que agora também tinha computadores digitais onde ideias podiam ser experimentadas.
Uma dessas experiências ganhou corpo em 1951: o SNARC, construído por Marvin Minsky e Dean Edmonds. Circuitos representavam conexões, e um mecanismo de reforço modificava caminhos usados recentemente. A biografia do próprio Minsky e sua tese documentam esse trabalho. Era uma máquina experimental: as redes já tinham implementações físicas antes de Dartmouth, ainda longe de reproduzir um cérebro.
Turing muda a pergunta
Em 1950, Turing publicou Computing Machinery and Intelligence. Para reformular a pergunta sobre “pensar”, começou com um jogo entre um homem, uma mulher e um interrogador, e então perguntou o que aconteceria se uma máquina ocupasse um dos papéis. A interpretação mais conhecida do teste pergunta se o interrogador conseguiria distinguir, por respostas textuais, uma máquina de uma pessoa.
Dá pra observar as respostas e descrever o experimento mesmo discordando sobre o significado de pensar. O teste que passou a levar seu nome oferece um modo de discutir a questão, não um certificado definitivo de inteligência, consciência ou compreensão.
Uma máquina pode convencer por limitações do avaliador, por estratégia de conversa, por um contexto estreito ou por capacidade real em linguagem. E um sistema pode resolver um problema científico importante sem conversar como uma pessoa. Por isso, tornar-se indistinguível numa conversa é uma evidência sobre uma situação, não uma medida universal de tudo que chamamos inteligência.
O artigo também discute aprendizagem. Turing não imaginava apenas escrever manualmente todas as respostas de uma máquina adulta; considera a ideia de construir algo que pudesse ser educado. Isso aproxima a pergunta sobre inteligência da pergunta sobre mudança com experiência. O texto de 1950 vale mais do que o resumo de uma frase que costuma circular dele.
A ligação com criptografia passa por esse interesse em procedimentos, restrições e inferência. Em Bletchley Park, o trabalho contra a Enigma foi coletivo: apoiou-se nas contribuições dos poloneses Marian Rejewski, Jerzy Różycki e Henryk Zygalski, além das de Turing e outros pesquisadores britânicos. Explorar restrições pra descartar configurações é um exemplo de busca estruturada. Isso ajuda a enxergar uma continuidade de perguntas, mas não transforma automaticamente criptoanálise em aprendizado de máquina.
A IA terá métodos que procuram soluções seguindo regras e métodos que ajustam parâmetros com exemplos. Às vezes trabalham juntos. Representação, busca e computação são pontos de encontro entre essas áreas, construídos por várias pessoas.
uma área ganha nome, e a ambição cresce
Dartmouth não começou do zero
Em 31 de agosto de 1955, John McCarthy, Marvin Minsky, Nathaniel Rochester e Claude Shannon assinaram uma proposta de pesquisa para o verão seguinte em Dartmouth. A expressão artificial intelligence aparece no documento. Em 1956, o encontro ajudou a consolidar um nome e uma identidade científica para um conjunto de perguntas que já tinha antecedentes.
O documento partia de uma conjectura ambiciosa: aspectos da aprendizagem e da inteligência poderiam ser descritos com precisão suficiente pra que uma máquina os simulasse. A proposta incluía temas como linguagem, redes neurais, abstração e aperfeiçoamento de máquinas. O original preservado no arquivo de McCarthy permite ver o otimismo sem depender de uma retrospectiva publicitária.
Dar nome a um campo tem consequências práticas. Ajuda a reunir pesquisadores, pedir financiamento, abrir laboratórios, criar cursos e discutir uma agenda. Um conjunto de trabalhos que antes parecia pertencer a tradições diferentes passa a ter uma bandeira sob a qual pode se organizar.
Isso também cria disputas. Que trabalhos entram nessa bandeira? Qual abordagem merece dinheiro? Uma rede inspirada em neurônios e um programa que demonstra teoremas estão tentando explicar inteligência da mesma maneira? O nome une uma área, mas não resolve suas diferenças internas.
O encontro ajudou a organizar a área, mas as abordagens continuaram divergindo. Os participantes não saíram de Dartmouth com um plano dos próximos setenta anos.
- 1936Church e Turing7 anosformalizar procedimentos e investigar seus limites.
- 1943McCulloch e Pitts5 anosredes de neurônios idealizados ligadas à lógica.
- 1948Shannon e Wiener2 anosinformação, comunicação, controle e feedback.
- 1950Turing5 anosum experimento sobre comportamento, além da discussão sobre pensar.
- 1955a proposta1 anoartificial intelligence aparece como programa de pesquisa.
- 1956Dartmouth2 anoso encontro consolida uma identidade para a disciplina.
- 1958perceptronRosenblatt publica um modelo de aprendizagem por ajuste de pesos.
o programa que procurava uma demonstração
Allen Newell, Herbert Simon e Cliff Shaw desenvolveram o Logic Theorist em meados dos anos 1950. O programa trabalhava com demonstração de teoremas. Em termos simples, recebia um objetivo e tentava encontrar uma sequência de operações que ligasse afirmações disponíveis à conclusão desejada. O relatório de 1956 preservado pela Carnegie Mellon documenta essa linha.
Uma demonstração pode ser pensada como um caminho. Você começa com premissas aceitas, aplica operações permitidas e precisa chegar ao destino. Além de conhecer as operações, precisa decidir quais tentar, em qual ordem e quando abandonar um caminho que está ficando ruim.
Se você já tentou montar um quebra-cabeça, conhece essa diferença. Saber que peças compatíveis podem se encaixar não diz qual das centenas de peças escolher em seguida. Uma boa pista reduz tentativas. Em computação, uma heurística é justamente uma orientação prática pra procurar de maneira mais promissora, sem necessariamente garantir que aquela escolha seja perfeita.
O Logic Theorist produzia demonstrações procurando caminhos entre representações: as operações eram dadas; encontrar uma sequência útil era o trabalho do programa.
Newell e Simon continuaram essa linha com o General Problem Solver. A ambição era tornar menos específico o mecanismo de solução: representar estados, objetivos e diferenças, escolhendo ações que reduzissem a distância entre o estado atual e o desejado. “Geral” no nome precisa ser lido como objetivo de pesquisa, não como capacidade de resolver qualquer problema cotidiano.
Imagine preparar café: o estado inicial tem água fria, pó e uma chaleira; o objetivo é café pronto. Aquecer a água permite passar à ação de coar. Mas, se falta energia, a ação de aquecer falha e o plano precisa de outra condição ou alternativa, como um fogão disponível. Este é um exemplo didático, não uma execução histórica do GPS: explicitar estados e ações funciona num problema preparado; descobrir tudo o que importa no cotidiano aumenta muito o trabalho de representação.
Os primeiros resultados impressionavam porque faziam algo antes impossível. Ainda faltava medir quanto trabalho seria necessário pra sair dos problemas preparados para a demonstração.
o programa que mudava com experiência
Uma outra direção ficava mais clara com o perceptron de Frank Rosenblatt, descrito em seu artigo de 1958. Em vez de representar toda uma cadeia de regras humanas, o modelo combinava entradas usando pesos ajustáveis e produzia uma decisão.
Um peso determina quanto uma entrada influencia o resultado. Imagine avaliar se uma fruta está madura. Cor, firmeza e cheiro podem contribuir de maneiras diferentes. Com características na mesma escala, um peso maior em módulo dá mais influência ao cheiro na combinação numérica; o sinal pode favorecer ou contrariar a saída. O modelo não tem nariz nem conceito de fruta; recebe números que alguém escolheu ou mediu como representação das características.
O treinamento altera esses pesos a partir de exemplos. Se a saída desejada era “madura” e o modelo respondeu outra coisa, um procedimento pode ajustar os valores para reduzir erros seguintes. Esse é um modo de programar diferente: a pessoa escolhe a estrutura, os exemplos e a regra de aprendizagem, mas não escreve diretamente cada decisão final.
No treinamento, os parâmetros, valores ajustáveis como os pesos, mudam. Na inferência, o modelo executa suas operações sobre uma entrada com os parâmetros disponíveis para produzir uma previsão ou resposta. Aqui, “inferência” nomeia essa execução, sem exigir raciocínio lógico.
Trocar a entrada também pode mudar a resposta sem alterar pesos. Essa distinção será fundamental nos prompts: exemplos numa conversa orientam aquela execução, sem incorporar por isso uma habilidade permanente ao modelo.
O perceptron tinha limites importantes, que veremos numa experiência mais à frente. Já dá pra comparar os dois programas: o Logic Theorist procurava consequências e caminhos usando representações explícitas; o perceptron ajustava uma função de decisão com exemplos. São duas formas de trabalhar com problemas de IA, anteriores aos chatbots.
Os grandes modelos de linguagem (LLMs, de large language models) usados em chatbots são redes neurais com muitas camadas. Redes são uma família de aprendizado de máquina, que faz parte da IA. O desenho coloca esse pedaço dentro da área inteira; as camadas e a linguagem vêm mais adiante.
por que os primeiros resultados pareciam uma promessa maior
Um computador que demonstra um teorema pode parecer perto de fazer ciência sozinho. Um classificador que aprende com imagens pode parecer perto de reconhecer qualquer objeto. Os primeiros resultados alimentavam expectativas desse tamanho.
Mas uma foto cuidadosamente preparada e um objeto mal iluminado na rua exigem coisas diferentes do classificador. O mesmo vale para conversar com frases esperadas e acompanhar uma história cheia de referências implícitas. Na demonstração de teoremas, as premissas já estão definidas; num problema social, decidir quais premissas representam a situação pode ser justamente a parte difícil.
Cada resultado precisa ser lido dentro de suas condições. Quais entradas foram usadas? Que partes da tarefa já estavam resolvidas pela representação? Quem selecionou os exemplos? Quanto trabalho humano havia em volta? São essas perguntas que dizem quanto da tarefa o programa resolveu.
inteligência escrita em regras
representar um mundo e procurar um caminho
Para manipular símbolos, pesquisadores também precisavam de linguagens de programação adequadas. John McCarthy iniciou a implementação de Lisp em 1958; o artigo formal sobre suas funções recursivas veio em 1960. Lisp facilitava trabalhar com listas e expressões: uma afirmação, um conjunto de regras ou parte de um programa podiam ser representados como estruturas que outro programa examinava. A história contada por McCarthy distingue o desenvolvimento da publicação.
Imagine guardar “Ana é mãe de Bia” como uma lista com três papéis, em vez de apenas uma frase solta. O programa pode localizar a relação, substituir um nome ou combinar essa estrutura com outra. Lisp ajudava a construir e transformar essas representações. O conhecimento ainda precisava ser colocado nelas. Essa utilidade ajuda a explicar seu lugar nos laboratórios de IA simbólica e, mais tarde, no mercado de máquinas Lisp.
A abordagem que ficou conhecida como IA simbólica representa coisas explicitamente: objetos, relações, condições, ações e regras. “A está em cima de B” pode ser um fato; “se A está em cima de B, mover B exige antes retirar A” pode ser uma regra. O programa opera sobre essas representações.
As regras deixam parte do raciocínio visível. Se o sistema diz que precisa retirar uma caixa antes de puxar a prateleira, podemos acompanhar o caminho que levou à decisão. Os fatos ainda podem estar errados, mas temos como examinar as operações.
Imagine três caixas empilhadas. Você quer levar a caixa de baixo para outra sala, mas só pode mover uma caixa por vez e não pode atravessar as outras. Há um estado inicial, um objetivo e ações permitidas. A solução envolve uma sequência: tirar a de cima, tirar a do meio, mover a de baixo. O programa precisa encontrar essa sequência dentro do espaço de possibilidades.
Um estado é uma descrição relevante da situação. Uma ação transforma um estado em outro. Um plano é uma sequência de ações para alcançar uma condição desejada. Esses conceitos podem ser usados por uma máquina sem que ela tenha vontade de carregar a caixa ou saiba como é estar numa sala.
Encontrar meios de atingir um objetivo e organizar ações eram tarefas associadas ao raciocínio. Os programas conseguiam executar partes delas, usando mecanismos que podiam ser diferentes dos nossos.
A dificuldade aparece quando as possibilidades se multiplicam. Se cada estado permitir dez ações, dois passos podem abrir cem caminhos; três, mil. Dez passos já podem produzir uma quantidade enorme de combinações. Nem todos os caminhos são diferentes ou precisam ser explorados, mas o exemplo mostra por que “é só tentar as opções” deixa rapidamente de ser uma solução prática.
Uma heurística pode orientar a procura. Num mapa, a distância em linha reta até o destino sugere qual cidade visitar antes. Não substitui a estrada real, mas ajuda a evitar tentativas muito ruins. No planejamento, outras medidas aproximadas podem cumprir o mesmo papel. Isso reduz a quantidade de caminhos que o programa precisa examinar.
ELIZA: quando a conversa faz parecer que há alguém ali
Em 1966, Joseph Weizenbaum publicou um artigo sobre ELIZA. O sistema transformava entradas textuais usando palavras-chave e regras de decomposição e recomposição. Um roteiro conhecido imitava certos padrões de uma conversa terapêutica, frequentemente devolvendo perguntas relacionadas às palavras da entrada.
Uma frase com “minha mãe” poderia acionar uma resposta sobre família. Uma frase com uma estrutura esperada poderia ser rearranjada numa pergunta. Não era uma rede neural treinada em livros nem um modelo que tivesse um entendimento geral da situação narrada.
O artigo de Weizenbaum é importante tanto pelo mecanismo quanto pela reação que ele ajuda a discutir. Pessoas atribuem intenção e compreensão a comportamentos linguísticos com muita facilidade. Uma resposta que parece acolhedora pode dar a impressão de que o sistema compreendeu a experiência de quem falou, mesmo quando acionou uma transformação muito estreita.
A tendência de enxergar alguém por trás da conversa já aparecia ali. Os modelos de linguagem atuais têm outro mecanismo, mas encontram essa mesma reação humana.
A versão abaixo procura trechos literais e mostra a regra que encontrou. É uma adaptação pequena pra você conseguir ver o funcionamento inteiro, não uma reprodução de ELIZA.
execução simplificada · regras locais
resposta por regras
o que faz você dizer que está triste?
regra acionada
contém “triste” → devolver uma pergunta sobre tristeza, sem analisar a negação
A resposta pode parecer pertinente porque você forneceu uma palavra que o roteiro reconhece. Mas pode errar porque a palavra apareceu numa negação, numa citação ou num contexto inesperado. O programa não precisa identificar tudo isso pra produzir uma frase gramatical.
Há também uma parte humana no funcionamento. Quem conversa completa lacunas: interpreta a pergunta vaga como interesse, imagina continuidade e atribui intenção. A interface contribui pra essa leitura. Uma mesma operação, apresentada como uma transformação de texto num quadro técnico, pode parecer bem menos humana do que dentro de uma janela de conversa.
SHRDLU e a vantagem de um mundo pequeno
Terry Winograd desenvolveu SHRDLU no fim dos anos 1960 e início dos 1970. O sistema lidava com linguagem em um mundo de blocos: objetos com propriedades e relações que podiam ser representadas explicitamente. Era possível pedir operações sobre esses objetos e fazer perguntas dentro daquele contexto.
Imagine pedir “coloque o bloco vermelho sobre o azul”. Num ambiente de blocos, o sistema pode ter uma lista dos objetos, saber quais são vermelhos e azuis, representar relações espaciais e escolher uma ação. Uma frase seguinte pode usar “ele”, e o contexto ajuda a determinar qual bloco está sendo mencionado.
SHRDLU integrava análise de linguagem, memória de contexto e ações sobre o ambiente. O relato do próprio Winograd ajuda a entender também o limite: o programa trabalhava num universo muito preparado para seus mecanismos.
Se eu saio dos blocos e digo “arrume a casa para uma visita”, o significado se abre. Que visita? O que conta como arrumado? A caixa no chão está atrapalhando ou é onde a pessoa guarda os remédios? O conhecimento de senso comum que uma pessoa usa sem perceber pode ser muito maior que a lista explícita de objetos e regras.
O mundo fechado de blocos fazia parte da solução. Fora dele, aumentar a lista de substantivos não bastava pra dar ao programa o conhecimento necessário.
Nem todo mundo aceitava que escrever mais regras bastaria para ampliar esses resultados. Hubert Dreyfus, em uma crítica publicada pela RAND em 1965, questionava pressupostos dessa ambição. Conhecer uma situação também envolve habilidades tácitas, contexto e experiência corporal: reconhecer quando alguém está sendo irônico não é simplesmente localizar a palavra “ironia”. A crítica abriu uma disputa filosófica sobre o que as representações formais capturam. Ela não é uma demonstração matemática de que máquinas jamais poderiam aprender, mas impede tratar o mundo de blocos como uma amostra completa da vida humana.
Shakey leva o problema para o chão
No SRI, Shakey reuniu percepção, representação, planejamento e ação num robô móvel, desenvolvido entre 1966 e 1972. Aqui a situação não era apenas uma descrição simbólica dentro de um programa. O robô precisava lidar com um ambiente físico e fazer algo nele. O arquivo institucional do SRI preserva essa trajetória.
Uma tarefa como deslocar um objeto envolve mais coisas do que escolher uma frase: descobrir onde o objeto está, estimar o espaço, planejar uma sequência e executar movimento. Cada etapa pode ter seus próprios erros. Se a representação disser que há um caminho livre e uma câmera não perceber um obstáculo, o plano pode ser lógico e ainda falhar no chão.
No robô, cada instrução depende do corpo e do ambiente: sensores, posição, tempo de resposta e movimento. Uma ação correta no plano pode dar errado quando essas condições são diferentes das que o programa supôs.
Desse ambiente veio STRIPS, de Richard Fikes e Nils Nilsson, publicado em 1971. Uma ação tem pré-condições, o que precisa ser verdadeiro para aplicá-la, e efeitos, fatos que ela acrescenta ou retira do estado. Para mover uma caixa, o robô pode precisar estar junto dela; depois do movimento, “a caixa está na origem” deixa de valer e “a caixa está no destino” passa a valer. O artigo original formaliza esse modo de procurar planos.
Programação lógica abriu outra direção. Prolog, desenvolvido em 1972 por Alain Colmerauer, Philippe Roussel e colegas em Marselha, com interlocução teórica de Robert Kowalski e pesquisadores de Edimburgo, permite escrever fatos e relações e pedir ao sistema que procure uma prova para uma pergunta. O relato dos criadores e a história registrada por Kowalski preservam a colaboração entre a construção da linguagem em Marselha e a investigação de procedimentos de prova em Edimburgo. São relatos de participantes, com seus próprios pontos de vista.
Num exemplo de parentesco, forneça os fatos “Ana é mãe de Bia” e “Bia é mãe de Caio”, mais uma regra sobre avós. O sistema pode procurar uma cadeia que responda se Ana é avó de Caio. A pessoa descreve relações e uma pergunta; o mecanismo busca combinações que a satisfaçam. Essa tradição terá ligação direta com a aposta japonesa em processamento de conhecimento nos anos 1980.
Essas demonstrações funcionavam em condições bem delimitadas. ELIZA dependia dos padrões de conversa, SHRDLU de um mundo de blocos e Shakey da percepção e do controle do robô. Levar os resultados para situações menos preparadas ia exigir mais trabalho do que as promessas sugeriam.
promessas, especialistas e invernos
o que esfriou, exatamente?
“Inverno da IA” é uma expressão útil se não virar uma estação mundial com data exata para começar e acabar. Ela costuma nomear retrações de expectativas, financiamento e mercado. As áreas e os países não esfriaram todos juntos, nem deixaram de fazer pesquisa.
Na tradução automática, demonstrações iniciais e o contexto da Guerra Fria estimularam interesse e investimento. Mas traduzir envolve ambiguidade, contexto, expressão idiomática e conhecimento sobre o assunto. Uma demonstração feita com frases cuidadosamente escolhidas não mede o desempenho sobre documentos variados.
Uma demonstração concreta foi Georgetown–IBM, em 7 de janeiro de 1954: um IBM 701 traduziu frases do russo para o inglês usando um vocabulário e regras controlados. O registro da IBM e o relato técnico de 1955 descrevem as condições da demonstração. O sistema traduziu aquele conjunto de frases; ainda faltava investigar como lidaria com textos variados.
Considere “ele viu o banco”. Pode ser uma instituição financeira ou um assento. “O banco estava na praça” ajuda numa direção; “o banco aprovou o crédito” ajuda noutra. Traduzir palavras isoladas e rearranjar estruturas pode funcionar em casos simples e quebrar quando a escolha depende de uma história maior.
O relatório ALPAC de 1966 avaliou a tradução automática no contexto dos investimentos dos Estados Unidos. Seus efeitos sobre prioridades e recursos foram importantes. Isso não autoriza dizer que a tradução automática acabou ali: linguística computacional, ferramentas de apoio e outras linhas continuaram.
No Reino Unido, o relatório de James Lighthill de 1973 criticou dificuldades da IA, incluindo escalabilidade. A avaliação esteve associada à retração britânica, mas houve contestação contemporânea. A resposta de McCarthy mostra que a discussão tinha diferenças de interpretação e de critérios, não uma sentença unânime de que máquinas inteligentes eram impossíveis.
Quando uma área depende de financiamento, o que conta como sucesso também depende de instituições. Demonstrar um princípio, entregar uma ferramenta útil e justificar um investimento militar são objetivos diferentes. Uma mudança de prioridade pode reduzir recursos mesmo quando há resultados científicos; resultados aquém das promessas podem tornar a mudança de prioridade mais provável.
As expectativas cresciam, os resultados ficavam aquém do prometido e instituições reviam os recursos. Esse ciclo aconteceu em momentos e países diferentes, com dificuldades técnicas e escolhas de financiamento se combinando.
o limite de uma linha reta
Uma peça famosa dessa história é Perceptrons, de Marvin Minsky e Seymour Papert, publicado em 1969. O livro estudou limites de classes de perceptrons. O resultado mais conhecido na divulgação aparece na ideia de separação linear.
Imagine um papel com pontos vermelhos e azuis. Se você consegue traçar uma linha reta que deixa todos os vermelhos de um lado e todos os azuis do outro, a classificação é linearmente separável. Se as cores se alternam nos cantos de um quadrado, nenhuma linha reta faz o serviço.
Essa é a estrutura da tarefa XOR: duas entradas, e a saída deve ser 1 quando só uma está ligada. Os pontos “nenhuma ligada” e “as duas ligadas” ficam numa categoria; “apenas a primeira” e “apenas a segunda”, noutra. Um único separador linear não consegue dividir essas quatro combinações corretamente.
O resultado vale para aquele separador linear, e não para toda rede neural. Uma arquitetura com unidades intermediárias e operações não lineares pode construir uma separação diferente. Para que isso seja útil, também precisa de um método eficaz de treinamento.
O peso do livro nessa retração é uma questão histórica, não uma consequência de seu teorema. Mikel Olazaran, em 1996, investigou como a interpretação da controvérsia se relacionou à autoridade e à distribuição de recursos da IA simbólica. Explicar o período exige considerar também hardware, treinamento e pesquisas que continuaram, sem atribuir uma causa única a toda a área.
conhecimento de uma área, em vez de inteligência para tudo
Os sistemas especialistas diminuíram a ambição da tarefa: capturar o conhecimento de uma área e usá-lo em problemas específicos, em vez de começar por um solucionador geral.
DENDRAL trabalhou com interpretação de estruturas químicas. MYCIN investigou regras relacionadas a infecções e tratamentos. XCON foi usado na configuração de sistemas computacionais da Digital Equipment Corporation. O nome “especialista” vinha do recorte e da base de conhecimento; não queria dizer que o sistema dominava todos os assuntos.
Como isso funciona? Separe uma coleção de fatos de uma coleção de regras. Os fatos descrevem o caso atual. As regras dizem como certas condições permitem chegar a outras afirmações. Um mecanismo de inferência escolhe e encadeia regras, às vezes tratando graus de certeza.
Num exemplo inventado de manutenção, “a máquina não liga” é um fato. Uma regra pode dizer que, se não há alimentação elétrica, deve-se investigar a conexão antes de desmontar o motor. Outra regra pode usar o resultado dessa investigação. O sistema vai preenchendo uma trajetória orientada pelo conhecimento registrado.
Uma base bem organizada usa conhecimento de domínio para evitar caminhos ruins; acrescentar regras, sozinho, não resolve isso.
O livro Rule-Based Expert Systems, de Buchanan e Shortliffe, documenta a arquitetura e as discussões do MYCIN. É importante distinguir estudo experimental de implantação clínica rotineira. Avaliar um programa em condições de pesquisa não significa que ele virou um médico autônomo em hospitais.
quem mantém o mundo atualizado?
A dificuldade dos sistemas especialistas aparece quando o conhecimento muda ou quando uma regra interage mal com outra. Uma regra isolada pode parecer clara; milhares delas podem ter dependências, exceções e conflitos.
Capturar a experiência de um especialista humano também não é simplesmente perguntar “qual regra você usa?”. Muitas pessoas reconhecem situações por prática sem conseguir descrevê-las como uma lista completa. Extrair, formalizar, verificar e atualizar conhecimento exige trabalho.
Imagine uma loja com regras para recomendar peças compatíveis. Um fabricante muda um conector, outro lança um modelo parecido, um produto sai de linha e os nomes comerciais mudam. A base precisa acompanhar. Caso contrário, o mecanismo continua aplicando corretamente informações que já não correspondem ao catálogo.
Essa manutenção se soma ao custo da infraestrutura. Durante a onda comercial dos anos 1980, plataformas e máquinas Lisp especializadas tiveram seu espaço. Mudanças no mercado de computadores, custos e desempenho das alternativas alteraram as condições desse negócio. Uma tecnologia pode perder viabilidade comercial sem que toda a ciência por trás dela seja falsa.
O projeto japonês Fifth Generation Computer Systems, iniciado em 1982, apostou em processamento de conhecimento, programação lógica e paralelismo. O registro da Information Processing Society of Japan descreve onze anos e aproximadamente 54 bilhões de ienes, até o ano fiscal de 1992. Foi uma política científica com equipamentos e pesquisa, não apenas uma promessa de produto. Seu encerramento não apaga as contribuições que produziu, nem serve como prova de que programação lógica era inútil. O programa foi conduzido pelo ICOT com apoio do MITI; o arquivo ICOT/AIST preserva a pesquisa e a infraestrutura produzidas. A transformação comercial dominante imaginada no entusiasmo inicial não se concretizou.
No fim dos anos 1980 e início dos 1990, expectativas comerciais e custos de manutenção contribuíram para outra retração associada à expressão “inverno”. Enquanto isso, reconhecimento de fala, estatística, controle, otimização e redes continuavam andando. Esses métodos cresceram enquanto os sistemas especialistas ocupavam a vitrine comercial.
aprender com exemplos
quem escreve a regra?
Até aqui, uma pergunta reapareceu: quem coloca o conhecimento na máquina? Num sistema de regras, pessoas escrevem grande parte da estrutura que liga condições e consequências. No aprendizado de máquina, muitos comportamentos são estimados a partir de dados.
Alguém ainda escolhe uma representação, uma família de modelos, um objetivo, os dados e o procedimento de ajuste. A diferença é que o resultado não precisa ser uma coleção de decisões escritas uma por uma. O procedimento procura parâmetros que funcionem bem nos exemplos disponíveis.
Vamos usar um filtro de mensagens. Escrever “se contém promoção, marcar como spam” é uma regra manual. Ela pode pegar um golpe e também a mensagem legítima de uma loja que você acompanha. Uma abordagem aprendida recebe mensagens associadas a categorias e procura regularidades úteis: combinações de palavras, padrões de remetentes ou outras características.
Os rótulos são as respostas fornecidas durante o treinamento: spam ou mensagem legítima, no exemplo. O modelo faz previsões, compara com os rótulos e é ajustado para melhorar segundo uma medida escolhida. Isso é aprendizado supervisionado: há exemplos de entrada acompanhados de uma resposta desejada.
O rótulo não é uma verdade que nasceu do nada. Alguém classificou as mensagens, com critérios, dúvidas e possíveis erros. Se pessoas discordam sobre o que conta como spam, a máquina herda uma versão dessa disputa. Dados são uma representação do mundo produzida em condições específicas.
Também há métodos que procuram estruturas sem receber uma categoria para cada exemplo, como agrupamentos de itens parecidos. Isso costuma entrar no aprendizado não supervisionado. Em outros métodos, a própria estrutura dos dados fornece o alvo: esconder parte de um texto e tentar reconstruí-la, por exemplo. Chamamos muitas dessas abordagens de autossupervisionadas.
São maneiras de montar o problema de aprendizagem, e uma tarefa pode usar mais de uma. Essas categorias não medem o quanto um sistema é inteligente.
probabilidade entra como parte da solução
Nem todo problema aceita uma resposta determinística baseada em fatos completos. Um sensor tem ruído, uma palavra admite interpretações e os dados cobrem apenas parte das situações possíveis. A estatística oferece maneiras de estimar regularidades sem fingir certeza absoluta.
Uma ideia associada a Bayes é atualizar uma crença diante de uma evidência. Pense numa moeda que talvez esteja desequilibrada. Antes de observar lançamentos, você tem alguma hipótese sobre ela. A sequência de resultados muda o quanto cada hipótese parece compatível com o que aconteceu. Atualizar não é “acreditar no que eu quiser”: envolve relacionar hipóteses, evidência e suposições.
Judea Pearl e outros pesquisadores desenvolveram ferramentas para organizar relações probabilísticas. Uma rede bayesiana representa dependências entre variáveis por meio de um grafo. O desenho ajuda a organizar como uma observação muda estimativas sobre outras condições. A bibliografia do laboratório de Pearl documenta essa linhagem.
Dependência estatística não estabelece causa: dois valores podem variar juntos porque um terceiro influencia ambos. Inferir causalidade exige hipóteses adicionais; desenhar uma seta não as fornece.
No reconhecimento de fala, modelos ocultos de Markov tiveram uma trajetória importante. “Oculto” significa que o sistema não observa diretamente o estado que quer inferir. Ele observa sinais produzidos por uma sequência de estados e procura uma explicação compatível com eles.
Imagine ouvir alguém atrás de uma parede. Você recebe um sinal imperfeito, não uma transcrição já pronta. Certos sons e certas transições são mais prováveis do que outros. Um modelo pode combinar essas probabilidades para escolher sequências mais plausíveis. O tutorial de Lawrence Rabiner de 1989 sistematizou problemas e métodos dessa família.
Essas peças dão papéis diferentes à incerteza: Bayes atualiza crenças, redes organizam dependências e os modelos de Markov estimam sequências de estados a partir de sinais. Na fala ou na frase ambígua do “banco”, o sistema pode comparar alternativas sem exigir fatos completos.
árvores, margens e combinações de modelos
Na linguagem, a mudança também passou por gramáticas, análise da estrutura das frases e métodos probabilísticos. Um analisador sintático procura relações como sujeito, verbo e objeto; um modelo de linguagem pode estimar a probabilidade de uma continuação. Modelos de n-gramas fazem isso observando pequenos trechos consecutivos. A tradução estatística de Brown e colaboradores, em 1990, procurava regularidades em traduções pareadas e combinava probabilidades com busca. Não eliminava toda estrutura linguística: mudava como parte dela era estimada, em vez de depender exclusivamente de regras escritas por especialistas.
Nem todo aprendizado de máquina envolve uma rede neural. Uma árvore de decisão organiza testes em sequência: a resposta de um teste leva a outro ramo, até alcançar uma decisão. A diferença para uma árvore escrita à mão é que um algoritmo pode escolher os testes a partir dos exemplos.
No filtro de mensagens, uma árvore pode dividir dados por uma característica e depois por outra, buscando separar melhor as categorias. O processo de indução de árvores estudado por Quinlan ajuda a ver como uma estrutura que parece um conjunto de regras pode ser aprendida, não apenas fornecida por um especialista.
Uma árvore muito ajustada a poucos exemplos pode memorizar detalhes. Uma combinação de árvores, com diversidade nas construções, pode reduzir certas fragilidades. Random Forests, associadas ao trabalho de Leo Breiman, exploram árvores e escolhas aleatórias para combinar previsões. A página original de Breiman apresenta o método.
As máquinas de vetores de suporte, ou SVMs, procuram uma separação com boa margem entre categorias. Volte aos pontos no papel. Se há várias linhas que separam corretamente os dados, uma linha que passa espremida junto aos pontos pode ser mais sensível a pequenas mudanças. A margem ajuda a escolher uma fronteira com distância em relação aos exemplos que mais importam para defini-la.
Com técnicas chamadas kernels, determinadas relações podem ser tratadas como separações em outra representação. A representação altera o tipo de fronteira que o modelo pode encontrar, embora nem todo problema fique simples com essa troca. O artigo de Cortes e Vapnik de 1995 é um marco dessa linha.
Esses métodos continuam relevantes porque muitos problemas têm tabelas, volumes moderados de dados e restrições de custo. Um sistema que prevê uma quantidade a partir de um cadastro não precisa necessariamente de uma rede com bilhões de parâmetros. A técnica adequada depende dos dados, do objetivo e das condições de uso.
treino não é prova de que funciona fora dele
Se você treina e avalia nos mesmos exemplos, há um problema. O modelo pode ficar ótimo em reproduzir aquele conjunto e ruim em casos novos. Uma criança que decorou a ordem das respostas de uma lista não necessariamente aprendeu a fazer a operação.
Por isso, separar dados de treino e de teste é tão importante. O treino participa do ajuste. O teste procura medir o comportamento em exemplos que não foram usados diretamente para ajustar o modelo. Outros conjuntos podem ajudar a escolher configurações durante o desenvolvimento; o cuidado é não transformar o teste final em mais um material de treino por tentativas repetidas.
O sobreajuste, ou overfitting, prende a solução a particularidades dos exemplos e prejudica a generalização. A perda no treino pode cair sem melhorar o uso real: em quais dados o gráfico está medindo?
Também existe vazamento de dados. Se uma informação que só estaria disponível depois da decisão entra no treinamento ou na avaliação, o resultado fica artificialmente fácil. Prever amanhã usando um dado que só existe depois de amanhã é uma demonstração enganosa, mesmo que o algoritmo faça todas as contas corretamente.
como uma rede ajusta os próprios pesos
No treino, a rede tenta, mede a diferença para o alvo e ajusta seus números internos. Ela combina entradas, pesos e operações não lineares; unidades intermediárias alimentam outras unidades. Vamos dar nomes às partes desse ciclo.
Treinar começa por definir uma medida de erro, a função de perda. Ela compara a previsão com o alvo e atribui um custo. O objetivo do procedimento de treinamento é encontrar parâmetros que reduzam esse custo segundo os exemplos disponíveis.
Mas uma rede pode ter muitos pesos. Como saber quais mexer, em qual sentido e quanto? O gradiente informa a sensibilidade da perda a pequenas mudanças dos parâmetros. A retropropagação, ou backpropagation, calcula essas sensibilidades através das camadas usando a relação entre as operações.
O artigo de Rumelhart, Hinton e Williams de 1986 foi central para popularizar a aprendizagem de representações em camadas intermediárias. Não foi a invenção absoluta de toda a diferenciação reversa: há antecedentes. O que ganhou força foi uma maneira prática de treinar redes que podiam representar mais do que um separador simples.
Imagine descer um terreno sem enxergar a paisagem inteira. A inclinação local indica uma direção de descida. Pequenos passos podem reduzir a altura, mas não garantem encontrar o lugar mais baixo de toda a paisagem. No treinamento, a “paisagem” é o erro em função dos parâmetros, e o cálculo de inclinações é matemático.
Na experiência abaixo, você escolhe AND ou XOR e compara um neurônio com uma rede que tem quatro unidades intermediárias. A rede recebe todos os quatro exemplos, calcula previsões e ajusta pesos. O treinamento é real, feito aqui no navegador, com a mesma inicialização quando você reinicia.
execução simplificada · treino local
rodadas: 0 · perda média: 0.8664
| entradas | esperado | probabilidade de 1 | decisão |
|---|---|---|---|
| 0 / 0 | 0 | 31.5% | 0 ✓ |
| 0 / 1 | 1 | 38.8% | 0 ✗ |
| 1 / 0 | 1 | 14.5% | 0 ✗ |
| 1 / 1 | 0 | 19.0% | 0 ✓ |
pesos da saída: -0.99 / 0.32 · ajuste de base da saída: -0.78
A perda média é a entropia cruzada binária. O treino usa os quatro exemplos da tabela. Acertá-los não mede generalização para outros problemas.
AND pede “os dois ligados”; XOR pede “apenas um ligado”. Um neurônio consegue aprender uma separação para AND. Em XOR, mais insistência não resolve o limite da arquitetura. A camada intermediária permite formar outras combinações, e o ajuste consegue reduzir o erro nesse exemplo.
A previsão é uma probabilidade; a tabela aplica um corte para decidir a categoria. Probabilidades diferentes podem dar a mesma decisão, por isso contar acertos e medir a perda respondem a perguntas diferentes.
imagens, sequências e recompensas pedem estruturas diferentes
Uma rede convolucional, ou CNN, aproveita relações locais em imagens. Um filtro pequeno percorre regiões, usando os mesmos pesos em lugares diferentes. Um padrão aprendido não precisa ser reaprendido separadamente para cada coordenada da imagem. Isso dá à arquitetura uma hipótese útil sobre como imagens são organizadas.
O trabalho de LeCun e colaboradores de 1998 documenta redes e aplicações de reconhecimento de documentos antes de AlexNet. O caminho entre pixels e uma decisão passa por representações aprendidas; a arquitetura ajuda a explorar a estrutura espacial.
Um antecedente importante é o Neocognitron, apresentado por Kunihiko Fukushima em 1980. Camadas combinavam detecção de características locais com tolerância a deslocamentos: reconhecer que um traço está presente mesmo quando ele aparece um pouco mais à esquerda ou à direita. O artigo de Fukushima ajuda a entender a linhagem das CNNs. Ele não usava o treinamento por retropropagação das redes convolucionais posteriores; inspiração arquitetural e regra de ajuste precisam ser distinguidas.
Em sequências, a ordem importa. “O cachorro mordeu o homem” e “o homem mordeu o cachorro” têm as mesmas palavras, mas relações diferentes. Redes recorrentes mantêm um estado enquanto percorrem entradas. Uma dificuldade de treinamento é preservar informação relevante ao longo de muitos passos.
LSTMs, apresentadas por Hochreiter e Schmidhuber em 1997, regulam o que entra, permanece e sai de um estado interno. É esse fluxo de informação que “memória” descreve aqui.
No aprendizado por reforço, o sistema aprende a escolher ações a partir de consequências e sinais de recompensa. Um agente num jogo pode receber um resultado favorável por vencer e precisar descobrir ações que aumentem a chance desse resultado. A recompensa pode chegar muito depois da escolha; atribuir valor às ações intermediárias faz parte da dificuldade.
Richard Sutton desenvolveu métodos de diferença temporal, e o Q-learning de Watkins e Dayan se tornou uma referência. São maneiras de aprender estimativas de valor e orientar decisões. Não pressupõem linguagem natural, nem dependem de um usuário conversando.
Na diferença temporal, sistematizada por Sutton em 1988, uma previsão pode ser atualizada comparando-a com uma recompensa recente e com a nova estimativa do que ainda acontecerá. Imagine rever sua previsão de chegada depois de completar um trecho da viagem, sem esperar chegar ao destino para aprender alguma coisa. Em jogos, isso ajuda a atribuir valor a situações intermediárias.
O Q-learning aprende valores de ações em estados e pode atualizar uma estratégia desejada usando experiência coletada por outra estratégia; essa distinção é chamada de off-policy. Explorar uma alternativa não obriga o sistema a considerá-la sua melhor ação futura. A demonstração de convergência de 1992 depende de hipóteses sobre exploração, taxas de atualização e ambiente. Ela não promete que qualquer agente aprenderá qualquer tarefa só por receber recompensas.
A recompensa também pode estar mal desenhada. Um sistema pode maximizar o número registrado sem realizar o objetivo que a pessoa tinha em mente. Aprender a ganhar pontos não equivale a aprender justiça, prudência ou intenção humana. Daqui a algumas décadas, quando preferências humanas e verificadores forem usados para ajustar modelos de linguagem, essa dificuldade vai reaparecer com outra escala.
O que guardar dessas famílias: o tipo de problema, a estrutura do modelo e o sinal de aprendizagem são escolhas diferentes.
| Pergunta | Exemplos desta parte |
|---|---|
| Que regularidade procurar? | árvores aprendem divisões; SVMs procuram margens; modelos probabilísticos representam incerteza. |
| Como organizar as entradas? | CNNs exploram vizinhanças em imagens; redes recorrentes e LSTMs percorrem sequências. |
| De onde vem o sinal de ajuste? | rótulos no supervisionado, estrutura dos dados no autossupervisionado, consequências no reforço. |
Essas escolhas podem se combinar. O aumento de dados e computação permitiria experimentar algumas delas em outra escala.
dados e computadores mudam a escala
uma vitória no xadrez, sem um cérebro de enxadrista
Em 1997, Deep Blue derrotou Garry Kasparov numa disputa de seis partidas. A vitória teve enorme força simbólica: um computador venceu um dos maiores enxadristas da história numa atividade usada como exemplo de inteligência humana.
O placar foi 3,5 a 2,5. Segundo a IBM, o sistema podia examinar cerca de 200 milhões de posições por segundo. O número mede a busca naquele equipamento. Não há uma conversão disso para "pensamentos por segundo" de um jogador.
O sistema combinava busca, avaliação de posições, conhecimento específico e hardware especializado. Não era um modelo de linguagem nem aprendia xadrez do modo de sistemas neurais posteriores. A história preservada pela IBM documenta o resultado e a engenharia por trás dele.
Pense num jogador olhando algumas jogadas à frente. Cada ação abre respostas possíveis do adversário. O número de combinações cresce, e avaliar tudo até o fim da partida é impraticável. Um sistema pode explorar parte da árvore, descartar possibilidades e estimar quais posições são mais favoráveis. O conhecimento de domínio ajuda a decidir o que investigar e como avaliar o que encontrou.
A vitória mostra que desempenho pode ser obtido por mecanismos diferentes dos que uma pessoa usa. Não precisamos atribuir ao programa a experiência humana de gostar de xadrez, sentir pressão ou ter uma intuição consciente para reconhecer que ele jogou de forma extraordinária.
Também mostra o limite de uma tarefa estreita. Vencer xadrez não dá automaticamente capacidade de dirigir, traduzir ou compreender uma conversa. O tabuleiro tem regras explícitas, estado representável e objetivo relativamente claro. O mundo fora dele tem condições bem diferentes.
O aprendizado por reforço já oferecia outra trajetória nos jogos. TD-Gammon, de Gerald Tesauro, usava redes e aprendizagem por diferenças temporais para jogar gamão, explorando resultados de partidas. Seu relato de 1995 documenta o trabalho. Busca e aprendizagem continuaram se desenvolvendo e, mais tarde, seriam combinadas em outros sistemas.
por que uma placa de vídeo ajuda a treinar uma rede?
Em 2006, Hinton, Osindero e Teh apresentaram um método de treinamento de redes profundas com uma estratégia de pré-treinamento por camadas. O artigo sobre deep belief networks ajudou a retomar o interesse nessas redes. "Deep", profundo, se refere às várias camadas de operações aprendidas.
Treinar muitas camadas era difícil por razões de otimização e custo. Uma arquitetura expressiva não serve muito se o procedimento de ajuste não encontra uma boa solução ou exige recursos inviáveis. Métodos de treinamento e recursos disponíveis estavam mudando essas condições.
Parte dessas condições veio das GPUs, as unidades de processamento gráfico. Desenhar uma cena envolve fazer muitas operações parecidas sobre muitos elementos. Esse tipo de trabalho favorece processamento paralelo. Redes neurais também executam enormes quantidades de multiplicações e somas sobre grupos de números.
Uma matriz é uma organização de valores em linhas e colunas. Essa tabela permite reunir relações e calcular muitas combinações de uma vez. Quando uma camada combina vários valores de entrada com vários pesos, operações matriciais oferecem uma linguagem e uma implementação eficientes.
A GPU consegue executar muitos desses cálculos com grande rendimento. O ganho depende de memória, formato dos dados, tamanho do trabalho, movimentação de valores e implementação. Acrescentar um equipamento potente a um programa que passa o tempo esperando dados não resolve todo o problema.
Uma ponte prática foi CUDA, apresentado pela NVIDIA em 2006, com ferramentas disponibilizadas em 2007: pesquisadores podiam usar GPUs para computação além dos gráficos. Em um estudo de 2009, Raina, Madhavan e Ng relataram ganhos de até 55 vezes em relação a uma CPU de dois núcleos. Uma configuração de rede com cerca de 100 milhões de parâmetros passou de semanas para aproximadamente um dia. O número pertence àquele experimento; o marco é tornar experimentos maiores praticáveis, não prometer o mesmo ganho para qualquer programa.
ImageNet: dados são uma infraestrutura
Uma rede precisa de exemplos, e avaliar avanços exige condições de comparação. ImageNet, apresentado em 2009 por Jia Deng e colaboradores, organizou uma grande base de imagens por categorias. Fei-Fei Li teve papel central na liderança desse esforço.
Montar o dataset deu trabalho. Coletar, organizar e anotar imagens exigiu projeto e trabalho humano. Pessoas definiram categorias, selecionaram exemplos e produziram rótulos. O artigo de ImageNet documenta a construção da base.
Na apresentação de 2009 eram 3,2 milhões de imagens, 5.247 categorias organizadas pela WordNet e doze grandes ramos dessa hierarquia. Parte da verificação usou trabalhadores do Mechanical Turk. Esses números descrevem aquela versão; não são o tamanho de todas as versões posteriores nem o recorte usado em cada competição.
Um dataset é um conjunto organizado de dados usado num trabalho. Um benchmark é uma configuração de avaliação que permite comparar resultados. Eles podem estar relacionados, mas não são a mesma coisa. Uma base pode servir a muitos experimentos; uma avaliação escolhe dados, tarefas, medidas e condições.
Ter um benchmark comum mudou a dinâmica da pesquisa em visão. Equipes podiam comparar métodos numa tarefa compartilhada. Isso favorece progresso mensurável, mas também pode estreitar incentivos: melhorar a pontuação daquela prova não é necessariamente resolver todas as dificuldades da visão no mundo real.
Em 2012, AlexNet, de Alex Krizhevsky, Ilya Sutskever e Geoffrey Hinton, demonstrou uma vantagem marcante na competição de classificação de imagens. A combinação envolvia CNNs, GPUs, muitos dados e escolhas de treinamento e regularização. Nenhum desses ingredientes pode ser apagado da explicação.
O artigo original informa erro top-5 de 15,3% contra 26,2% na competição de 2012. “Top-5” aceita que a categoria correta esteja entre cinco sugestões. Não é a taxa de erro para qualquer imagem possível, nem a mesma medida que exigir uma única resposta correta.
Os 15,3% pertencem a uma combinação de sete redes submetida à competição. A rede descrita no artigo tinha cerca de 60 milhões de parâmetros; no teste ILSVRC-2010, o PDF informa 17,0% de erro top-5. Distinguir edição, conjunto e combinação de modelos é necessário até para entender um resultado histórico tão famoso.
Com deep learning, a rede aprende também as representações usadas para resolver a tarefa. Em muitas abordagens anteriores, pessoas projetavam manualmente características: padrões de bordas, formas, frequências ou combinações que pareciam relevantes. Redes profundas passaram a aprender muitas dessas transformações junto com a decisão final.
As pessoas continuam escolhendo o dataset, o objetivo, a arquitetura e o treinamento. Parte do trabalho muda de lugar: em vez de desenhar à mão todas as características úteis, parte da representação pode surgir do ajuste sobre exemplos.
palavras viram posições, sequências viram problemas de memória
Em linguagem, embeddings são representações por vetores: listas de números aprendidas para representar palavras, tokens ou outros objetos. Word2Vec, associado aos trabalhos de Mikolov e colaboradores em 2013, tornou especialmente visível a utilidade dessas representações.
Imagine um mapa de cidades, mas com muitas dimensões e coordenadas aprendidas a partir de usos. Elementos usados em contextos relacionados podem adquirir relações úteis nesse espaço. O trabalho original investiga representações eficientes de palavras. Não precisamos interpretar cada coordenada como “quanto essa palavra é feliz” ou “quanto é humana”; o valor está no conjunto e nas operações que ele permite.
Analogias entre vetores não são leis semânticas universais. O mapa reflete regularidades dos dados, inclusive desigualdades e associações problemáticas.
Em 2014, modelos seq2seq mostraram uma maneira neural de mapear uma sequência em outra, como uma frase de entrada numa tradução. O artigo de Sutskever, Vinyals e Le usava LSTMs. Uma parte codificava a entrada; outra produzia a saída.
Comprimir a informação de uma frase longa numa representação fixa cria um gargalo. Você pode perceber a dificuldade sem matemática: tente ler um parágrafo, fechar o livro e traduzir tudo usando apenas o que conseguiu reter num resumo muito pequeno.
Bahdanau, Cho e Bengio propuseram um mecanismo de atenção para que o processo de tradução pudesse consultar representações de partes da entrada conforme produzia a saída. O trabalho foi disponibilizado em 2014, antes do Transformer. O tradutor aprendia a combinar informação de posições diferentes, operação que vamos acompanhar na próxima parte.
gerar, aprofundar e aprender a jogar
Redes adversárias generativas, ou GANs, do inglês generative adversarial networks, propostas por Goodfellow e colaboradores em 2014, montaram um jogo entre dois modelos. Um gerador produz exemplos; um discriminador tenta distinguir exemplos produzidos de exemplos do conjunto real. Os objetivos se enfrentam, e o treinamento pode melhorar a geração.
Dá pra comparar com um falsificador e um fiscal: o primeiro tenta produzir algo convincente, o segundo tenta identificar a origem. No programa, são duas funções ajustadas por otimização. O artigo das GANs descreve essa construção, que também tem dificuldades de estabilidade e variedade dos resultados.
ResNets introduziram conexões residuais: caminhos que permitem combinar uma representação com uma transformação aprendida dela. Isso ajudou a treinar redes muito profundas. O trabalho de He e colaboradores, divulgado em 2015 e apresentado no CVPR de 2016, tornou claro que profundidade precisava de uma arquitetura que facilitasse o fluxo de informação e o ajuste.
No reforço, DQN combinou redes profundas com aprendizagem de valores para jogar Atari a partir de pixels. O trabalho inicial de 2013 antecede o artigo na Nature de 2015. Uma rede podia aprender representações úteis para agir sem receber previamente uma lista manual de todas as características visuais relevantes.
AlphaGo combinou redes de política, redes de valor e busca. Uma política orienta ações; uma estimativa de valor ajuda a avaliar posições; a busca explora alternativas. O artigo de janeiro de 2016 documenta a vitória sobre Fan Hui, e a disputa com Lee Sedol ocorreu em março daquele ano. O artigo original deixa visível a combinação, não uma vitória de “redes sozinhas” sobre todo o restante.
Os tamanhos e condições contam outra parte da história: ResNet apresentou redes de 152 camadas; o artigo de DQN de 2015 avaliou 49 jogos, treinando um agente separado para cada jogo com a mesma receita geral. AlphaGo venceu Fan Hui por 5 a 0 em outubro de 2015, antes da publicação, e Lee Sedol por 4 a 1 em março de 2016. Não eram um único modelo capaz de jogar qualquer jogo sem treino, nem demonstrações fora de suas regras de avaliação.
Transformers e modelos reutilizáveis
primeiro, a linguagem precisa virar entrada
Um computador não recebe uma palavra como uma ideia pronta. Recebe uma representação. Nos modelos de linguagem, o texto costuma ser dividido em tokens, unidades que podem corresponder a palavras, pedaços de palavras, sinais ou outras sequências, dependendo do tokenizador.
“Token” aqui tem outro significado que o token de certificado discutido no post de criptografia. É uma unidade do processamento de texto. A mesma palavra aparece em vários contextos técnicos; aprender o conceito específico evita misturar funções que não têm relação.
Por que dividir assim? Um vocabulário com toda palavra e variação possível seria enorme e ainda encontraria novidades. Trabalhar apenas com unidades muito pequenas alonga sequências. Métodos que aprendem combinações frequentes oferecem um compromisso: sequências comuns podem virar unidades reutilizáveis, enquanto outras são representadas por pedaços.
O byte-pair encoding, BPE, oferece uma maneira de construir essas combinações. Na experiência abaixo, o algoritmo começa pelos bytes do texto e junta pares adjacentes que se repetem. Você escolhe quantas junções usar e consegue reconstruir o texto a partir dos tokens produzidos.
execução simplificada · junções locais
Bytes que ainda não formam um caractere UTF-8 aparecem em hexadecimal (0x…). ␣ representa um espaço.
o + ␣ → o␣a + t → atat + o␣ → ato␣
o gato viu o rato e o gato viu a casa✓ decode(encode(texto)) == texto
Esse experimento ensina uma operação, mas não representa o tokenizador de todo modelo comercial. A escolha do vocabulário, a forma de tratar caracteres e os dados usados importam. Português, código, números e outros tipos de texto podem ocupar quantidades diferentes de tokens para uma mesma quantidade aparente de informação.
Depois da divisão, cada token é associado a uma representação numérica. As camadas trabalham sobre essas representações. As representações são valores aprendidos, usados nos cálculos das camadas e transformados conforme o contexto. Não há uma definição de dicionário colada em cada token.
Isso também ajuda a entender por que pequenas alterações no texto podem mudar comportamento. A divisão em tokens pode ser diferente, as posições mudam e as relações entre as representações são recalculadas. A superfície que parece quase igual para uma pessoa pode resultar numa entrada diferente para o sistema.
atenção é uma operação, não um estado mental
Volte à frase: “o gato dormiu porque ele estava cansado”. Pra uma pessoa, “ele” pode se referir ao gato. Para um modelo, uma questão útil é permitir que a representação da posição de “ele” combine informação de outras posições da sequência.
Na atenção, escores calculados a partir das representações são convertidos em pesos, e esses pesos orientam uma combinação de valores. Uma posição pode usar mais informação de outra e menos de uma terceira. Na autoatenção, ou self-attention, essas consultas acontecem entre posições da própria sequência.
“Atenção” nomeia essa operação matemática, não concentração subjetiva. Seu mapa de pesos, sozinho, não explica todo o comportamento da rede.
O visual abaixo usa pesos escolhidos para ensinar a mistura, sem executar um Transformer. Ele considera uma leitura da frase completa. Em modelos que geram o próximo token, máscaras restringem quais posições podem ser consultadas; uma posição não pode usar um futuro que ainda precisa prever.
ilustração · participações escolhidas
escolha a posição que consulta as outras
1. posições separadas
oposição 1gatoposição 2dormiuposição 3porqueposição 4eleposição 5estavaposição 6cansadoposição 7
cada unidade recebe uma representação, e a posição ajuda a distinguir a ordem. aqui as palavras inteiras são unidades didáticas; um tokenizador real pode dividi-las.
pesos inventados para a explicação; não são medições de um Transformer
o que mudou em 2017
O artigo Attention Is All You Need, de Vaswani e colaboradores, apresentou o Transformer em 2017. A arquitetura usava atenção como mecanismo central no lugar da recorrência que organizava muitos modelos anteriores. O artigo original investigava tarefas de tradução.
Uma rede recorrente tem uma dependência entre passos: o estado do passo seguinte depende do anterior. Isso dificulta fazer muitos desses cálculos ao mesmo tempo. O Transformer tornou possível processar muitas posições em paralelo durante o treinamento, aproveitando melhor o tipo de hardware que estava se tornando central.
Esse paralelismo vale durante o treinamento. Na geração autorregressiva, cada próximo token depende do contexto, incluindo os anteriores: a saída continua sequencial.
A ordem também precisa entrar na representação, porque misturar uma coleção de posições sem indicação de ordem perderia diferenças entre frases. O Transformer original usa informação posicional. A arquitetura ainda inclui outras operações, como camadas que transformam representações e conexões residuais. O título do artigo não deve ser lido como uma lista literal de que só há atenção e nada mais.
Múltiplas cabeças de atenção permitem diferentes projeções e combinações em paralelo. Uma analogia possível é examinar a mesma sequência por vários recortes. Mas não devemos fixar uma cabeça como “a cabeça que entende pronome” sem investigar o modelo: as representações distribuídas são mais complicadas que essas etiquetas.
Atenção também tem custo. Na versão densa tradicional, combinar todas as posições com todas as outras faz o trabalho crescer aproximadamente com o quadrado do comprimento da sequência. Dobrar o contexto não custa necessariamente só o dobro naquela operação. Outras arquiteturas e técnicas posteriores procuram reduzir gargalos, mas o limite ajuda a explicar por que contexto longo envolve engenharia difícil.
três maneiras de organizar a mesma família
O Transformer abriu várias famílias de modelos. Uma maneira de acompanhar é distinguir o papel da entrada e da saída.
Um encoder constrói representações de uma entrada. BERT, apresentado por Devlin e colaboradores em 2018 e publicado em 2019, tornou especialmente forte o pré-treinamento de representações usando contexto dos dois lados. Uma tarefa importante era reconstruir partes mascaradas do texto. O artigo de BERT documenta a abordagem e a adaptação para tarefas posteriores.
Um decoder autorregressivo produz sequências prevendo sucessivamente o próximo token, com acesso ao contexto permitido. A linhagem GPT explorou essa direção a partir de 2018, como descreve o trabalho inicial da OpenAI. Para produzir “o gato dormiu”, o sistema faz operações sobre o contexto, escolhe uma continuação e usa o resultado para continuar.
Uma arquitetura encoder-decoder representa uma entrada e gera uma saída condicionada a ela. T5, de Raffel e colaboradores, organizou muitas tarefas no formato “texto para texto”: uma entrada textual é transformada em outra saída textual. O trabalho de T5 sistematiza comparações de dados, objetivos e transferência.
São categorias de arquitetura; um produto pode combinar várias delas com ferramentas. Seu nome comercial não revela essa composição.
uma base ampla, adaptável depois
Pré-treinamento é uma fase ampla de aprendizagem antes de adaptações posteriores. Num grande modelo de linguagem, a tarefa de prever ou reconstruir texto pode ser construída a partir do próprio corpus. Não é necessário que uma pessoa escreva a resposta ideal para cada possível pergunta futura.
Ajuste fino, ou fine-tuning, é treinamento posterior para uma tarefa, domínio ou comportamento. Aqui os parâmetros mudam. Já colocar instruções e exemplos no contexto muda a entrada com os parâmetros fixos, embora o comportamento resultante possa mudar bastante.
GPT-3, descrito por Brown e colaboradores em 2020, tornou essa diferença especialmente visível. O maior modelo do trabalho tinha 175 bilhões de parâmetros e podia realizar várias tarefas a partir de instruções e exemplos no próprio contexto. O artigo de GPT-3 documenta condições, resultados e limites.
Mostrar duas traduções e pedir uma terceira permite usar o padrão naquela execução: é o aprendizado em contexto, com os pesos fixos, como na distinção anterior entre entrada e treinamento.
O interesse em leis de escala cresceu com regularidades empíricas entre quantidade de dados, tamanho do modelo, computação e perda. O trabalho de Kaplan e colaboradores de 2020 documenta essas relações. São relações experimentais úteis para planejar recursos; não garantem o mesmo ganho em toda medida de qualidade.
Em 2021, pesquisadores de Stanford propuseram a expressão modelo de fundação para bases treinadas em dados amplos e adaptáveis a várias tarefas. O relatório de Bommasani e colaboradores discute tanto oportunidades quanto riscos: reutilizar uma base pode disseminar capacidades e também propagar suas falhas por muitas aplicações.
além do texto, além da conversa
CLIP, de Radford e colaboradores, aprendeu relações entre imagens e descrições textuais. O artigo de 2021 mostra como representações das duas modalidades podem ser alinhadas. Isso oferece outra ponte: a linguagem pode ajudar a organizar tarefas de visão sem ser a única entrada do sistema.
O treinamento usou 400 milhões de pares de imagem e texto. O objetivo contrastivo aproxima representações correspondentes em relação a alternativas: uma descrição deve combinar melhor com sua imagem que com outra. Isso permitiu avaliar transferência zero-shot, isto é, sem treinar novamente naquela tarefa específica, usando descrições textuais das categorias. Zero-shot não significa que o modelo nunca viu conceitos relacionados no pré-treinamento.
Multimodalidade significa trabalhar com mais de um tipo de informação, como texto, imagem, áudio ou vídeo, aprendendo relações conforme a arquitetura e o treinamento.
AlphaFold oferece uma trajetória diferente da conversa generalista. O sistema usou métodos neurais para predição de estruturas de proteínas, com resultados marcantes em avaliação científica. O artigo de Jumper e colaboradores de 2021 documenta a abordagem e os experimentos.
Prever uma estrutura ajuda em problemas científicos importantes. Ainda é diferente de conhecer automaticamente toda função biológica de uma proteína ou de dispensar experimentos. Esse cuidado mantém o tamanho da conquista sem transformá-la numa explicação de toda a biologia.
Essas aplicações já iam além da linguagem: relacionar imagens e descrições, adaptar uma base a tarefas diferentes e prever estruturas de proteínas. Em 2022, a interface de conversa tornaria parte dessa pesquisa muito mais fácil de usar.
Até aqui, há três escolhas para localizar os modelos: BERT representa uma entrada, GPT gera continuações e T5 transforma uma entrada em outra sequência. O pré-treinamento produz uma base; o ajuste fino muda seus parâmetros; exemplos no contexto orientam uma execução com parâmetros fixos. Multimodalidade amplia os tipos de entrada e saída. O mapa de famílias reúne essas relações para consulta.
a IA chega ao cotidiano
de prever texto a responder uma pessoa
Prever o próximo token pode ensinar regularidades úteis de linguagem, mas esse objetivo não equivale diretamente a responder bem a uma pergunta. Um texto da internet pode continuar uma frase com sarcasmo, ficção, erro ou uma citação. Um assistente precisa de um comportamento mais específico.
O ajuste por instruções usa exemplos de pedidos e respostas desejadas para orientar esse comportamento. Perguntar “explique fotossíntese para uma criança” é diferente de pedir apenas a continuação de um trecho de livro. O modelo precisa responder conforme o pedido, e o treinamento pode enfatizar esse padrão.
InstructGPT, descrito por Ouyang e colaboradores em 2022, combinou demonstrações humanas, comparações de respostas e ajuste posterior. Em uma etapa, pessoas escreviam exemplos. Em outra, comparavam alternativas, e essas preferências ajudavam a treinar um modelo de recompensa. Depois, o modelo de linguagem era otimizado para produzir respostas melhor avaliadas.
Esse processo é uma forma de aprendizado por reforço com feedback humano, ou RLHF. O artigo de InstructGPT documenta as etapas. O que mudou foi o objetivo: o objetivo de prever texto foi complementado por sinais sobre o comportamento desejado numa interação.
No estudo, um modelo ajustado de 1,3 bilhão de parâmetros foi preferido ao GPT-3 de 175 bilhões na distribuição avaliada. Isso ensina uma diferença importante: tamanho, qualidade de previsão e utilidade para um usuário não são a mesma medida. Um modelo maior pode não estar tão bem preparado para seguir o tipo de pedido que recebeu.
Uma resposta confiante, curta ou concordante pode agradar mesmo errada. Como a avaliação humana depende de instruções, conhecimento e critérios, aprovação e verdade factual podem divergir.
Por isso, “alinhamento” não deve virar palavra que encerra o assunto. Pode significar seguir uma instrução, respeitar políticas, evitar certos comportamentos ou atender valores sociais. Esses objetivos podem entrar em conflito e requerem avaliação contínua. RLHF trata partes do problema; não resolve toda a relação entre uma máquina e os interesses humanos.
Constitutional AI, associada à pesquisa da Anthropic, investigou outra combinação: princípios escritos orientam críticas e revisões, e feedback produzido por modelos pode participar do treinamento. A pesquisa original descreve um procedimento; “constituição” é uma forma de nomear os princípios usados, não a garantia de que um sistema possui ética própria ou aplica perfeitamente qualquer valor.
a interface mudou o alcance da tecnologia
O feedback humano também tem antecedentes: experimentos com GPT-2, em 2019, já ajustavam comportamentos como resumir usando preferências. Em 2022, o treinamento e o acesso público levariam essas técnicas a muito mais gente.
ChatGPT foi lançado em 30 de novembro de 2022. O anúncio original descrevia a relação com modelos GPT-3.5 e treinamento com feedback humano. A janela de conversa tornou muito mais fácil experimentar uma tecnologia que, até então, chegava a boa parte das pessoas por demonstrações, artigos ou integrações menos visíveis.
Você podia escrever uma pergunta, acompanhar uma resposta, pedir uma reformulação e continuar no mesmo fio. Isso reduz a distância entre ter uma curiosidade e usar o sistema. Não era necessário aprender uma linguagem de programação para testar um resumo, uma explicação ou um rascunho.
Uma interface nova pode ser uma mudança histórica enorme mesmo quando usa uma combinação de técnicas anteriores. A importância de um produto não se mede apenas por ter inventado uma arquitetura. Distribuição, acesso, integração e experiência de uso alteram quem consegue fazer o quê.
O contexto da conversa também permite que um pedido posterior se refira ao anterior. “Faça mais curto” tem pouco significado isoladamente e bastante quando a resposta anterior está disponível. Isso pode parecer memória pessoal, mas exige distinguir o histórico apresentado ao modelo de mudanças permanentes em seus parâmetros.
Em 2023 e 2024, produtos de várias organizações ampliaram o uso público de modelos de linguagem, código e multimodalidade. GPT-4, Claude, Bard/Gemini, Llama e Mistral são exemplos de trajetórias com regimes diferentes de acesso e distribuição. Esses modelos passaram a fazer parte de ferramentas cotidianas, com formas diferentes de acesso.
Foi aí que o chatbot passou a ocupar tanto espaço na conversa sobre IA. Esse era o incômodo do post anterior: usar uma dessas ferramentas começou a ser confundido com conhecer a área inteira.
Algumas datas ajudam a separar modelo de interface. GPT-4 apareceu em 14 de março de 2023; seu relatório omitia detalhes de arquitetura, equipamento e dados de treinamento. Claude 2 chegou em julho, Mistral 7B em setembro e Mixtral 8x7B em dezembro. O Google apresentou a família Gemini em dezembro de 2023, antes de renomear a interface Bard para Gemini em fevereiro de 2024. Nome de produto, família de modelos, licença e disponibilidade são informações diferentes.
alucinação: a frase cabe, o fato pode faltar
Um modelo de linguagem pode produzir uma resposta fluente que não corresponde aos fatos ou às fontes disponíveis. A área chama muitos desses casos de alucinação. O termo é uma metáfora para a saída do sistema, não um diagnóstico humano.
Considere pedir o nome de um artigo e sua referência. O modelo conhece padrões de títulos, autores, revistas e datas. Pode produzir uma combinação com aparência de bibliografia, mas que não corresponde a um documento existente. A forma pode ser convincente justamente porque o treinamento ensinou regularidades daquela forma.
O modelo pode ter aprendido informação útil e ainda errar ao produzir uma referência. A fluência não confere se o artigo existe; essa checagem precisa entrar na avaliação da resposta.
Há diferenças entre errar uma conta, citar uma fonte inexistente, omitir uma condição e seguir uma instrução indevida. A categoria geral ajuda a discutir um problema, mas avaliar um sistema exige separar os tipos de falha. Um percentual único pode esconder comportamentos muito diferentes.
Também não basta pedir “não alucine”. A instrução faz parte da entrada, mas não fabrica evidências ou garante que o modelo reconheça suas lacunas. Sistemas mais confiáveis combinam treinamento, dados adequados, ferramentas, avaliação e desenho do fluxo de uso.
consultar documentos muda a entrada
Uma pontuação alta pode esconder contaminação de benchmark: se perguntas ou respostas da avaliação estavam no material de treino, a prova deixa de medir apenas desempenho em exemplos novos. Formato, ferramentas, número de tentativas e orçamento de inferência também precisam ser comparáveis. Um exame conhecido não demonstra inteligência geral, e ampliar a escala não garante eliminar alucinações.
O mesmo cuidado vale para capacidades chamadas de emergentes. Parece que uma habilidade surgiu de repente quando a pontuação salta depois de certo tamanho. Mas uma métrica “tudo certo ou tudo errado” pode esconder melhorias graduais nos passos. Um estudo de 2023 mostrou esse efeito em avaliações específicas. O modo de medir pode produzir a aparência de um salto. O estudo não permite descartar toda capacidade nova como ilusória.
Uma maneira de trazer informação atual ou específica é recuperar documentos e colocá-los no contexto. RAG, geração aumentada por recuperação, combina uma etapa de busca com a geração condicionada ao material recuperado. O artigo de Lewis e colaboradores de 2020 é uma referência desse caminho.
Imagine perguntar o horário de funcionamento de um museu. O modelo pode ter visto informações antigas no treinamento. Uma aplicação pode consultar a página atual, selecionar um trecho e entregá-lo junto com a pergunta. Agora a resposta tem uma fonte disponível naquela execução.
A consulta acrescenta informação ao contexto, como os exemplos anteriores, sem atualizar os pesos por essa operação. O documento precisa estar disponível na execução em que será usado.
RAG também não garante que a aplicação encontrou o documento correto ou que a resposta o interpretou bem. A busca pode selecionar uma unidade do museu diferente, o trecho pode omitir um feriado e a geração pode confundir condições. É preciso avaliar a recuperação e a resposta, além da qualidade da fonte.
ensinar a retirar ruído para gerar imagens
A popularização da geração de imagens tem uma história técnica própria. Modelos de difusão aprendem operações relacionadas a um processo que acrescenta ruído aos dados e a um percurso gerador que remove ruído progressivamente.
No treinamento, podemos começar com uma imagem e acrescentar ruído em níveis conhecidos. O modelo recebe versões perturbadas e aprende uma tarefa de estimativa ligada a esse processo. Na geração, parte-se de ruído e aplicam-se transformações aprendidas para construir uma amostra.
O trabalho de Ho, Jain e Abbeel de 2020 é um marco dessa família. A geração produz uma nova amostra com regularidades aprendidas, condicionada ou não a informações como texto. Não revela uma fotografia que já estava escondida no ruído.
O visual é esquemático: mostra um desenho de casa ficando visível à medida que reduzimos uma camada de ruído programada. Ele ilustra um percurso, mas não executa o procedimento matemático de um modelo de difusão e não gera uma imagem nova a partir de um prompt.
ilustração · desenho fixo
1. ruído: no processo gerador real, a amostra começa em uma distribuição de ruído. neste visual, o padrão é reproduzível.
voltar: acrescentar ruído · O desenho se torna mais definido em seis etapas. A imagem final está programada: aqui não há um modelo gerando imagens.
Modelos de difusão latente fazem parte desse trabalho numa representação comprimida, em vez de operar sempre diretamente em todos os pixels. O artigo de Rombach e colaboradores, disponibilizado em 2021 e publicado em 2022, explica essa combinação de eficiência e condicionamento.
DALL-E 2, Stable Diffusion e Midjourney ajudaram a tornar geração texto-imagem uma atividade pública em 2022. Eles reuniam métodos geradores, representações de linguagem, dados, hardware e interfaces. Uma imagem bonita, assim como uma frase fluente, pede avaliação própria: fidelidade ao pedido, variedade, direitos, vieses e possibilidade de reproduzir exemplos do treinamento.
Geração visual também tem caminhos distintos. O DALL-E original, de janeiro de 2021, usava um Transformer autorregressivo; não era um modelo de difusão. A difusão tornou-se especialmente visível ao público em 2022, inclusive com Stable Diffusion. Vídeo generativo acrescentou a necessidade de manter relações ao longo do tempo: produzir um quadro convincente não garante que um objeto preserve posição e identidade nos próximos.
adaptar e reduzir custo
Conforme modelos grandes viraram bases reutilizáveis, cresceu a necessidade de adaptá-los sem repetir o treinamento inteiro. LoRA, proposta por Hu e colaboradores em 2021, aprende atualizações de menor dimensão sobre determinadas operações. O artigo original explica como reduzir o conjunto de parâmetros ajustados.
Quantização representa valores com menos precisão numérica. Isso pode reduzir armazenamento e requisitos de memória, com consequências que dependem do modelo e da técnica. QLoRA, descrita por Dettmers e colaboradores em 2023, combina quantização e adaptação de baixo posto para tornar certos ajustes mais acessíveis. São reduções de custo em etapas específicas; o treinamento continua exigindo recursos.
Destilação treina um sistema para reproduzir comportamentos ou sinais de outro. Pode produzir um modelo menor que retém parte da utilidade, embora não preserve automaticamente todas as capacidades. É uma maneira de transferir comportamento sob um objetivo e um conjunto de exemplos.
Adaptar um modelo e reduzir sua memória ajuda quando a pergunta passa a ser "quanto custa colocar isso numa aplicação?". Custo e latência dependem também dessa engenharia em volta da rede.
raciocínio, ferramentas e agentes
gastar computação enquanto resolve
Se você entrou por aqui, vale retomar treinamento e inferência e consulta a documentos. Agora a pergunta é: quanto trabalho um sistema faz depois de receber um problema e antes de entregar a resposta?
Há várias maneiras de gastar mais computação nessa fase. Produzir candidatos, comparar alternativas, revisar uma tentativa, fazer busca e usar verificações são exemplos. O objetivo é melhorar uma solução usando um orçamento maior de processamento durante a execução.
Pedir passos intermediários em um prompt já era uma linha de investigação anterior a 2024. A mudança posterior envolve combinar essa possibilidade com treinamento e estratégias de alocação de recursos. Test-time compute, computação em tempo de resolução, nomeia esse eixo.
O trabalho de Snell e colaboradores de 2024 estudou trocas entre tamanho do modelo e processamento durante a solução em tarefas e condições específicas. O ganho dependia da tarefa e da forma de distribuir o processamento. A comparação abriu outra opção além de aumentar o modelo, sem estabelecer uma vantagem universal.
Em certas comparações com orçamento de operações equivalente, as estratégias de inferência superaram usar simplesmente um modelo 14 vezes maior. A dificuldade do problema e a distribuição do processamento alteravam o resultado. O número descreve uma comparação experimental, não uma regra de substituição entre qualquer par de modelos.
OpenAI o1, apresentado em setembro de 2024, tornou esse regime especialmente visível em produtos. A empresa descreveu treinamento por reforço e ganho com maior computação na resolução. O anúncio é fonte para o lançamento e os resultados relatados; comparações de desempenho precisam conservar suas condições e sua origem.
DeepSeek-R1, apresentado em janeiro de 2025, ampliou o acesso a modelos e destilações associados a raciocínio reforçado. O artigo técnico distingue R1-Zero, R1 e modelos destilados. Essas variantes não devem ser tratadas como se fossem o mesmo procedimento com nomes intercambiáveis.
“Raciocínio” nomeia aqui capacidades e estratégias investigadas em problemas. Passos mais longos podem conter erros, e a explicação produzida não revela necessariamente o processo interno que levou ao resultado.
verificar muda o jogo
No reforço com recompensas verificáveis, às vezes abreviado RLVR, uma resposta pode receber recompensa porque passou em testes ou chegou a um resultado verificável. A verificação reduz a dependência de alguém comparar cada solução, mas o teste precisa representar a tarefa. FastCuRL, de 2025, investigou esse caminho com um modelo de 1,5 bilhão de parâmetros e oito GPUs, ajustando a dificuldade dos exemplos e o comprimento das soluções. O exemplo mostra uma escala menor que a dos maiores treinamentos industriais, nas condições da tarefa avaliada.
Se o sistema gera uma solução de código, uma ferramenta pode executar testes. Se propõe uma jogada, um ambiente pode medir o resultado. Se responde a um problema com resposta verificável, há um sinal mais claro para comparar tentativas.
Essa possibilidade facilita treinamento e seleção de candidatos. O verificador fornece uma informação que a aparência da resposta não fornece sozinha. Um programa elegante que falha no teste precisa ser corrigido; uma alternativa menos elegante pode satisfazer a condição medida.
Mas um verificador só verifica o que foi definido. Testes incompletos podem aceitar um programa com erro. Uma resposta numérica pode estar certa por um caminho inválido, dependendo da tarefa. Uma solução pode passar numa prova e falhar quando os requisitos mudam.
Em temas abertos, como explicar um acontecimento histórico ou aconselhar uma organização, a medida de qualidade é mais difícil de condensar numa recompensa automática. Fontes podem divergir, condições podem estar ausentes e valores podem entrar em conflito. Um avanço em matemática não pode ser transferido por frase para toda forma de julgamento humano.
uma ferramenta dá acesso a algo fora dos pesos
Um modelo pode produzir um pedido estruturado para que um software execute uma ação. Essa ação pode consultar uma base, rodar uma conta, abrir um documento ou operar outra aplicação. O programa externo executa e devolve o resultado, que volta ao contexto.
Quando a aplicação consulta uma calculadora e devolve a conta ao modelo, temos uso de ferramentas. Pra avaliar o sistema, precisamos saber qual resultado veio da ferramenta e como o modelo o usou, em vez de atribuir o cálculo inteiro à rede.
Um agente, no sentido usado por muitos sistemas atuais, coloca essas operações num ciclo: observar, escolher uma ação, executar uma ferramenta, ler o resultado e decidir como continuar. “Agente” tem uma história anterior aos LLMs; o termo não foi inventado para o chatbot que chama uma ferramenta.
Vamos acompanhar um exemplo: encontrar horários de dois museus e montar uma tabela com fontes. A simulação abaixo mostra tanto o percurso que obtém as informações quanto outro em que um resultado é incompleto. Ela não consulta museus reais, não executa ferramentas e não contém dados de uma visita que você possa planejar.
simulação de fluxo · resultados fictícios
- 1observar
- 2planejar
- 3consultar
- 4ler resultados
- 5verificar
- 6responder
resultado observado
pedido fictício: montar uma tabela com os horários de Museu A e Museu B
o sistema recebe a tarefa e as condições: dois museus, horários e fontes verificáveis.
simulação local: nenhuma ferramenta é executada e nenhuma informação externa é consultada
Uma ferramenta também tem permissões. Saber escrever uma solicitação de ação não concede automaticamente acesso ao mundo. É a aplicação que define quais ferramentas existem, que dados podem ser vistos e quais operações são permitidas.
O Model Context Protocol, MCP, foi anunciado pela Anthropic em novembro de 2024 como um protocolo para integrar aplicações de IA com fontes e ferramentas. O anúncio original documenta a proposta. Um protocolo comum facilita conexões; não fornece, por si só, memória, competência, segurança ou autorização irrestrita.
contexto é parte da engenharia
O modelo recebe uma entrada organizada pela aplicação: instruções, histórico, documentos, resultados de ferramentas e estado da tarefa. Engenharia de contexto descreve o trabalho de selecionar e organizar esse material.
Se uma informação importante ficou fora, o modelo pode tomar uma decisão ruim mesmo que conseguisse usar aquela informação quando apresentada. Se o contexto mistura uma instrução confiável com texto externo que tenta comandar ações, a aplicação precisa distinguir os papéis.
Uma injeção de prompt explora justamente essa fronteira: texto encontrado num documento ou numa página tenta ser tratado como uma instrução para o sistema. O problema é de integração e controle, além de comportamento do modelo. Um documento que o agente lê não deveria herdar a autoridade de quem pediu a tarefa.
Em tarefas longas, erros também podem se acumular. Uma busca retorna a página errada, um resumo perde uma condição e uma ação usa esse resumo. O resultado final pode parecer bem organizado enquanto carrega uma falha de três passos atrás.
Ter uma janela de contexto grande informa quantos tokens podem entrar; não garante usar todos com a mesma qualidade. No estudo Lost in the Middle, de 2023, alguns modelos tiveram dificuldade maior quando a informação relevante estava no meio de textos longos. Imagine entregar uma pasta inteira e perguntar por uma data escondida na página 87: caber na pasta e encontrar a data são coisas diferentes. O resultado precisa ser reavaliado para cada modelo, versão e tarefa, sem virar uma condenação universal ao contexto longo.
a fronteira em outubro de 2026
No corte de 10 de outubro de 2026, convivem variantes que priorizam capacidade, velocidade e custo, sistemas multimodais e produtos que integram ferramentas. Há acesso por interfaces de conversa, interfaces de programação de aplicações (APIs, usadas por outros softwares) e distribuição de pesos, com condições diferentes. A tabela de anúncios e acesso conserva exemplos e fontes; ela é um retrato datado, não um ranking.
Pesos distribuídos, código disponível, dados publicados e receita de treinamento reproduzível são dimensões diferentes de abertura. A licença do artefato específico também importa. “Dá pra baixar” não resume todas essas perguntas.
A definição de IA de código aberto da OSI explicita liberdades de uso, estudo, modificação e compartilhamento e requisitos sobre os componentes. Open weights, pesos acessíveis, informa algo mais limitado. É possível distribuir pesos e manter restrições ou não fornecer informação suficiente para estudar e modificar o sistema nos termos dessa definição.
Modelos menores e execução local convivem com serviços de grande escala. Quantização, destilação e especialização podem reduzir requisitos. Em arquiteturas mixture-of-experts, ou MoE, partes diferentes do modelo são ativadas conforme o processamento; o total de parâmetros e o número utilizado em uma operação deixam de coincidir necessariamente. “Especialistas”, aqui, nomeia componentes da arquitetura, não profissionais humanos com disciplinas delimitadas.
Gemma e Ministral, além de variantes Qwen e destilações de R1, exemplificam essa direção. Rodar no dispositivo pode reduzir latência, permitir uso sem conexão constante e conservar determinados dados localmente. Essas vantagens dependem da aplicação e de seus outros componentes: baixar um modelo não garante que todo o fluxo seja privado ou caiba em qualquer celular.
Na programação, o sistema em volta do modelo costuma ser chamado de harness. Ele oferece editor, terminal, testes, limites de execução e montagem de contexto. Um agente pode editar, testar, observar uma falha e revisar. Grok Build abriu componentes desse sistema em julho de 2026, incluindo ferramentas, MCP e subagentes; isso não equivale a publicar os pesos do modelo. Subagentes são processos que recebem subtarefas, diferentemente dos “especialistas” internos de uma arquitetura MoE. Coordenar vários processos acrescenta comunicação e critérios de conclusão, não uma garantia automática de acerto.
O estado do campo é uma combinação de redes, busca, representação, memória externa, ferramentas, verificadores e infraestrutura. Algumas peças são recentes; outras têm décadas. O sistema consegue mais porque as peças foram ligadas, mas também pode falhar nas fronteiras entre elas. As ligações entre os componentes também precisam ser avaliadas.
a história além dos modelos
Chegamos aos sistemas atuais pelo caminho dos métodos. Agora vamos olhar para o outro eixo anunciado no começo: aplicações, instituições, infraestrutura e impactos — onde os sistemas já eram usados, quem os constrói e o que os sustenta. Esse trabalho esteve presente nas épocas anteriores, mesmo quando a narrativa acompanhou um algoritmo ou uma demonstração.
a IA que você já usava sem chamar de IA
Você provavelmente já usava outras formas de IA antes de abrir um chatbot: ao receber uma recomendação de filme, usar reconhecimento de voz ou procurar algo numa imagem.
Sistemas de recomendação organizam filmes, produtos, músicas e publicações. Uma abordagem conhecida procura regularidades nas preferências de pessoas e itens: quem escolheu coisas parecidas pode ter interesse em outras coisas relacionadas. Outras aprendem representações e previsões a partir de interações.
Isso inclui filtragem colaborativa e fatoração de matrizes. Imagine uma tabela em que linhas são pessoas, colunas são filmes e quase todas as avaliações estão vazias. A fatoração aprende representações menores de pessoas e filmes que ajudam a estimar valores ausentes. Não precisa saber conscientemente por que alguém gosta de um filme para encontrar regularidades úteis; também não pode tratar uma estimativa como uma preferência garantida.
O objetivo escolhido influencia o comportamento. Maximizar cliques não é a mesma tarefa que ampliar variedade, satisfação duradoura ou qualidade da informação. Um sistema pode melhorar a métrica registrada enquanto empobrece algo que não foi medido.
Há também um ciclo: o sistema seleciona o que a pessoa vê, a pessoa reage ao que foi selecionado e essa reação vira novo dado. Os dados registram reações às opções que o sistema mostrou, não a todas as opções que a pessoa poderia escolher. Esse ciclo também aparece fora das redes sociais.
Reconhecimento e síntese de fala têm trajetórias próprias, dos modelos estatísticos aos sistemas neurais e multimodais. Transcrever áudio, produzir voz e interpretar um pedido falado são tarefas distintas, embora uma interface possa reuni-las. Um sotaque pouco representado ou ruído de ambiente pode mudar o resultado de uma parte do fluxo antes mesmo de a pergunta chegar ao modelo de linguagem.
Em sistemas mais antigos, modelos acústicos e de linguagem eram componentes separados. Abordagens neurais posteriores ampliaram treinamento de ponta a ponta, como mapear áudio diretamente para texto, e também áudio para áudio. Isso reduz algumas separações do fluxo; não elimina a necessidade de avaliar transcrição, conteúdo, voz e condições de uso.
Na visão computacional, localizar objetos, segmentar uma imagem, classificar uma cena e relacionar imagem com texto também são problemas diferentes. Melhorar uma medida de classificação não resolve automaticamente percepção em trânsito, inspeção industrial ou imagens científicas. Precisamos saber qual tarefa foi avaliada.
Além das CNNs, o Vision Transformer, divulgado em 2020, dividiu imagens em pedaços e tratou suas representações como uma sequência. Pra resolver problemas de visão, descritores projetados manualmente, CNNs e Transformers procuram representações úteis por caminhos diferentes.
Na robótica, a tradição de controle e feedback continua essencial. Um modelo visão-linguagem-ação procura ligar percepção, instrução e comportamento físico. Mas mover um braço exige sensores, localização, controle e contato com objetos. A tolerância a erro depende da situação, e uma frase plausível não substitui uma ação fisicamente segura.
Nos anos 1980, Rodney Brooks explorou camadas de comportamento reativo: um robô podia responder a obstáculos sem primeiro construir uma descrição simbólica completa de tudo. Outra trajetória estimou probabilisticamente onde o robô estava e como era o ambiente. Trabalhos de Thrun, Fox e Burgard ligaram localização e mapeamento simultâneos, ou SLAM, do inglês simultaneous localization and mapping. Um sensor é incerto; observar e atualizar estimativas pode ser mais útil que fingir ter um mapa perfeitamente conhecido. Essas linhas convivem com planejamento e controle.
VLA, de vision-language-action, nomeia a ligação entre visão, linguagem e ação. Já um modelo como Qwen2.5-Omni, de março de 2025, reúne texto, imagem, áudio e vídeo sem, por isso, controlar um robô. Qwen3, de abril, destacou modos de resposta direta e de processamento deliberativo. “Multimodal” não informa sozinho quais entradas, saídas e ações um modelo suporta.
Em ciência e saúde, modelos podem contribuir para analisar imagens, prever estruturas, organizar documentação e apoiar investigação. A evidência necessária varia conforme o uso. Um resultado de pesquisa, uma autorização regulatória e uma demonstração de benefício em condições clínicas são categorias diferentes; nenhuma pode ser trocada silenciosamente pela outra.
AlphaFold 3, apresentado em maio de 2024, ampliou o problema para interações entre proteínas, DNA, RNA e outras moléculas. Genômica e modelos celulares também procuram regularidades em grandes conjuntos biológicos. Prever uma estrutura ou uma relação é uma contribuição científica; demonstrar que um tratamento melhora a vida de pacientes exige outro percurso de evidência.
O AI Index 2026 registrou 258 autorizações da FDA para dispositivos com IA em 2025 até setembro. Em uma população diferente, um estudo publicado no JAMA em 2025 examinou 903 dispositivos autorizados até agosto de 2024: 505 tinham estudos clínicos descritos publicamente, e 12 desses 505, ou 2,4%, incluíam ensaios randomizados. Esse denominador importa. Não significa 2,4% dos 258 dispositivos de 2025, nem que a ausência de descrição pública prove ausência de qualquer evidência clínica.
Em 2024, o Nobel de Física reconheceu trabalhos de John Hopfield e Geoffrey Hinton relacionados a redes neurais, e parte do Nobel de Química reconheceu Demis Hassabis e John Jumper pela predição de estruturas de proteínas, junto do prêmio a David Baker por projeto computacional de proteínas. Os anúncios de Física e Química documentam esse reconhecimento. O reconhecimento incluía redes neurais e aplicações científicas, bem além dos chatbots.
uma história de países e instituições
Empresas dos Estados Unidos ocupam boa parte da conversa recente, mas precisamos olhar também para a pesquisa feita na Europa, no Japão, na União Soviética e na China.
A Europa aparece desde os antecedentes de lógica e computação, passa por pesquisa em linguagem, programação lógica, estatística e robótica, e continua em laboratórios e empresas. O projeto japonês de quinta geração mostra uma política industrial e científica diferente, com apostas em conhecimento e computação paralela que influenciaram discussões internacionais.
A União Soviética teve uma trajetória própria em computação e cibernética. O lugar da cibernética mudou com disputas políticas e institucionais, de objeto de contestação a linguagem de modernização em determinados períodos. O estudo histórico de Slava Gerovitch ajuda a perceber como ciência e discurso político se relacionaram. Não basta traduzir essa história como atraso ou avanço numa única corrida.
A China é central no ecossistema contemporâneo, com universidades, empresas, robótica e famílias de modelos como Qwen e DeepSeek. A existência dessas linhas mostra que ideias, competências e infraestrutura não estão restritas a um país. Comparar países exige separar produção científica, capacidade industrial, adoção, patentes, acesso a hardware e modelos disponíveis.
Patentes, modelos lançados e investimentos medem coisas diferentes. Uma promessa de investimento, por exemplo, ainda pode estar longe de virar equipamento entregue. Nenhuma dessas contagens, sozinha, resume a qualidade da pesquisa de um país.
Também há circulação: pesquisadores estudam e trabalham em países diferentes, artigos atravessam instituições, implementações reutilizam conhecimento publicado. Países e empresas são unidades úteis pra discutir recursos e política, mas não caixas fechadas onde uma ideia pertence para sempre.
Dois recortes dimensionam a China sem misturar medidas: o AI Index 2026 atribui ao país 74,2% das concessões de patentes de IA de 2024 na base utilizada; a International Federation of Robotics registra 54% das novas instalações de robôs industriais em 2024, cerca de 295 mil. Patentes e instalações medem atividades diferentes, e nenhuma delas resume a qualidade de toda a pesquisa de um país.
o Brasil não entrou nessa história ontem
A comunidade brasileira de IA tem uma história anterior à onda generativa. O memorial do SBIA publicado pela SBC registra um primeiro simpósio em Porto Alegre, em novembro de 1984, e a construção de uma comunidade de pesquisa nas décadas seguintes.
Universidades e grupos trabalharam com representação de conhecimento, redes neurais, otimização, linguagem, visão e sistemas inteligentes. Entre as instituições associadas a essa trajetória estão UFRGS, USP, Unicamp, UFRJ/COPPE, UFPE, PUC-Rio, ITA e outras. A diversidade do trabalho é maior do que uma lista curta consegue representar.
A BRACIS resulta da aproximação das comunidades de inteligência artificial e redes neurais. A organização da edição de 2025 explica a fusão de SBIA e SBRN. A conferência reúne comunidades que pesquisavam IA e redes neurais muito antes dos assistentes atuais.
Um registro intermediário importante é o I Workshop Nacional em Redes Neurais e a I Escola de Redes Neurais, em 1992. A BRACIS de 2025 se apresenta como a 35ª edição na continuidade dessas comunidades. Esse calendário de pesquisa é bem mais antigo que o de lançamentos comerciais dos chatbots.
- 1984primeiro simpósio registrado26 anosPorto Alegre: organização da comunidade que o memorial do SBIA documenta.
- 2010memorial do SBIA10 anosa comunidade registra sua própria trajetória, pessoas e instituições.
- 2020C4AI4 anosinício de um centro de pesquisa com desafios em português, ciência e sociedade.
- 2024PBIA 2024–20281 anoum plano de formação, infraestrutura e aplicações; metas ainda pedem execução e avaliação.
- 2025BRACISa conferência registra a continuidade e a aproximação de comunidades científicas.
O C4AI da USP, IBM e FAPESP começou suas atividades em 2020, com temas como linguagem em português, saúde, ambiente e trabalho. O anúncio da USP e a página da FAPESP documentam essa formação. Ele é um exemplo, não o único centro ou um berço nacional exclusivo.
Português brasileiro importa como problema de pesquisa. Uma avaliação feita em inglês não estabelece o mesmo resultado em português, e português de um documento formal não cobre todos os sotaques, registros e contextos de uso. Dados e critérios precisam representar quem usará o sistema.
O Plano Brasileiro de Inteligência Artificial 2024–2028 trata de infraestrutura, formação e aplicações. É um documento de planejamento: metas e investimentos previstos precisam ser distinguidos de execução e resultados medidos.
Os registros brasileiros mostram muitas instituições e contribuições, mas são menos sistemáticos para alguns períodos. Escolher um único "fundador da IA brasileira" exigiria uma investigação histórica que esses documentos não permitem fazer.
o trabalho coletivo que desaparece atrás de um sobrenome
Os nomes ajudam a acompanhar ideias, mas podem virar uma distorção se esconderem equipes e trabalho menos visível. Uma rede treinada em milhões de exemplos depende de quem criou, organizou, anotou e avaliou esses exemplos. Um produto depende de pesquisadores, engenheiros, operadores e pessoas que produzem sinais de preferência e segurança.
Mulheres aparecem desde Ada Lovelace na história da computação. Karen Spärck Jones teve contribuições fundamentais para recuperação de informação e linguagem. Seu trabalho sobre a importância de termos em documentos ajuda a entender por que uma palavra rara num conjunto pode informar mais do que uma palavra que aparece em quase tudo. O artigo de 1972 e o arquivo em Cambridge preservam essa trajetória.
Fei-Fei Li aparece na construção de ImageNet; Kristina Toutanova é coautora de BERT. No Brasil, o memorial da SBC registra pesquisadoras como Rosa Maria Viccari e Maria Carolina Monard. Contar esses trabalhos só pelo nome de um pesquisador apagaria parte de quem os fez.
Na avaliação dos impactos, Joy Buolamwini, Timnit Gebru, Margaret Mitchell, Inioluwa Deborah Raji e outros pesquisadores ajudaram a tornar explícitas perguntas sobre disparidades, documentação e responsabilidade. O trabalho científico inclui escolher quais erros procurar, não apenas diminuir uma média de erro já existente.
Gender Shades, de Buolamwini e Gebru, examinou disparidades interseccionais em sistemas comerciais de classificação de gênero a partir de imagens. O artigo de 2018 tem tarefa, amostra e condições específicas. O resultado vale para os sistemas e as condições estudadas. A pergunta ajuda a encontrar um problema nas avaliações: uma média boa pode esconder um desempenho muito pior para certos grupos.
Model cards, propostas por Mitchell e colaboradores, organizam informações sobre finalidade, avaliação e limitações de um modelo. O trabalho original mostra que documentação também faz parte de avaliar tecnologia. Uma pontuação solta não diz para quem, em quais condições e com quais riscos o sistema foi testado.
Rediet Abebe e colaboradores acrescentam outra pergunta: o que a computação pode fazer dentro de processos de mudança social? Roles for Computing in Social Change examina papéis e limites da contribuição técnica. Um modelo mais preciso não resolve sozinho distribuição de poder, acesso ou decisões institucionais. A métrica técnica pode deixar essas condições de fora.
o datacenter faz parte do modelo que você usa
A explicação “um algoritmo ficou melhor” é incompleta quando a escala depende de semicondutores, memória, redes e energia. Um treinamento distribuído precisa mover dados e coordenar muitas máquinas. Processar rápido não ajuda se as máquinas passam o tempo esperando informação ou se a memória não comporta o trabalho.
GPUs, TPUs e outros aceleradores oferecem capacidades distintas de cálculo. Memória de alta largura de banda ajuda a alimentar essas operações. Interconexões ajudam máquinas a trocar valores. Software precisa organizar o conjunto. Os gargalos mudam conforme a arquitetura e o tamanho da tarefa.
Também há diferença entre custo de treinamento e custo de uso. Um treinamento caro pode ser amortizado por muitas aplicações. Uma inferência mais barata pode ampliar o número de usos. Ao mesmo tempo, a competição na fronteira pode exigir treinamentos e infraestrutura ainda maiores.
Esse é um motivo pelo qual conhecimento publicado e capacidade de executar um experimento não se distribuem da mesma maneira. Ler uma arquitetura não dá a uma universidade os equipamentos, energia e equipes para repetir qualquer treinamento industrial. Publicação aberta ajuda a circulação das ideias, mas a infraestrutura impõe condições materiais.
A Agência Internacional de Energia estimou, em seu relatório de 2025, que todos os datacenters consumiram cerca de 415 TWh de eletricidade em 2024. Seu cenário central projetava cerca de 945 TWh para 2030. O capítulo de demanda energética explica hipóteses e cenários. Esses valores não são consumo exclusivo de IA, e o valor de 2030 é uma projeção daquele relatório.
Os 415 TWh representavam cerca de 1,5% da eletricidade mundial. Uma participação global relativamente pequena pode coexistir com pressão local grande quando muitos equipamentos se concentram na mesma região.
Eficiência por tarefa e consumo total também podem andar em direções diferentes. Se cada consulta gastar menos, mas a quantidade de consultas crescer muito, o total pode aumentar. Uma promessa de economia precisa dizer qual comparação está fazendo.
Localmente, grandes concentrações de datacenters podem pressionar redes elétricas e outros recursos mesmo quando sua participação global parece menor. A "nuvem" depende de equipamentos físicos, e o lugar onde estão muda quem precisa lidar com esses custos.
viés, privacidade e autoria entram na mesma história
Viés pode aparecer na seleção de dados, nas categorias, no objetivo e no contexto de uso. Um conjunto desequilibrado pode deixar uma população pouco representada. Uma categoria mal escolhida pode comprimir situações diferentes numa etiqueta só. Uma média de acerto pode ocultar disparidades.
Corrigir isso exige mais do que filtrar uma palavra ofensiva. Precisamos saber qual é a tarefa, quais grupos e condições estão representados e quais tipos de erro têm consequência. O critério de avaliação também é uma escolha humana.
Privacidade envolve coleta, acesso, retenção e possibilidades de inferir informações. Um modelo pode memorizar determinados exemplos de treinamento, e uma aplicação pode expor documentos porque suas permissões foram mal montadas. São mecanismos diferentes; tratar tudo como “o modelo vazou” pode esconder onde a correção é necessária.
Direitos autorais incluem perguntas distintas: como material foi usado no treinamento, se uma saída reproduz expressão protegida, quem pode reivindicar autoria e quais condições de licença se aplicam. A discussão varia entre jurisdições e continua exigindo análise dos casos. Os relatórios do U.S. Copyright Office distinguem, por exemplo, autoria de material gerado e questões de treinamento. Essa documentação não serve como uma regra única para qualquer país.
O trabalho humano também não desaparece porque a interface gera sozinha. Produzir datasets, anotar exemplos, comparar respostas, moderar conteúdo e investigar falhas são atividades que ajudam a construir o sistema. Esse trabalho costuma ficar fora da interface que usamos.
Essas decisões influenciam o próprio sistema: o que entra nos dados, o objetivo do treino, quem pode acessar as ferramentas, como avaliamos erros e quem recebe os benefícios.
emprego: tarefas, postos e instituições
Uma ocupação reúne muitas tarefas. Automatizar parte delas pode mudar a rotina sem eliminar imediatamente o posto. Também pode permitir reorganizar equipes, ampliar produção ou deslocar trabalho para quem verifica e corrige saídas.
Por isso, exposição à IA não é a mesma medida que desemprego previsto. Um levantamento pode identificar que certas tarefas são potencialmente realizáveis por uma tecnologia; o resultado efetivo depende de custo, confiabilidade, adoção, organização e decisões econômicas. O estudo da OIT de 2025 trabalha com exposição ocupacional e potencial de transformação.
O AI Index 2026 relata que 88% dos respondentes de uma pesquisa de 2025 disseram que suas organizações usavam IA em alguma função, e 79% relataram uso regular de IA generativa em pelo menos uma função de negócio. São respostas autodeclaradas de uma pesquisa, não um censo de todas as empresas do planeta. O uso de agentes em escala, por função, era muito menos difundido na maior parte dos casos. O relatório, capítulo 4.3, explicita essas condições.
Resolver uma tarefa, ter adoção organizacional e distribuir benefícios são resultados diferentes, que exigem medidas próprias.
Na mesma pesquisa, 32% dos respondentes esperavam redução de pessoal no ano seguinte por causa da IA, enquanto 43% esperavam estabilidade. Expectativa autodeclarada não é uma contagem de demissões realizadas. Confundir exposição de tarefas, expectativa gerencial e mudança efetiva de emprego fabrica uma certeza que os dados não oferecem.
Há também uma questão de aprendizagem humana. Se uma pessoa deixa de praticar tarefas que lhe ensinavam a conferir o resultado, pode ficar mais dependente do sistema justamente no momento em que precisa julgar uma falha. Não é uma consequência inevitável; é uma escolha de como organizar uso, formação e revisão.
Ganhos de produtividade também precisam de contexto. Generative AI at Work, de Brynjolfsson, Li e Raymond, estudou assistência em atendimento e encontrou benefícios heterogêneos, maiores para trabalhadores menos experientes naquela situação. A tarefa, a organização e o nível de experiência alteram o resultado. Isso oferece evidência de uma aplicação concreta; não mede sozinho a produtividade de toda a economia ou o futuro de todas as profissões.
inteligência, compreensão e consciência não são um só teste
O sucesso em tarefas reabre perguntas filosóficas antigas. O que conta como inteligência? Desempenho, aprendizagem, adaptação, compreensão, capacidade geral? Uma definição que não é especificada deixa duas pessoas discutindo palavras enquanto pensam em critérios diferentes.
John Searle formulou o argumento do Quarto Chinês em 1980. A ideia é imaginar uma pessoa que segue regras para manipular símbolos de uma língua que não compreende. A resposta produzida pode parecer adequada a quem olha de fora. Para Searle, isso questiona a conclusão de que manipular símbolos corretamente basta para compreender. O artigo original também inclui a discussão e objeções.
Na distinção usada por Searle, IA fraca pode servir como ferramenta para estudar cognição; IA forte sustenta que o programa adequado constitui compreensão. “Forte”, nessa discussão, não significa simplesmente obter uma nota alta ou ter mais parâmetros. Também não é um sinônimo preciso de AGI: capacidade geral e compreensão são perguntas diferentes.
O argumento é filosófico e continua em disputa; não foi um experimento que encerrou a questão. Há críticas sobre o papel do sistema inteiro, da representação e da relação com o mundo. A diferença entre comportamento e experiência continua discutida por tradições que não concordam inteiramente entre si.
LLMs reabrem a disputa porque aprendem representações e mostram capacidades que vão além de scripts fixos. Essas capacidades precisam ser investigadas. Ainda assim, uma resposta “eu sinto” não estabelece experiência subjetiva: o sistema foi treinado para produzir linguagem em que pessoas dizem esse tipo de coisa.
Uma análise interdisciplinar de 2023 sobre consciência em IA examinou indicadores derivados de teorias da consciência. Sua conclusão sobre os sistemas estudados naquele momento não deve virar prova universal sobre qualquer modelo futuro. A questão exige critérios, teoria e evidência, não uma impressão produzida pela conversa.
AGI, inteligência artificial geral, também depende de uma definição e de uma maneira de avaliá-la. Um benchmark isolado, uma promessa de laboratório ou uma tarefa impressionante não resolve a disputa inteira. Precisamos saber o alcance, as condições de aprendizagem, a transferência e a confiabilidade que estão sendo exigidos.
Quanto à governança, iniciativas como o AI Risk Management Framework do NIST e a recomendação da UNESCO colocam avaliação e responsabilidade numa prática contínua. O problema é maior que rotular uma tecnologia como boa ou ruim em abstrato: envolve finalidades, instituições, evidências e consequências.
O que a história demonstra é uma sequência de capacidades construídas, testadas, ampliadas e às vezes superestimadas. Ela não demonstra que consciência, inteligência geral ou uma substituição automática de toda atividade humana sejam um destino inevitável.
Isso vale também para riscos sistêmicos: concentração de poder, vigilância, desinformação e dependência institucional não se resumem a um chatbot errar uma frase. Testes adversariais, ou red teaming, procuram falhas deliberadamente; avaliações de segurança precisam acompanhar capacidades e usos. O Foundation Model Transparency Index de dezembro de 2025 registrou uma média de 41 pontos, contra 58 na edição anterior. Critérios e participantes mudaram, então a comparação precisa dessa ressalva. Publicar mais benchmarks não é o mesmo que oferecer transparência sobre dados, riscos e operações.
o que mudou de uma ponta à outra
O caminho até aqui começou com formas de raciocínio que podiam ser descritas. Símbolos e procedimentos permitiram representar essas formas; computadores permitiram executá-las e testar programas.
Busca e regras funcionaram em tarefas preparadas, mas o conhecimento e as alternativas possíveis cresceram depressa fora delas. Aprender com exemplos mudou parte desse trabalho. Redes profundas passaram a aprender também representações, e dados, hardware e software permitiram treinar essas redes em outra escala.
O Transformer ajudou a aproveitar processamento paralelo. O pré-treinamento permitiu reutilizar uma base, e o ajuste por instruções e preferências mudou seu comportamento como assistente. Com recuperação, ferramentas e verificadores, a aplicação passou a consultar informação e executar operações fora dos pesos. A interface de conversa levou isso a muito mais gente.
Em todas essas mudanças, o resultado continuou dependendo da tarefa, da representação e das condições. ELIZA parecia entender pela conversa. SHRDLU funcionava num mundo estreito. Sistemas especialistas enfrentaram manutenção. Redes precisaram de dados e métodos de ajuste. Modelos de linguagem e agentes ainda precisam de avaliação e de sistemas bem organizados em volta.
Uma promessa de capacidade geral precisa mostrar como saiu dessas condições específicas. Acertar uma tarefa ainda não dá a um sistema autoridade sobre todas as outras.
Um token, um peso e um plano agora têm lugares diferentes nessa história. Você pode voltar aos exemplos e mexer nas experiências: quais valores mudam quando a rede treina? De onde veio a resposta do agente? Qual regra fez ELIZA perguntar sobre família?
Esse é o passo que eu queria dar depois do post anterior. Usar a ferramenta pode ser útil, mas estudar o assunto exige abrir essas perguntas e conferir o que acontece por dentro.
para consultar depois
A narrativa termina acima. Esta parte pode ficar para quando surgir uma dúvida: mapa de famílias para localizar métodos; cronologia para datas; anúncios de 2026 para condições de acesso; glossário para termos; atalhos comuns para conferir interpretações; e leituras para aprofundar.
uma cronologia das mudanças
Datas de desenvolvimento, demonstração, artigo e lançamento podem ser diferentes. Um marco nesta cronologia não tem necessariamente o mesmo peso que outro. Os links históricos estão nas respectivas explicações e nas leituras; os lançamentos recentes têm links próprios.
| Data ou período | Marco e significado |
|---|---|
| Antiguidade | Aristóteles sistematiza formas de inferência silogística, antepassado conceitual da lógica formal. |
| séc. XVII | Autômatos mecânicos europeus tornam material a ideia de máquinas capazes de imitar ações complexas. |
| 1640s | Pascal constrói calculadoras mecânicas, parte da longa história da automação aritmética. |
| 1670s | Leibniz desenvolve máquina calculadora e articula ambições de cálculo simbólico universal. |
| 1700s | A ideia leibniziana de calculus ratiocinator permanece referência histórica para mecanização da razão. |
| 1830s | Babbage projeta a Máquina Analítica programável. |
| 1843 | Ada Lovelace publica notas sobre a Máquina Analítica e discute manipulação simbólica além de simples números. |
| 1847–1854 | George Boole desenvolve álgebra da lógica. |
| 1879 | Frege publica Begriffsschrift, marco da lógica moderna. |
| 1900 | Hilbert formula problemas que ajudam a estruturar o programa formalista da matemática. |
| 1920s | O programa de Hilbert intensifica a busca por formalização e procedimentos de decisão. |
| 1931 | Gödel publica teoremas de incompletude, revelando limites de sistemas formais. |
| 1936 | Church formaliza computabilidade via cálculo lambda. |
| 1936 | Turing apresenta máquinas abstratas e caracteriza computabilidade. |
| 1937 | Equivalências entre formalismos reforçam o que passou a ser chamado de tese de Church–Turing; a tese sobre procedimentos efetivos não se confunde com essas demonstrações. |
| fim dos 1930s | Shannon liga álgebra booleana e circuitos de comutação. |
| 1943 | McCulloch e Pitts publicam neurônios formais capazes de realizar operações lógicas. |
| 1948 | Shannon publica teoria matemática da comunicação. |
| 1948 | Wiener publica Cybernetics, articulando feedback, controle e comunicação. |
| 1949 | Hebb publica teoria de aprendizagem por modificação sináptica associativa. |
| 1950 | Turing publica Computing Machinery and Intelligence e o jogo da imitação. |
| 1951 | Minsky e Dean Edmonds constroem SNARC, uma experiência de rede em hardware. |
| 1954 | Demonstração Georgetown–IBM chama atenção para tradução automática. |
| 1955 | Newell, Simon e Shaw desenvolvem Logic Theorist. |
| 31 ago. 1955 | McCarthy, Minsky, Rochester e Shannon submetem a proposta do Dartmouth Summer Research Project. |
| verão 1956 | O encontro de Dartmouth consolida “Artificial Intelligence” como identidade de pesquisa. |
| 1956 | Logic Theorist é demonstrado como sistema de prova automatizada. |
| 1957 | Rosenblatt desenvolve o perceptron. |
| 1958 | McCarthy inicia LISP, que se tornaria linguagem central da IA simbólica. |
| 1958–1959 | Perceptrons recebem grande atenção pública e militar. |
| fim dos 1950s | Newell e Simon avançam em solucionadores gerais de problemas. |
| 1960s | Laboratórios no MIT, Stanford, Carnegie Mellon e Edinburgh expandem IA simbólica. |
| 1960s | DENDRAL inicia exploração de sistemas baseados em conhecimento científico. |
| 1965–1966 | Weizenbaum desenvolve e publica ELIZA. |
| 1966 | Relatório ALPAC critica resultados da tradução automática disponível. |
| 1966 | Inicia o projeto Shakey no SRI. |
| 1969 | Minsky e Papert publicam Perceptrons. |
| 1970–1971 | Winograd desenvolve SHRDLU no mundo de blocos. |
| início dos 1970s | STRIPS formaliza ações por pré-condições e efeitos em planejamento. |
| 1972 | Desenvolvimento inicial do MYCIN em Stanford. |
| 1972–1973 | Relatório Lighthill critica escalabilidade da IA britânica. |
| 1970s | Financiamento cai em algumas linhas de IA nos EUA e Reino Unido: primeiro “AI winter”. |
| 1970s | Prolog consolida programação lógica, com trabalho franco-europeu de Colmerauer, Roussel e influências de Kowalski. |
| fim dos 1970s | Sistemas especialistas atraem novo interesse comercial. |
| 1980 | Fukushima apresenta o Neocognitron, importante precursor conceitual de CNNs modernas. |
| 1980 | XCON começa a demonstrar valor comercial de sistemas especialistas. |
| 1982 | Japão lança o Fifth Generation Computer Systems. |
| 1980s | Mercado de máquinas Lisp cresce com sistemas especialistas. |
| 1986 | Rumelhart, Hinton e Williams popularizam retropropagação para representações distribuídas. |
| 1987–1990 | Mercado de máquinas Lisp e expectativas comerciais de expert systems entram em colapso. |
| 1988 | Sutton sistematiza temporal-difference learning. |
| 1988 | A obra de Judea Pearl consolida redes bayesianas como estrutura de raciocínio probabilístico. |
| 1989 | Rabiner publica tutorial clássico de HMMs. |
| fim dos 1980s | Segundo “AI winter” afeta empresas e financiamento em partes da área. |
| início dos 1990s | Métodos estatísticos ganham força em fala, NLP e reconhecimento de padrões. |
| 1992 | Q-learning recebe demonstração formal de convergência sob condições específicas. |
| 1992 | Brasil realiza I Workshop Nacional em Redes Neurais e I Escola de Redes Neurais. |
| 1992 | O FGCS encerra seu ciclo de onze anos no ano fiscal de 1992. |
| 1992–1995 | TD-Gammon demonstra aprendizagem por autojogo em nível extraordinário. |
| 1995 | Cortes e Vapnik publicam SVMs em Machine Learning. |
| 1997 | Hochreiter e Schmidhuber publicam LSTM. |
| maio 1997 | Deep Blue derrota Kasparov por 3,5–2,5. |
| 1998 | LeCun e colaboradores publicam síntese influente de aprendizagem por gradiente/CNNs em documentos. |
| 2001 | Breiman publica Random Forests. |
| primeiros 2000s | Dados digitais, internet e clusters expandem a base material do machine learning. |
| 2006 | Hinton, Osindero e Teh publicam treinamento rápido de deep belief nets. |
| 2006–2007 | CUDA e programação geral de GPUs ampliam acesso a computação paralela para pesquisadores. |
| 2009 | ImageNet é apresentado com milhões de imagens hierarquizadas. |
| 2009 | Raina, Madhavan e Ng demonstram grandes ganhos de velocidade com GPUs em deep learning. |
| 2012 | AlexNet domina a competição ImageNet, catalisando deep learning em visão. |
| 2013 | Word2Vec populariza embeddings neurais eficientes de palavras. |
| 2014 | Sutskever, Vinyals e Le apresentam seq2seq com LSTM. |
| 2014 | Bahdanau, Cho e Bengio introduzem atenção aprendida em tradução neural. |
| 2014 | Goodfellow e colaboradores apresentam GANs. |
| 2015 | DeepMind publica DQN na Nature. |
| 2015 | ResNet vence competições de visão com conexões residuais. |
| jan. 2016 | Artigo de AlphaGo é publicado; sistema já havia derrotado Fan Hui. |
| mar. 2016 | AlphaGo vence Lee Sedol por 4–1. |
| 2017 | Vaswani e colaboradores publicam Attention Is All You Need. |
| jun. 2018 | OpenAI apresenta generative pre-training baseado em Transformer. |
| 2018 | BERT é divulgado, depois publicado no NAACL 2019. |
| 2019 | T5 propõe estrutura unificada texto-para-texto. |
| 2019 | Human feedback já é usado para ajustar GPT‑2 em experimentos da OpenAI. |
| jan. 2020 | Kaplan e colaboradores publicam scaling laws para modelos de linguagem. |
| maio 2020 | GPT‑3 demonstra forte few-shot/in-context performance em grande escala. |
| 2020 | C4AI USP–FAPESP–IBM começa a operar no Brasil. |
| 2020 | AlphaFold2 alcança resultado histórico no CASP14; publicação detalhada viria em 2021. |
| jan. 2021 | OpenAI apresenta DALL‑E. |
| 2021 | CLIP mostra pretreinamento contrastivo imagem-texto em 400 milhões de pares. |
| jul.–ago. 2021 | AlphaFold2 é publicado na Nature. |
| ago. 2021 | Stanford publica relatório que consolida o termo “foundation model”. |
| 2022 | InstructGPT demonstra força de instruction tuning + RLHF. |
| 2022 | Modelos de difusão e sistemas texto-imagem tornam-se fenômeno público. |
| 2022 | Stable Diffusion acelera ecossistema de geração visual com pesos acessíveis. |
| 30 nov. 2022 | ChatGPT é lançado como research preview. |
| início 2023 | Anthropic expande acesso ao Claude. |
| 14 mar. 2023 | OpenAI lança GPT‑4. |
| jul. 2023 | Anthropic lança Claude 2. |
| set. 2023 | Mistral lança Mistral 7B sob Apache 2.0. |
| dez. 2023 | Google apresenta Gemini e o integra ao Bard. |
| dez. 2023 | Mixtral 8x7B reforça uso de sparse mixture-of-experts. |
| 8 fev. 2024 | Google renomeia Bard para Gemini. |
| 2024 | Modelos de vídeo generativo e multimodalidade avançada ampliam a corrida generativa. |
| 2024 | AlphaFold 3 expande modelagem biomolecular para interações mais amplas. |
| ago. 2024 | Trabalho sobre scaling ótimo de test-time compute quantifica novas trocas entre inferência e modelo. |
| 12 set. 2024 | OpenAI apresenta o1-preview, tornando “reasoning models” uma categoria comercial. |
| fim de 2024 | MCP emerge como protocolo aberto para ligar modelos a dados e ferramentas. |
| 20 jan. 2025 | DeepSeek lança R1, ampliando acesso a modelos de raciocínio. |
| mar. 2025 | Qwen2.5-Omni exemplifica entrada integrada de texto, imagem, áudio e vídeo. |
| abr. 2025 | Meta lança Llama 4 Scout e Maverick, modelos multimodais MoE de pesos acessíveis. |
| abr. 2025 | Qwen3 apresenta linha híbrida com modos de pensamento e resposta direta. |
| 2025 | Desenvolvimento de RL para raciocínio se difunde rapidamente em pesquisa aberta. |
| 2025 | Agentes de programação tornam-se importante categoria comercial e de pesquisa. |
| fev. 2026 | Anthropic lança Sonnet 4.6, com ênfase em coding, computer use e agentes. |
| mar. 2026 | OpenAI release notes registram GPT‑5.4 Thinking e reorganização da linha 5.x. |
| abr. 2026 | Meta apresenta Muse Spark no site e aplicativo; a API estava em prévia privada. Não confundir a disponibilidade de cada interface. |
| maio 2026 | Google anuncia a família Gemini 3.5 e infraestrutura de Managed Agents. |
| 21 jul. 2026 | Google apresenta Gemini 3.6 Flash, distinguindo iteração de modelo de infraestrutura de agentes. |
| jul. 2026 | xAI abre componentes do harness Grok Build para agentes de programação. |
| jul. 2026 | xAI disponibiliza Grok 4.5 em integração de coding; alegações de qualidade permanecem autorrelatadas. |
| jul. 2026 | OpenAI anuncia família GPT‑5.6 em documentação oficial recuperada. |
| ago.–set. 2026 | Google continua ciclo Gemini 3.7/3.8. |
| 22 set. 2026 | Documentação da Anthropic registra Claude Opus 5.5. |
| 6 out. 2026 | Mistral anuncia Large 4 em prévia pública de API; os pesos são prometidos para depois do corte deste texto. |
| 7 out. 2026 | Anthropic anuncia Haiku 5.5. |
| 8 out. 2026 | Google anuncia um Gemini agent integrado para trabalho empresarial. |
| set.–out. 2026 | A documentação de GPT-6 registra expansão de acesso. Uma atualização de 29 de setembro confirma anúncios anteriores, sem estabelecer sozinha o primeiro dia de lançamento. |
| 10 out. 2026 | A fronteira é caracterizada por raciocínio, multimodalidade, agentes, ferramentas e competição entre modelos grandes e pequenos, sem consenso sobre AGI. |
anúncios e acesso no corte de 2026
Estes são exemplos anunciados até 10 de outubro de 2026. A página do fabricante documenta o lançamento e as condições de acesso; as alegações de capacidade precisam de avaliação. Não use essa lista como ranking.
| Ecossistema | Exemplo documentado no corte | O que ajuda a enxergar |
|---|---|---|
| OpenAI | GPT-6.1 Sol e expansão de GPT-6 | modelos, interfaces e trabalho com ferramentas são desenvolvidos como partes de produtos. |
| Anthropic | Opus 5.5 e Haiku 5.5 | diferentes variantes atendem restrições de capacidade, velocidade e custo. |
| família Gemini 3.5 | linguagem, modalidades e ação aparecem na mesma agenda de sistemas. | |
| Alibaba | ecossistema Qwen | famílias chinesas incluem modelos de linguagem, imagem e outras modalidades. |
| DeepSeek | prévia de V4 e trabalho V4.1-Flash | artigos e prévias precisam ser lidos com suas condições de disponibilidade. |
| Mistral | prévia pública de Large 4, em 6 de outubro | o anúncio permite testar a API e promete pesos para depois; promessa não é disponibilidade já verificada. |
| xAI | Grok 4.6 | tarefas prolongadas e agentes aparecem como foco comercial. |
| Meta | Llama 4, anunciado em 2025 | um marco de multimodalidade e distribuição de pesos; esta linha não afirma ser o lançamento mais recente da empresa. |
glossário para voltar quando uma palavra escapar
| Palavra | Ideia que usamos aqui |
|---|---|
| IA | campo que investiga sistemas capazes de realizar tarefas associadas à inteligência, com várias tradições e métodos. |
| Simbólico | trabalhar com objetos, relações e regras representados explicitamente. |
| Busca | explorar alternativas para encontrar um caminho ou uma solução. |
| Heurística | orientação prática que ajuda a escolher quais alternativas explorar. |
| Estado / plano | descrição relevante de uma situação / sequência de ações para atingir um objetivo. |
| Machine learning | ajustar comportamento a partir de exemplos, dados ou consequências. |
| Dataset / benchmark | conjunto organizado de dados / tarefa e condições de avaliação comparável. |
| Parâmetro / peso | valor ajustado pelo treinamento / parâmetro que modula uma operação ou conexão. |
| Treinamento / inferência | etapa de ajuste / execução do modelo para obter uma saída. |
| Perda | medida do custo das previsões em relação ao objetivo escolhido. |
| Gradiente / retropropagação (backpropagation) | sensibilidade da perda aos parâmetros / cálculo dessas sensibilidades através das operações. |
| Generalização / sobreajuste | funcionar em exemplos novos / ajustar-se demais a detalhes do material de treino. |
| Supervisionado / autossupervisionado (self-supervised) | aprender com alvos fornecidos / obter alvos da estrutura dos próprios dados. |
| Deep learning | aprendizagem com redes de múltiplas camadas que transformam representações. |
| CNN / RNN / LSTM | arquiteturas que exploram, respectivamente, estrutura local, recorrência e controle de memória em sequências. |
| Reforço (RL) / política | aprender a partir de sinais de recompensa / comportamento que orienta a escolha de ações. |
| Token / embedding | unidade discreta processada / representação numérica aprendida. |
| Atenção / autoatenção | combinação ponderada de informação / combinação entre posições da própria sequência. |
| Transformer | família de arquiteturas com atenção como mecanismo central. |
| Autorregressivo | gerar uma sequência condicionando cada continuação ao contexto permitido. |
| Pré-treinamento (pretraining) / ajuste fino (fine-tuning) | aprendizagem ampla inicial / treinamento posterior para adaptar comportamento. |
| Contexto / janela de contexto (context window) | informação disponibilizada ao modelo numa execução, com capacidade limitada de processamento. |
| Aprendizado em contexto | usar instruções e exemplos apresentados sem necessariamente alterar os pesos. |
| LLM / modelo de fundação | grande modelo de linguagem / base ampla adaptável a múltiplas tarefas e modalidades. |
| Multimodal | trabalhar com mais de um tipo de informação, como texto, imagem e áudio. |
| GAN / difusão | geração por objetivos adversariais / geração associada a transições de remoção de ruído aprendidas. |
| RLHF | treinamento por reforço usando sinais associados a preferências humanas. |
| RAG | recuperar informações externas e incluí-las na geração da resposta. |
| LoRA / QLoRA | adaptação com atualizações de menor dimensão / combinação dessa adaptação com quantização. |
| Quantização / destilação | reduzir precisão numérica / transferir comportamentos ou sinais entre modelos. |
| MoE | arquitetura que seleciona subconjuntos de componentes para determinadas operações. |
| Test-time compute | computação investida durante a resolução depois de receber o problema. |
| Chain of thought | passos intermediários expressos na resolução; não são garantia de correção nem acesso fiel ao processo interno. |
| VLA | modelo visão-linguagem-ação, ligando percepção e instruções a ações; é mais específico que multimodalidade. |
| Verificador | componente que testa uma condição ou avalia um candidato, dentro de critérios definidos. |
| Ferramenta (tool use) / agente | software externo que executa operações / sistema que decide e atua em ciclos de observação. |
| MCP | protocolo de conexão entre aplicações de IA, fontes e ferramentas. |
| Alucinação | saída plausível que não corresponde aos fatos ou à evidência relevante. |
| AGI / consciência | termos para questões distintas de capacidade geral e experiência subjetiva, que exigem critérios e investigação. |
leituras por onde continuar
As fontes estão nos links ao longo do texto. Pra continuar, eu começaria pelos resumos e pelas figuras dos artigos, tentando entender qual problema cada um resolveu. Você não precisa entender toda a matemática de primeira.
- Para entender a pergunta original: Turing, 1950, e a proposta de Dartmouth, 1955. Leia como documentos de sua época, com perguntas e expectativas ainda abertas.
- Para enxergar o mecanismo por trás da conversa: ELIZA, 1966, e o relato de Winograd sobre SHRDLU. Compare o resultado aparente com o mundo que o sistema recebe.
- Para entender aprendizagem e representações: retropropagação, 1986, CNNs em reconhecimento de documentos, 1998, ImageNet, 2009, e AlexNet, 2012. Os quatro documentos tornam visível o intervalo entre uma ideia e as condições para ampliá-la.
- Para acompanhar a virada da linguagem: atenção na tradução, Transformer, GPT-3, e InstructGPT. Arquitetura, escala e comportamento de assistente são passos diferentes.
- Para conhecer geração visual e adaptação: difusão, difusão latente, LoRA e QLoRA. Observe quais custos cada trabalho procura reduzir e em quais condições.
- Para pensar sistemas além dos pesos: RAG, computação durante a resolução e DeepSeek-R1. Pergunte qual informação vem do treinamento, qual vem do contexto e qual vem de verificação externa.
- Para sair da média de acerto: Gender Shades e Model Cards. Avaliar inclui grupos, contextos e limitações, não apenas escolher um número alto.
- Para situar o Brasil: memorial do SBIA e história da BRACIS. Eles oferecem registros institucionais de uma comunidade que já existia antes do chatbot.
- Para a dimensão material e social: AI Index 2026, Energy and AI, da IEA, e exposição ocupacional, da OIT. Conserve o ano, a população, a metodologia e a distinção entre observação e projeção.
Usei um levantamento documental sobre a história da IA como base e conferi os acontecimentos em artigos e documentos históricos. O panorama recente vai até outubro de 2026. Comparações divulgadas por fabricantes continuam identificadas como resultados deles, com as condições e limitações que acompanham cada anúncio.
follow the next posts
Add this RSS feed to your feed reader to follow new posts. No account or email required.