We tend to talk about AI as though there are two separate things: humans on one side and models on the other.
A person types something. The model responds.
That framing is useful, but increasingly incomplete.
The more interesting system is the loop around that interaction.
I made the map above because I wanted to understand that loop end to end: how a human interaction becomes model context, how a response is generated, how people react to that response, how some interactions and feedback may eventually become inputs into future model development, and how those future models then change human behavior again.
Once you draw the entire thing, AI starts looking much less like a chatbot and much more like a recursive human-machine system.
The conversation is the smallest loop
At the most immediate level, the system is straightforward.
I provide a message, along with whatever context the system has available. The product assembles the relevant state: conversation history, system instructions, product state, retrieved information, tool outputs, and other permitted context.
The model then generates a response.
That response changes what I do next.
If we simplify it:
This happens every time we interact.
The important part is that the model is not merely answering me. Its answer becomes part of the environment in which I form my next question.
That makes the interaction recursive.
I influence the model’s output.
The model’s output influences me.
Then I influence it again.
But there is a much larger loop
Zoom out and things become more interesting.
Depending on settings, eligibility, privacy controls, provider policies, and selection processes, some conversations, explicit feedback, usage signals, evaluations, synthetic data, and other sources can contribute to the development of future systems.
That does not mean every conversation automatically becomes training data. There are multiple layers of eligibility, filtering, privacy processing, selection, evaluation, and governance between an interaction and a future model.
But at population scale, there is still a feedback system worth examining.
Humans interact with models.
Models influence humans.
Humans produce new behavior, language, expectations, preferences, and feedback.
Developers select and transform data and optimize models against particular objectives.
New models are deployed.
Those models encounter humans again.
And the cycle continues.
This is where the real questions begin
The obvious question about AI is:
What does the model know?
I think the more important questions increasingly become:
- What behavior does the system reward?
- Which human signals survive the selection process?
- Who defines what counts as an improvement?
- Which behaviors get amplified, and which get averaged away?
- What happens when humans begin adapting themselves to models that were partly shaped by previous human adaptation?
Those are governance questions, but they are also systems-engineering questions.
Every recursive system has control points.
In this one, some of the largest are provider objectives, data selection, filtering and transformation, evaluation criteria, deployment decisions, safety requirements, and user controls.
Change any of those and you potentially change the direction of the loop.
There may not be a stable endpoint
One reason I wanted the diagram to include several possible end states is that I don’t think “AI gets better” adequately describes what happens.
A feedback system can converge.
It can also drift.
It can oscillate.
It can homogenize.
It can amplify particular behaviors.
And because both halves of this system are changing, the target itself moves.
Models change human behavior while human behavior changes the environment in which future models are developed.
That means there may be no fixed equilibrium.
Instead, we may be building a continuously adapting human-AI ecosystem.
Homogenization particularly interests me
Suppose millions of people increasingly use models to write emails, code, research, summarize information, make decisions, learn subjects, and formulate arguments.
The models inevitably influence how those people communicate and reason.
Now suppose some portion of the resulting human output eventually enters the broader information environment from which future systems learn.
The distinction between “human-generated” and “AI-generated” culture begins getting blurry very quickly.
A model doesn’t need to directly train on its own outputs for recursive effects to appear.
Its outputs can first pass through humans.
That creates an indirect feedback path:
At sufficient scale, that raises a fascinating question: do these systems increase the diversity of human thought by giving individuals access to enormously capable intellectual tools, or gradually compress it by making certain patterns of reasoning and expression disproportionately common?
I suspect we will see both.
Humans are not passive components
There is another side to this that is easy to miss.
People learn models too.
Heavy users discover what kinds of prompts work. They learn how models interpret ambiguity. They develop workflows around their strengths and compensate for their weaknesses.
Eventually the interaction becomes less like querying a machine and more like operating a system.
The human changes.
The model changes.
The interface changes.
The surrounding institutions change.
And each becomes part of the other’s environment.
That is why I think describing AI purely in terms of model capability misses something important.
The consequential unit isn’t necessarily the model.
It may be the human-model loop.
Why I mapped it
I wasn’t trying to predict some inevitable AI endpoint with this diagram.
Quite the opposite.
The point is that there are many possible endpoints, because there are many places where humans still exercise control.
What gets collected.
What gets excluded.
What gets rewarded.
What gets evaluated.
What gets deployed.
What users are allowed to control.
What society decides is acceptable.
Those choices determine the trajectory.
And as these systems become more capable and more deeply embedded in ordinary life, understanding the feedback architecture around the model may become just as important as understanding the model itself.
We aren’t simply building machines that learn from humans.
We are increasingly building systems in which humans and machines continuously shape one another.
That is a much bigger experiment.