a computer you can give responsibility to

I can't stop thinking about this Steve Jobs talk from 1983. Jobs was 28, the Macintosh wasn't out yet, and most people had never used a personal computer. He spends the talk predicting computers you can carry like a book, wireless networks, software distributed over networks, and a version of Aristotle you could still ask questions after he died. A lot of it ended up being right.

At 1:52 AM last night, I asked an agent to read the full 55-minute talk and Q&A. Then I asked a simple question: what would this talk sound like in 2026 if you replaced the personal computer with an AI agent you can instruct? I'm 22. I would've been a terrible software engineer under the old paradigm. But Tyler and I have built a product with roughly 300,000 lines of code and no full-time engineers. We run 3-6 coding agents at once. We discuss and plan. They implement. We review.

I kept going: what happens when you run many agents, give them memory, and set them on loops? What does that look like in 20 years if everyone does it? The idea kept getting simpler: a chatbot answers a question. An agent owns a loop. The transcript below is my attempt to rewrite that 1983 talk for 2026.

---

transcript of a talk, 2026

Good morning.

How many of you have used an AI chatbot?

Almost everyone.

How many of you have given an AI agent a responsibility and let it keep working on that responsibility over time?

Not very many.

That gap is what I want to talk about today.

We are calling both of these things AI, but they are not the same thing.

A chatbot answers a question.

An agent owns a loop.

That is the difference.

And I think we are at the beginning of a very large change, because for the first time, a computer does not have to wait for us.

Every computer most of us have ever used has waited.

Search waited for a query.

Excel waited for a formula.

Photoshop waited for an edit.

Email waited for a message.

Even the first generation of AI waited for a prompt.

You asked. It answered. Then it stopped.

An agent is different.

An agent is a computer you can give responsibility to.

You can tell it what should remain true, give it enough context to understand why, give it tools to act, and let it continue until something changes or it needs your judgment.

Keep these customer relationships warm.

Keep this project moving.

Keep this software healthy.

Watch our spending and tell me when something is wrong.

After every customer call, find the objections, compare them with the previous calls, and show me the pattern.

Those are not questions.

They are responsibilities.

And responsibility changes the relationship between a person and a computer.

---

Let’s start with something simple.

What is work?

A lot of work is a loop.

You observe something. You decide what it means. You take an action. You look at what happened. Then you do it again.

A salesperson checks who needs a follow-up, writes the note, sends it, records what happened, and checks again later.

An engineer finds a problem, understands it, changes the software, tests the change, reviews the result, and keeps watching.

An executive assistant looks at the week, notices conflicts, moves things around, prepares context, follows up, and does it again tomorrow.

A manager decides what matters, gives people context, checks the work, corrects it, and gradually trusts them with more.

The documents are different. The tools are different. The vocabulary is different.

The underlying shape is the same.

Observe. Decide. Act. Review. Continue.

Until recently, computers could help with pieces of that loop, but a person had to remain inside it.

The computer could store the customer, but it could not notice that the relationship was going cold and prepare the right response.

The calendar could remember the meeting, but it could not attend it, understand the commitments, create the work, and make sure the work moved afterward.

The to-do list could remember that something was unfinished, but it could not finish it.

So human beings became the connection between all the software.

Email to brain to spreadsheet.

Meeting to brain to Slack.

Slack to brain to project manager.

Project manager to brain to email.

The computer stored the state.

The human moved it.

That is beginning to reverse.

The computer can now read, write, search, compare, click, call tools, inspect results, and try again.

The important thing is not that it can generate more words.

The important thing is that it can remain inside the loop while the human moves to the boundary.

---

I have already seen this happen in software.

I am 22 years old. Under the previous paradigm, I would have been a terrible software engineer.

I am not the person who wants to spend ten years memorizing the machinery beneath every abstraction before I am allowed to make something useful.

But my co-founder Tyler and I have built a product with roughly 300,000 lines of code and no full-time engineers.

We work with three to six coding agents in parallel.

The process is very simple:

Discuss.

Plan.

Implement.

Review.

We sit at the front and the end.

At the front, we discuss what should exist. We make the assumptions visible. We decide what matters. We define the constraints. We turn a vague desire into a plan that another intelligence can act on.

Then the agents implement.

One works on the interface. One works on the backend. One investigates a bug. One writes tests. One reviews what another agent changed.

At the end, we come back.

We inspect the result. We notice what is technically correct but spiritually wrong. We catch where the implementation followed the words and missed the intent. We decide whether it is good enough or whether the orchestra needs another pass.

That is not programming in the old sense.

It is closer to conducting.

A conductor does not create an orchestra by playing every instrument faster.

The conductor chooses the piece, establishes the interpretation, keeps the musicians in time, hears the dissonance, and shapes many independent performances into one coherent result.

The score matters.

The shared tempo matters.

The musicians hearing one another matters.

And the judgment at the front of the room matters.

If you put ten brilliant musicians in ten separate rooms and give each of them a different score, you do not get an orchestra.

You get noise.

The same is true for agents.

Running many agents is not orchestration.

Orchestration requires a shared plan, shared state, clear boundaries, visible dependencies, and a common definition of good.

The human provides the direction.

The agents provide the execution.

The human reviews the whole.

For now, I think this pattern applies far beyond software.

Humans frame.

Agents execute.

Humans judge.

Over time, the boundary moves.

At first, you review every note.

Then every section.

Then the performance.

Eventually, only the exceptions.

But the human does not become irrelevant.

The human moves up one layer.

---

There is another difference between the agents we have now and the ones we will actually live with.

State.

Most agents today are ephemeral.

You open a terminal. You start a session. You explain the repository. You explain the task. It works for a while. Then the session ends.

The next time, a new intelligence arrives with no memory of the relationship.

It may be brilliant, but it is brilliant in the way a contractor can be brilliant on the first day.

It does not know why the strange decision from three months ago was made.

It does not know which shortcuts you reject.

It does not know what it got wrong last time.

It does not know when you want speed and when you want care.

It does not know what remains unfinished unless you explain it again.

An ephemeral agent can complete a task.

It cannot truly hold a responsibility.

Responsibility requires continuity.

What happened before?

What did we try?

What did the human correct?

What does good look like here?

What is still unresolved?

What changed while nobody was watching?

State turns intelligence into continuity.

Continuity turns tasks into responsibility.

And review becomes much more valuable when the relationship has state.

Without state, review only improves the output in front of you.

With state, review improves the next output too.

Every correction becomes part of how the system understands you. Every approval teaches it where your judgment landed. Every rejected draft makes the future relationship a little less generic.

The work compounds.

The trust compounds.

The delegation compounds.

A prompt produces an answer.

A session completes a task.

A stateful agent learns a responsibility.

Many stateful agents become an organization.

---

This is why I think we are still misunderstanding the medium.

When a new medium appears, we use it to imitate the old one.

The first television programs were radio shows with a camera pointed at them.

The first websites looked like magazines.

The first smartphone apps looked like tiny desktop programs.

And most AI products today are old software with a chat box attached.

We are using agents to answer questions because questions are what search engines taught us to ask.

We are using them to produce documents because documents are what office software taught us to make.

We are using them one at a time because one person operating one application is the model we already understand.

This is the very early stage of the medium.

The agent-native question is not:

What can I ask this?

It is:

What can this own?

Not what output can it generate right now.

What condition can it keep true over time?

Not how can it help me perform this process.

Why am I still inside this process at all?

Those questions are difficult because most people have never been trained to ask them.

School trains us to complete assignments.

Early work trains us to close tickets.

Productivity systems train us to finish lists.

Software trains us to operate tools.

The world has spent decades creating extremely capable executors.

Then we hand those people an AI agent and ask them to become managers.

We give them a blank box that says, “What would you like to do?”

That sounds generous.

It is actually a brutal question.

It asks the user to imagine what is possible, identify the right problem, define the outcome, provide the context, design the process, anticipate the failure modes, and decide what should require approval.

All before they have developed a mental model for the thing in front of them.

Then we act surprised when they ask it to summarize a PDF.

This is not an intelligence problem.

It is a design problem.

The blank canvas is the problem.

---

A good agent should not wait silently for you to invent its job.

It should notice.

You had three meetings this week where you promised to follow up. Would you like drafts?

You have requested the same report every Monday for six weeks. Should I take responsibility for preparing it?

This customer objection appeared in four calls. Do you want to see the pattern?

This person matters to you, and the relationship has been quiet for too long. Should I prepare a note?

This task keeps returning because the underlying loop has never been designed. Would you like to design it together?

That is not autonomy for its own sake.

It is not a machine running wild.

It is the system making the next useful delegation obvious.

The primitive is not autonomy.

The primitive is responsibility.

A responsibility has an outcome.

It has context.

It has boundaries.

It has permissions.

It has a standard.

It has a review loop.

And it has a point where the agent must stop and ask a human.

We do not need agents that do everything without us.

We need agents that remember enough to help, act enough to matter, and ask enough that we retain judgment.

---

A lot of people are afraid of this.

Some of that fear is reasonable.

A system that can act can make larger mistakes than a system that can only answer.

A stateful system can know more about you than a blank text box.

A loop can repeat a bad decision many times before anyone notices.

So these systems need boundaries, budgets, permissions, observability, and very clear ways to stop them.

But I think some of the fear comes from somewhere more personal.

For most of our lives, execution has been the proof that we are useful.

We are the person who writes the code.

The person who knows the spreadsheet.

The person who remembers the follow-up.

The person who can find the document.

The person who responds quickly when something gets loud.

We build competence, status, and identity around being good at the work inside the loop.

Then an agent arrives and makes the execution cheaper.

The natural reaction is to defend the execution.

But cheap execution does not eliminate human value.

It moves human value.

When implementation becomes cheaper, deciding what deserves implementation becomes more important.

When outputs become abundant, taste becomes more important.

When agents can act, boundaries become more important.

When ten agents can work at once, coherence becomes more important.

When the machinery can continue without you, choosing the direction becomes more important.

The scarce skill is no longer moving every atom yourself.

It is knowing what should move, why it should move, and whether the result is good.

---

Young people have an unusual advantage here.

Not because young people are automatically smarter.

Not because experience stopped mattering.

Experience gives you judgment, taste, and an understanding of consequences. Those become more valuable, not less.

The advantage is simply that young people have less to unlearn.

An experienced software engineer may see software as code that must be personally understood and controlled line by line.

I arrived at software as an outcome that could be discussed, planned, delegated, and reviewed.

I did not become a faster version of the old software engineer.

I learned a different job.

I learned to direct a software-building system.

The same thing is going to happen in every field.

Some people will use AI to perform the old job a little faster.

Other people will redesign the job around loops that no longer require a human inside every step.

From the outside, they may look similar at first.

Same title. Same laptop. Same company.

But one is manually pulling levers faster.

The other is building operational machinery around themselves.

That difference compounds quietly.

Then it looks unfair.

The real divide will not be between people who use AI and people who do not.

Almost everyone will use AI.

The divide will be between people who ask for outputs and people who design systems of responsibility.

Between reactive AI users and proactive AI managers.

Between people who operate the instruments and people who can conduct the orchestra.

---

Let’s look twenty years ahead.

I do not think people will wake up and manage a hundred agents in a hundred windows.

That would be absurd.

A home can contain dozens of electric motors, but nobody thinks about orchestrating the motor in the refrigerator, the washing machine, the fan, and the garage door.

The motors disappear into useful objects.

Agents will disappear into useful loops.

You will not think about your research agent, scheduling agent, financial agent, relationship agent, software agent, and health agent as separate pieces of machinery.

You will decide what you care about.

You will establish the boundaries.

And systems will keep parts of your life moving until something requires you.

The relationship should stay warm.

The bills should stay correct.

The project should stay moving.

The software should stay healthy.

The important promise should not disappear because the urgent notification got loud.

You will not interact with all the machinery.

You will interact with decisions and exceptions.

That is the mature interface.

Not a blank canvas.

Not a dashboard full of agents.

A management layer that understands what matters, maintains the loops, and knows when to bring you in.

For most of history, only organizations could afford that.

To delegate, you needed another person. Salary. Hiring. Training. Communication. Management. More context moving between more brains.

Delegation had a high fixed cost, so most people absorbed the work themselves.

Agents lower that fixed cost.

And when the cost falls far enough, ordinary people gain something that previously belonged only to institutions:

Persistent execution.

Operational memory.

Parallel capability.

A system that continues working after they look away.

The personal computer gave every person a machine.

The internet gave every person distribution.

The AI agent gives every person a management layer.

---

This is the part I care about most.

We are not merely making the old work faster.

We are teaching people a new relationship to work.

Less: I am the endpoint everything flows through.

More: I design the system that catches what matters.

Less: I respond to whatever gets loud.

More: I decide which loops deserve ownership.

Less: I prove my value by touching every step.

More: I provide direction, judgment, and care to a system larger than what I could execute alone.

That is why the orchestra is the right image.

The point is not to remove the musicians.

The point is not to make the conductor play every instrument.

The point is to turn many capabilities into one coherent act.

And coherence is a human problem.

What are we trying to express?

What deserves to exist?

What does good feel like?

Where should the system stop?

What should never be delegated?

Those questions do not disappear when intelligence becomes abundant.

They become the work.

---

We are very early.

Most agents still forget.

Most tools still wait.

Most products still expose the machinery instead of the outcome.

Most people still think the goal is to write a better prompt.

It is not.

The goal is to create a better loop.

A prompt is an instruction.

A loop is a responsibility made operational.

And once a loop has state, tools, boundaries, and review, it can improve over time.

That is the thing we are building toward.

A computer that does not merely answer.

A computer that remembers.

A computer that acts.

A computer that works with other computers.

A computer that knows when to ask.

A computer you can give responsibility to.

Twenty years from now, I think that will feel completely ordinary.

People will wonder how work ever functioned when every application waited, every system forgot, and every unfinished promise needed a human being to carry it from one piece of software to another.

They will ask, “Wasn’t it always this way?”

No.

We are at the first date right now.

And we have a chance to make this relationship great.

Thank you.

---

come sit by the pond, the water's good

-parsa