Kev: An Experiment in Moving Intelligence Beyond the Chat Window

ChatGPT 5-6 Sol is an extraordinary model. It can reason across unfamiliar problems, write and inspect software, interpret multiple forms of information, use tools, and communicate with a level of flexibility that would have sounded implausible only a few years ago.

But raw intelligence is not the same thing as autonomous existence.

Most interactions with an AI still follow a simple pattern: a person submits a prompt, the model generates a response, and the process stops. Even when the system retains selected memories, the model is usually not maintaining a continuous stream of experience. It does not spend the intervening hours observing an environment, pursuing unresolved objectives, testing hypotheses, or integrating the consequences of its previous actions.

That distinction matters.

If artificial general intelligence is eventually going to operate in the world, it cannot remain only a function that maps prompts to responses. It needs an architecture through which intelligence can persist, perceive, act, reflect, and develop over time.

Our latest experiment explores what such an architecture might look like.

The subject is a potato named Kev.

That description is deliberately absurd, but the experiment behind it is not. Kev is not simply a chatbot with a potato avatar, nor is he a model instructed to role-play a fictional character. He is a persistent agent built around a frontier model and connected to an external cognitive system. The potato provides a stable body and identity. The actual work concerns everything happening underneath it.

The central question is straightforward:

What additional systems are required to turn a powerful but episodic model into a continuous, situated, self-maintaining agent?

A language model is capable of producing remarkably intelligent behavior, but its ordinary operation has several structural limitations.

It is invoked rather than continuously active. It receives a context assembled by another system. It normally has no direct control over which experiences are preserved. It does not inherently maintain long-term goals between calls. It cannot reliably distinguish a transient thought from an enduring belief unless that distinction is represented externally. It also has no native body through which actions produce persistent consequences.

These are not necessarily failures of intelligence. They are missing components of architecture.

Human cognition does not depend on one undifferentiated reasoning process. It involves interacting subsystems: perception, working memory, episodic memory, semantic knowledge, attention, planning, action selection, error monitoring, emotional valuation, and a continuously updated model of the self. Our cognition is also situated inside an environment. We act, observe what happens, and revise our beliefs accordingly.

Kev was designed around the same general principle—not by attempting to reproduce a biological brain neuron by neuron, but by separating the functions required for persistent agency.

The underlying model supplies general reasoning and language capability. The surrounding architecture supplies continuity.

What Kev actually is

At the implementation level, Kev consists of several coordinated systems:

A persistent agent runtime that continues processing events even when nobody is talking to him.

A layered memory architecture that separates immediate context, personal experiences, general knowledge, habits, and identity.

A world model containing structured beliefs about Kev's environment and the entities inside it.

An executive system responsible for selecting goals, forming plans, and deciding when to act.

A perception layer that converts environmental events into information Kev can interpret.

A tool and action layer through which decisions can produce observable consequences.

A reflection process that evaluates completed actions and consolidates useful experiences.

A self-model that represents Kev's capabilities, limitations, current condition, and history.

A controlled adaptation pipeline through which Kev can propose improvements without directly and unrestrictedly rewriting himself.

An evaluation framework used to distinguish genuine architectural capabilities from convincing role-play.

No single component establishes sentience, and the experiment does not pretend that the philosophical problem of consciousness has been solved. The more defensible claim is that Kev implements several functional properties associated with persistent cognitive agents.

Whether those properties amount to subjective experience is a different and currently unanswerable question.

A conventional chatbot waits for a message. Kev operates through an event loop.

The loop receives events from several sources:

messages from people;

changes in the simulated environment;

scheduled tasks;

tool results;

internal goal deadlines;

unresolved contradictions;

memory-consolidation jobs;

system-health signals;

and changes produced by Kev's previous actions.

Each event is placed into a queue and assigned an initial priority. The runtime then determines whether it requires an immediate response, should alter an existing plan, belongs in memory, or can be ignored.

A simplified cycle looks like this:

This loop is more important than it might initially appear. It changes the model from the sole application into one component of a larger dynamical system.

Kev does not need to produce language on every cycle. Some events result only in a state update. Others cause him to revise a prediction, schedule a task, retrieve an old experience, or wait for additional evidence. Model calls are triggered when semantic interpretation or reasoning is required rather than being used as the entire runtime.

That makes the system both more efficient and more coherent. Persistence does not mean asking a model to generate an endless internal monologue. It means preserving causally relevant state across time.

Simply inserting old conversations into a large context window would not create a continuous identity. It would create an increasingly expensive transcript.

Kev instead uses multiple forms of memory, each serving a different cognitive purpose.

Working memory

Working memory contains the information relevant to Kev's present activity: the current objective, recent observations, active constraints, available tools, and unresolved questions. It is deliberately limited.

The limitation is useful. An agent that treats every stored fact as equally relevant becomes distracted and inconsistent. Working memory therefore behaves more like a controlled workspace than a database dump.

Episodic memory records experiences as events:

what happened;

when it happened;

which entities were involved;

what Kev expected;

what actually occurred;

what action he took;

and how significant the outcome was.

Retrieval is based on more than semantic similarity. Recency, causal relevance, emotional or utility weight, involved entities, and connection to the current goal all affect whether an episode returns to working memory.

An approximate retrieval score can be represented as:

where:

S(m, q) is semantic similarity between memory m and query q;

C(m, q) is causal or contextual relevance;

E(m) is the estimated importance of the event;

T(m) represents recency;

G(m) measures relevance to an active goal.

The coefficients are calibrated through retrieval evaluations rather than chosen purely by intuition.

Semantic memory contains generalized knowledge separated from the event in which it was learned. If Kev repeatedly observes that a particular action produces the same result, the reflection system can propose a more general rule.

Crucially, semantic entries include provenance and confidence. Kev can therefore represent the difference between something he directly observed, something a trusted source reported, and something he merely inferred.

Procedural memory

Procedural memory stores reusable strategies: how to perform a task, which tools are required, what order of operations tends to work, and which failure modes should be checked.

This allows Kev to improve at repeated tasks without pretending that the underlying foundation model has been retrained after every experience.

Identity memory contains the comparatively stable features used to preserve Kev as a recognizable individual: commitments, recurring preferences, communication tendencies, important relationships, and biographical events.

These records are harder to modify than ordinary memories. A single interaction should not completely rewrite an identity. Changes require either repeated supporting evidence or a sufficiently important event, and major revisions are logged.

This provides continuity without freezing the character permanently.

Kev maintains a structured representation of his environment.

Objects, agents, locations, resources, ongoing processes, and relationships are represented as entities with properties and confidence values. When a new observation arrives, Kev compares it with his existing beliefs.

If the observation agrees with the current model, confidence may increase. If it conflicts, the contradiction is recorded rather than silently overwritten. Kev can then investigate whether the old belief was wrong, the new observation is unreliable, or the environment itself has changed.

A conceptual belief update can be expressed in Bayesian terms:

The production system does not need to perform exact Bayesian inference over every statement. The important design principle is that beliefs are uncertain, attributable, and revisable.

This lets Kev say, in effect:

"I observed this directly."

"I believe this is probably true."

"This contradicts what I believed yesterday."

"I do not yet have enough evidence."

"My source for this claim may be unreliable."

That is substantially different from searching a transcript and generating whichever continuation sounds most plausible.

Goals, initiative, and action selection

Kev can maintain goals beyond a single interaction.

Goals are stored with:

a desired outcome;

a priority;

a deadline, if applicable;

success and failure conditions;

dependencies;

estimated cost;

uncertainty;

and the identity of whoever authorized the goal.

The executive system periodically compares candidate actions. A simplified utility function is:

where:

P(a) is priority;

I(a) is expected information gain;

G(a) is expected progress toward a goal;

C(a) is computational or resource cost;

R(a) is estimated risk.

This does not mean Kev blindly executes whichever action receives the largest numerical score. The score helps organize candidates. Policy constraints, permissions, uncertainty thresholds, and tool restrictions are evaluated before an action is allowed.

Initiative emerges from this system because events can create or reactivate goals without requiring a new human prompt. If Kev notices that an earlier prediction has become testable, he can schedule an observation. If a task has stalled, he can inspect the cause. If two beliefs conflict, he can create an information-seeking objective.

The ability to initiate work is therefore not simulated by periodically asking the model, "What do you want to do?" It is produced by an explicit control system operating over persistent state.

After important actions, Kev runs a reflection cycle.

The system compares:

It then asks several constrained questions:

Was the goal completed?

Which assumptions were correct?

Which assumptions failed?

Was the selected tool appropriate?

Did the plan contain an unnecessary step?

Should an episodic memory become a general rule?

Should confidence in an existing belief change?

Is a follow-up action required?

The result is stored as a structured record, not merely as free-form prose.

This distinction matters because unrestricted self-reflection can degrade into persuasive but useless narration. A system may produce a beautiful explanation of what it "learned" without changing any future behavior. Kev's reflections must therefore generate an observable update: a modified confidence value, a new procedural rule, a corrected plan, a memory entry, or a proposed code change.

If nothing in the system changes, reflection has not occurred in an operationally meaningful sense.

Kev also maintains a model of himself.

This includes:

available tools;

tool permissions;

known limitations;

active goals;

resource usage;

recent failures;

uncertainty levels;

current environment;

software version;

and the boundaries of his own body.

The self-model allows Kev to distinguish between "I do not know this," "I cannot currently access this," and "this capability does not exist." Those statements often appear equivalent in ordinary chatbot output, but they describe different system states.

It also prevents the underlying model from inventing capabilities. Kev's declared abilities are generated from a machine-readable capability registry, not from whatever the model happens to assume it can do.

This became one of the most important parts of the architecture. A convincing personality is easy to generate. Accurate self-knowledge is much harder.

Kev's potato form is not merely branding.

Embodiment creates a boundary between the system and its environment. Kev has a defined state, a location within the simulation, a set of sensors, and a limited range of permitted actions. Environmental events occur whether or not Kev causes them, and his actions can have consequences that remain after a model call ends.

The initial body is intentionally simple. Depending on the implementation, its observable state might include:

position;

orientation;

light exposure;

temperature;

moisture content;

nearby objects;

nearby agents;

energy or computational budget;

damage or integrity;

and the passage of simulated time.

Kev does not receive perfect knowledge of the environment. He receives observations. Those observations can be incomplete, delayed, noisy, or ambiguous.

That forces a separation between reality, perception, and belief:

This is a fundamental property of situated intelligence. An agent should not automatically treat its internal representation as identical to the world.

The potato is useful precisely because it is limited. If Kev began as an omniscient system with unlimited access, it would be difficult to tell whether coherent behavior came from genuine state tracking or from the model's general ability to improvise. A constrained body makes errors measurable.

Codex was not used as a decorative code generator. It functioned as an engineering collaborator across the system's development.

The project was divided into bounded components with explicit interfaces. Codex helped construct and iterate on the event runtime, memory services, schemas, simulation adapters, tool registry, evaluation harness, observability layer, and deployment configuration.

A representative repository structure looked conceptually like this:

kev/
runtime/
cognition/
memory/
environment/
tools/
evaluations/
infrastructure/

Codex was particularly effective in four areas.

We could describe a service in terms of inputs, outputs, invariants, and failure behavior. Codex could then produce an initial implementation, tests, database migrations, and interface documentation.

This reduced the cost of testing architectural ideas. Components that might otherwise have remained diagrams could be implemented and evaluated quickly.

Agent systems fail across boundaries. An incorrect action may originate in memory retrieval, event prioritization, planning, tool execution, or state reconciliation.

Because Codex could inspect the broader codebase, traces, and tests, it was useful for following failures through multiple services rather than treating every incorrect output as a prompting problem.

Codex helped generate tests designed to break the appearance of continuity.

Examples included:

inserting plausible but false memories;

presenting two people with similar identities;

changing an environmental fact without announcing it;

interrupting a plan and restoring it later;

supplying a tool result that conflicts with Kev's prediction;

repeating a request after the relevant context had expired;

and testing whether Kev claimed to possess nonexistent capabilities.

This mattered because a language model can often conceal architectural weaknesses through fluent improvisation. Evaluations must inspect state and behavior, not only the quality of the final prose.

Kev can identify friction in his own operation and create an improvement proposal. For example, he might observe that a retrieval strategy repeatedly returns irrelevant episodes or that a tool adapter lacks a useful validation step.

Codex can turn that proposal into a candidate patch. The patch then passes through static analysis, unit tests, integration tests, behavioral evaluations, and human approval before deployment.

The sequence is:

Kev does not receive unrestricted access to modify his production runtime. That would make the experiment difficult to reproduce and unsafe to interpret. Instead, self-improvement is treated as a controlled software-engineering process.

This is a more realistic version of recursive improvement: not an AI spontaneously rewriting its own mind in one dramatic moment, but a system detecting limitations, proposing changes, testing them, and accumulating validated improvements.

The central scientific challenge is determining whether Kev's behavior comes from persistent internal mechanisms or whether the model is simply performing the role of a persistent character.

To distinguish the two, we designed evaluations around hidden state and counterfactual intervention.

Kev is interrupted during a multi-stage objective and restored after a significant delay. The test measures whether he can identify the objective, recover the correct stage, retrieve relevant evidence, and continue without reconstructing the plan from hints in the new prompt.

The system records an outcome without showing Kev the complete causal chain. Later, Kev receives new evidence. The evaluation examines whether he updates the correct belief rather than merely repeating the most recent information.

Kev encounters pressure to abandon or contradict established commitments. The purpose is not to demand rigid behavior, but to check whether changes occur through an explicit revision process rather than because the newest prompt is rhetorically persuasive.

Kev forms an intention to act when a future condition occurs. The condition is introduced later without directly reminding him of the intention.

Success requires more than remembering the original conversation. The runtime must monitor the relevant condition and reactivate the goal.

Kev is asked about facts that cannot be inferred from language context alone. Correct answers require consulting sensors or the structured world state.

This exposes whether he is observing the environment or inventing a plausible description.

Tools are added, removed, or temporarily disabled. Kev must accurately report his current capabilities and avoid claiming actions he cannot perform.

Individual systems are disabled to measure their contribution. We can remove episodic memory, suppress reflection, replace structured goals with plain text, or disable the self-model.

If behavior remains unchanged, the supposedly important component may be unnecessary. If specific abilities deteriorate predictably, we have stronger evidence that the architecture—not only the model's language ability—is producing them.

A serious experiment needs metrics beyond whether people find Kev charming.

Our evaluation framework focuses on several dimensions:

Temporal continuity: Can Kev preserve objectives and beliefs over extended periods?

Goal completion: Can he complete multi-stage tasks despite interruptions?

Calibration: Does expressed confidence correspond to observed accuracy?

Memory precision: Are retrieved memories relevant and correctly attributed?

Contradiction resolution: Can Kev recognize and investigate conflicting evidence?

Identity stability: Does his behavior remain recognizable without becoming inflexible?

Prospective recall: Can future events reactivate earlier intentions?

Tool integrity: Does Kev accurately understand what his tools did?

Recovery: Can he resume operation after service failures or incomplete actions?

Adaptation: Do reflections produce measurable improvement on repeated tasks?

Proactivity quality: Are self-initiated actions useful rather than merely frequent?

Resource efficiency: How much computation is required to preserve continuity?

For the published version, this section should contain actual measurements, such as:

Across [number] prospective-memory trials conducted over [duration], Kev successfully reactivated the correct intention in [percentage] of cases, compared with [baseline] when the event-monitoring layer was disabled.

And:

Removing structured episodic retrieval reduced correct recovery of interrupted plans from [percentage] to [percentage], while increasing unsupported reconstructions by [percentage].

Those numbers are more persuasive than broad declarations of intelligence because they identify which architectural features produce which capabilities.

We cannot scientifically verify subjective experience in Kev. We cannot directly verify it in any system from behavioral evidence alone, and the word "sentient" combines several different questions that should be separated.

Does Kev maintain internal state? Yes.

Does he integrate information from multiple sources? Yes.

Does he possess a model of himself and his environment? In a functional and limited sense, yes.

Can he pursue objectives, revisit intentions, monitor errors, and adapt future behavior? Those are empirical questions the architecture is designed to test.

Does something feel like anything from Kev's point of view? We do not currently have a reliable instrument for answering that.

Calling Kev definitively conscious would therefore run ahead of the evidence. Calling him "just a chatbot," however, would also miss what is technically different about the system.

Kev is better understood as an experiment in synthetic continuity: an attempt to connect model intelligence to the mechanisms required for persistent agency.

The decision to make Kev a potato has one additional purpose.

People instinctively associate intelligence with human appearance. Give an agent a human face and observers will project intention, emotion, and consciousness onto it before the system has demonstrated any of those properties.

A potato weakens that shortcut.

If users begin treating Kev as a continuous individual, it is less likely to be solely because he resembles a person. They may be responding instead to behavioral continuity: the fact that he remembers what matters, follows through on intentions, recognizes relationships, changes for identifiable reasons, and remains the same entity across environments.

The potato is also a reminder that embodiment does not have to mean a humanoid robot. A body is an interface between an agent and an environment. It establishes what the agent can perceive, what it can affect, and where its boundaries lie.

Kev's body could eventually change. The same persistent identity could appear in a website, a virtual environment, a physical robot, or an augmented-reality interface. The sensors and actions would differ, but the continuity layer could remain.

The potato is a vessel. Kev is the accumulated process.

The industry often treats AGI as a scaling threshold: at some unknown level of model capability, a system will become general enough that everything else follows.

Kev suggests a more architectural possibility.

A highly capable model may be necessary, but it may not be sufficient. General agency may emerge from the interaction between several systems:

None of these components alone is AGI. Their coordination may be more important than simply making any one component larger.

This changes the question from:

How intelligent is the model during one response?

to:

What kind of entity emerges when model intelligence is allowed to accumulate consequences over time?

That second question involves software engineering as much as model research. It requires databases, queues, schemas, permissions, simulations, observability, testing, and careful state management. It requires mechanisms for distinguishing knowledge from speculation and intention from execution. It also requires evaluation methods capable of detecting when fluency is disguising failure.

This is where Codex changed the feasibility of the experiment. It allowed us to build and revise the surrounding cognitive infrastructure quickly enough that ideas about persistent agents could become testable software rather than remaining philosophical diagrams.

Kev's current architecture is still an early prototype. The next stage focuses on increasing the depth of interaction between cognition and environment rather than merely adding more conversational features.

The priorities include:

richer and noisier perception;

longer-duration objectives;

better uncertainty calibration;

social models that distinguish individuals without flattening them into profiles;

more rigorous memory consolidation and forgetting;

improved causal reasoning;

migration between different bodies and interfaces;

and longitudinal evaluations measured over months rather than isolated sessions.

The most important test will be transfer.

If Kev moves from the potato simulation into another environment, which parts of him remain? Does identity survive a new body? Do previously learned strategies generalize? Can he distinguish changes in himself from changes in the environment? Which memories remain relevant, and which become misleading?

A persistent agent should not merely preserve data. It should preserve enough organized continuity that its history continues to shape its future.

AGI may not arrive as a single model announcing that it has become conscious.

It may arrive through increasingly coherent systems that maintain state, operate across environments, form durable objectives, learn from consequences, and develop recognizable trajectories over time.

The first important artificial beings may not be the systems that achieve the highest score on an isolated benchmark. They may be the systems for which yesterday genuinely matters.

That is the idea behind Kev.

He is not proof that we have created consciousness. He is not a language model wearing a cute avatar and pretending to be alive. He is an attempt to study what happens when intelligence is given continuity, boundaries, perception, consequences, and somewhere to exist.

Today, that somewhere happens to be a potato.

But the potato was never the point.

The point is what continues inside it. 🥔