Introducing Clone: Steering AI agents on your behalf

July 1, 20269 min readMinchan Kim (Founder & CEO)

researchproduct

We're Clone. We're building user models that simulate a person from their life trajectory.

Our mission is to free every human from a single self.

A human can only be in one place, hold one thread of attention, and communicate one intention at a time. Agents do not share that constraint. They can run tirelessly, operate in parallel, explore alternatives, and move across many digital environments at once.

This asymmetry creates the central problem Clone is built to solve: in the era of agents, humans become the bottleneck.

The Human–Agent Interaction Bottleneck

Human-computer interaction has always been constrained by the bandwidth between human intent and machine execution. We typed commands, clicked buttons, searched menus, and eventually learned to prompt language models. Each interface increased expressive power, but the underlying burden stayed with the human: translate intent into instructions the machine can use.

Agents change the shape of that burden.

Once agents can plan, execute, verify, and coordinate work, the scarce resource is no longer only computation or model capability. The scarce resource becomes high-quality human signal: goals, constraints, context, taste, feedback, review, approval, and judgment.

The bottleneck moves from execution to interaction.

1. Review Burden

Figure 1. Faster agents create a review burden when human judgment is still consumed one item at a time.

Agent abundance does not automatically create human abundance.

When an agent becomes faster, the human often becomes busier. Every draft, plan, pull request, design, spreadsheet, and recommendation eventually returns to the user as something to review. The agent can generate work at high throughput, but the human still has to decide whether the work is good, whether it matches the goal, and whether it reflects their standards.

This creates a throughput mismatch. Agents can produce work in parallel, but human judgment is still consumed one item at a time.

This is the review burden: the hidden cost of supervising capable agents.

2. Vertical Bottleneck

Figure 2. Clone reduces the amount of steering depth the human has to personally pay inside a single agent workflow.

The vertical bottleneck appears inside a single agent workflow.

Even one agent can require many rounds of prompting, correction, review, and refinement before the result meets the user's standard. This is especially painful when the user has high standards, high stakes, or low tolerance for generic output.

The agent may be fast, but the human still has to keep steering it.

Clone does not necessarily make the task shallower. It reduces how much of the steering depth must be paid by the human. The agent may still need many rounds, but the user should not have to personally handle every round.

3. Horizontal Bottleneck

Figure 3. Parallel agents create horizontal leverage only if they do not all block on the same human context switch.

The horizontal bottleneck appears across many parallel agent workflows.

Agents can run in parallel. Humans cannot. A single person may soon supervise dozens of agents across coding, writing, research, operations, scheduling, design, sales, and personal workflows. But if every agent requires the human to repeatedly restate context, explain preferences, review decisions, and provide narrow feedback, agent abundance simply creates a new coordination burden.

Horizontal bottlenecks are worse than simple parallelism. Every time the human switches between agents, they pay a context-switching tax: reloading the goal, the current state, the constraints, and the prior reasoning before they can give useful feedback.

In a parallel agent system, most agents may not be blocked by computation. They may be blocked by waiting for the same human to regain context and respond.

The system bottlenecks on the one human who has to supervise them all.

4. Attention Ceiling

Figure 4. Without a user model, agent productivity eventually hits the ceiling of human attention.

The result is an attention ceiling.

As agents produce more work, productivity rises at first. But beyond a certain point, additional agent output stops translating into additional human value, because the user cannot review, prioritize, and steer everything.

Past that point, more tokens, drafts, or tasks do not create more value. They create backlog.

The limiting factor becomes not how much work agents can generate, but how much high-quality judgment the human can provide.

Clone is designed to raise that ceiling by carrying the user's context, taste, and judgment into agent loops.

Clone Is a User Model, Not Another Agent

Clone is not another agent.

Clone is the user model that steers agents with the prompts you would have written.

Clone prompts. Agents execute.

Clone is not trying to create a generic assistant personality. It is trying to model a specific user's operating system: how they frame problems, what they care about, what they ignore, how they make tradeoffs, how they respond to ambiguity, and what they consider good work.

We call this speculative steering.

Speculative steering is the process of letting a user model steer agents toward the outcome the human would have wanted, while minimizing the number of human turns required to get there.

Without steering, agents converge toward generic outcomes. With personal steering, agents can move toward unique outcomes that reflect the user's context, taste, and judgment.

This is why Clone is closer to a user model than a world model. World models help agents understand and act in the external world. User models help agents understand and act on behalf of a particular person [3,4].

Clone is a user model for agent-native work.

From Human-in-the-Loop to Clone-in-the-Loop

The dominant safety and control pattern for agents today is Human-in-the-Loop: the agent acts, the human reviews, the agent asks questions, the human clarifies, and the loop repeats.

HITL is necessary, but it does not scale on its own.

A human is single-threaded. A human gets tired. A human forgets what they already explained. A human cannot sit inside every agent workflow at once.

Clone proposes a different operating pattern: Clone-in-the-Loop.

In CITL, the user model sits between the human and the agent ecosystem. It does not replace the human. It carries the human's accumulated context into agent workflows, predicts likely preferences, supplies feedback, and escalates only when uncertainty or risk is high.

Human-in-the-Loop asks:

What should the human decide right now?

Clone-in-the-Loop asks:

What would this person likely want, given their memory, taste, goal, and context?

This changes the topology of agent work. The human remains the single-threaded source of intent, taste, and accountability. Clone becomes a parallel user model that carries memory, taste, goals, and feedback. Agents remain parallel executors that plan, act, verify, and report.

Figure 5. Clone-in-the-Loop shifts steering from repeated human turns to predicted goals, feedback, and escalation decisions.

We can describe Clone-in-the-Loop as two nested prediction loops plus one escalation decision: predicting the next goal, predicting the next feedback, and predicting when the human should return to the loop.

Here, $k$ indexes an agent interaction, $j$ indexes turns within that interaction, and $t$ denotes global user time.

\underbrace{o_{k,0}}_{\text{start context}} \rightarrow \underbrace{g_k}_{\text{initial prompt}} \rightarrow o_{k,1} \rightarrow f_{k,1} \rightarrow \cdots \rightarrow \underbrace{o_{k,J_k}}_{\text{end context}} \rightarrow \underbrace{g_{k+1}}_{\text{next initial prompt}}

1. Big Loop: Next Goal Prediction

g_t \sim F_{\theta_t}^{\mathrm{g}}(\cdot \mid o_t, m_t)

Next Goal Prediction predicts the initial prompt that begins a new agent interaction.

This is the big loop: modeling how a person's goals evolve over time. Given the current state, Clone predicts what the user would likely want to do next, which agents should be invoked, and what initial context those agents should receive.

2. Small Loop: Next Feedback Prediction

f_{k,j} \sim F_{\theta_{k,j}}^{\mathrm{f}}(\cdot \mid o_{k,j}, g_k, m_{k,j}), \quad j \ge 1

Next Feedback Prediction predicts the human's next feedback within an ongoing agent interaction.

This is the small loop: steering an agent from its current state toward the intended goal state. Instead of waiting for the human to inspect every intermediate result, Clone can provide likely corrections, refinements, and review comments on the user's behalf.

3. Out-of-Loop: Human Escalation Prediction

e_{k,j} \sim F_{\theta_{k,j}}^{\mathrm{e}}(\cdot \mid o_{k,j}, g_k, f_{k,j}, m_{k,j}), \quad j \ge 1

Human Escalation Prediction predicts when a decision exceeds Clone's confidence or authority and should be escalated to the human.

Clone should not answer everything. It should know when to stop, when to ask, and when to defer. Low confidence, high stakes, irreversible actions, financial decisions, sensitive communication, and questions of taste that require real human accountability should move out of the loop and back to the person.

These prediction problems require more than a prompt router. Each one depends on memory to recover context, taste to judge what the user would prefer, and simulation to predict the next steering action.

Three Engines: Memory, Taste, Simulation

A useful user model must do three things well.

It must remember what matters. It must infer what the user values. And it must simulate what the user would likely do next.

These three requirements correspond to the three engines behind Clone: Memory, Taste, and Simulation.

All three engines are built from the same raw material: the user's trajectory.

Here, a trajectory means the observed sequence of what the user saw, did, asked, corrected, approved, rejected, and accepted over time [1,2]. Some of it comes from direct computer use, where tacit behavior becomes visible. Some of it comes from agent interactions, where explicit delegation and feedback become visible.

A compact notation for this trajectory is:

\tau_{<t}=\{(o_i,a_i)\}_{i<t}

1. Memory Engine ( $M$ )

m_t = M(\tau_{<t})

The memory engine builds a structured representation from a person's observed life trajectory [1].

This representation is not just a log. It turns the user's digital life into context agents can use: active projects, prior decisions, relevant files, recurring collaborators, constraints, examples, and the surrounding state that would otherwise be lost between sessions.

Memory gives agents continuity.

2. Taste Engine ( $T$ )

\theta_t = T(\tau_{<t})

The taste engine infers the latent preferences and values that shape a person's judgments [3,4].

Taste is broader than preference. It includes style, standards, priorities, boundaries, habits, defaults, and the subtle pattern of what a person accepts or rejects. In creative work, taste determines whether a draft feels sharp or flat. In engineering, taste determines whether a design feels robust or overbuilt. In daily work, taste determines whether an answer is useful, too verbose, too risky, or simply not the way this person would do it.

Taste gives agents judgment.

3. Simulation Engine ( $F$ )

a_t \sim F_{\theta_t}(\cdot \mid o_t, m_t)

The simulation engine predicts the next action conditioned on observation, memory, and taste [2,5].

It estimates what the user would likely prompt, correct, approve, reject, delegate, or escalate next. Simulation is what turns memory and taste into steering.

Simulation gives agents direction.

Life With Your Clone

Clone is a user model that delivers your memories, tastes, goals, and feedback to agents on your behalf.

The human remains the source of purpose, values, and accountability. Clone becomes the interface layer that allows those signals to travel across many agents, many tasks, and many moments in time.

Imagine a future where you are working shifts alongside your Clone.

You focus on the work only you can do: setting direction, making hard calls, living your life, and deciding what matters. Your Clone carries your context into the agent ecosystem, helps agents act with your taste, and keeps work moving when your attention is elsewhere.

That is the mission behind Clone: not to replace the self, but to free it from being singular.