The AGI Feeling Is Delegated Agency

I have more will than time.

That sentence explains a lot of my current relationship with AI. It explains why the whole thing feels so spiritually weird. It explains why the best agents feel less like “chatbots” and more like prosthetic executive function. It also explains why the AGI debate often feels pointed at the wrong object.

This essay started as a messy spoken thought. I was pacing around, rambling into a computer about agents, UCA, Fridayland, ADHD, evals, marketing, dread, and the feeling that the world is getting more unstable. The output was not a clean outline. It was a pile of live cognition.

Then I delegated the rest.

That is the mic drop, really. Not because the machine became a person. Not because taste and judgment disappeared. But because a rough voice note could turn into a real article, repo changes, a publishing workflow, citations, and a draft sitting in the CMS. The lived experience is the argument. The thing that feels like AGI is not necessarily an artificial mind becoming human. It is the collapse in the cost of executing human intent.

I wrote about this previously in The Ceiling and the Abyss: A Theory of Computable Automation. The core idea there was Universal Computable Automation: a horizon where every task with a computable evaluation function becomes automatable or mostly automatable. I want to sharpen that now.

“Computable” is the important word. UCA is not magic. It does not mean every human task is solved. It means the boundary is not “is this hard?” The boundary is closer to: can we specify the task, give the system the right environment, and evaluate whether the result is good enough?

For a huge class of knowledge work, that boundary is moving very fast.

AGI vs. UCA

AGI discourse tends to get stuck on whether the machine is human-like. Does it reason? Does it understand? Does it have a self? Is it conscious? Is it just stochastic parroting wearing a nicer jacket?

Those questions matter, but they are not the only useful questions.

UCA asks something more practical: what parts of agency become automatable when execution gets cheap?

Agency used to be throttled by execution time. If I wanted to redesign a blog, upgrade a stack, write an essay, cite sources, test the build, and create a publishing workflow, that was not one task. It was a week of tasks. It required long stretches of executive continuity. It required remembering where I left off. It required being emotionally willing to walk through yak after yak after yak.

Now the unit of work is changing. The bottleneck is less “can this be executed?” and more “can I specify what I want, decide what good means, and close the loop?”

That is a different civilization-level shape.

It is also why “AGI” can feel simultaneously overhyped and under-described. The feeling is real. Something enormous is happening. But the thing happening is not necessarily that the model has become a human. The AGI feeling is that nonhuman execution is suddenly available on demand.

The practical collapse in the cost of acting on intention is enough to change the world.

Delegates, Not Agents

Nicklas Berild Lundblad puts this sharply in his transcript from a FODI-days talk: “We talk about building agents but we are really just building delegates right now—we delegate our will to them.” He continues by making the important distinction: they do not have will of their own. The verified source I can point to is Lundblad’s own transcript; I could not reliably verify the Hannah Fry YouTube transcript, so I am not going to pretend the video says something exact.

That distinction feels load-bearing.

The word “agent” quietly smuggles in too much. It makes the system sound like a little creature with goals. Sometimes that is useful shorthand. But it can also blur the moral shape of the thing. These systems do not want what I want. They do not want anything. They are not sitting there with an inner ache to finish my blog migration.

I want things. The delegate extends my will into an environment.

That does not make the system small. A delegate can still change the world. A corporation is full of delegates. A legal system is full of delegates. A compiler is a delegate. A CI pipeline is a delegate. The machine does not need to want things to matter. It only needs to let us delegate what we want.

This is where the “tool vs. being” framing gets too flat. A hammer is a tool. A shell script is a tool. An agentic coding system is a tool, but it is a tool that can keep state, use tools, inspect its own failures, ask for clarification, run tests, and update its plan. That starts to feel less like a hammer and more like a temporary employee made of probability, permissions, and duct tape.

Still a delegate.

Not a person.

Not nothing.

The Unit Of Analysis Is The System

One mistake I see constantly is judging “the model” in isolation.

That is like judging a developer by dropping them in an empty white room with no editor, no repo, no docs, no package manager, no internet, no test suite, no design brief, and no ability to ask questions. You would learn something, but you would not learn how useful they are in the real world.

The useful unit is the whole system:

Capability = model × harness × environment × evaluator

The model matters. Obviously. Better models listen better, recover better, infer intent better, and hold more of the problem in their head.

But the harness matters too. Does it have tools? Can it read the repo? Can it run the tests? Can it browse current docs? Can it maintain a plan? Can it use subagents? Can it pause for human approval before risky writes? Can it preserve unrelated local changes? Can it distinguish judgment-heavy work from low-risk execution?

The environment matters. Is the repo legible? Are there scripts? Are errors visible? Are docs bundled? Are secrets separated from public config? Are success conditions encoded in tests or deploy checks?

And the evaluator matters. This is the piece people underweight. A task becomes delegable when there is some way to tell whether it worked. Typecheck. Lint. Build. Tests. Screenshots. Golden examples. Human review. A rubric. A benchmark. A customer outcome. Even a taste test, if the taste is made explicit enough through examples and iteration.

Raw model intelligence is not the product. Model plus harness plus environment plus evaluator is the product.

This is why I think evals are not just a research artifact. They are a marketing artifact, a product artifact, and honestly a philosophical artifact. If someone asks, “Does combining two plan updates into one instruction improve model performance?” the good answer is not vibes. The good answer is: let’s run the eval.

And then, if the eval is open source, the loop gets interesting. People can inspect the claim. Model providers can grind it. The benchmark can saturate. Then the work shifts again: write better evals, update the values, choose what matters next.

That is UCA in miniature. Once success is externally evaluable, execution starts getting eaten.

The Frontier Moves To Specification

Before, the hard part was often doing the thing.

After UCA, the hard part is increasingly specifying the thing.

This is already obvious in software. If I can describe a bug precisely, give an agent the repo, let it inspect the failing path, and run the test suite, the fix is often boring. Not always. But often enough that the shape of the work changes.

The scarce skill becomes deciding what deserves execution.

What is the right abstraction? What is the smallest sufficient intervention? What should not be automated? What should stay close to the user because taste or trust is involved? What is “good” here? When is the result finished?

That last question matters more than people want to admit.

Infinite delegation is not automatically freedom. Without judgment and closure, it becomes infinite open loops. You can ask the machine to start a hundred things. It will. Congratulations. Now you have a hundred half-real branches of intention tugging on your nervous system.

This is where I feel the ADHD angle personally. AI feels like agency expansion because it meets the bottleneck directly. It catches the thought before it evaporates. It turns “I should really do that” into a file, a PR, a draft, a checklist, a working demo.

That is intoxicating because the gap between will and artifact has been one of the most painful gaps in my life.

But the danger is symmetrical. If you have more ideas than time, and then you increase execution capacity, you can also increase unfinishedness. You can create more open loops than your judgment can metabolize. The agent can extend your agency, but it can also extend your avoidance, your overcommitment, and your ability to generate plausible work that never earns its own existence.

So the human does not disappear. The human moves.

Less typing. More taste.

Less grinding. More deciding.

Less “can I do this?” More “do I actually want this done?”

Known Problems And Taste Problems

A known problem is a task where success can be defined outside the model.

Fix the failing test. Generate the RSS feed. Migrate from one package API to another. Create a draft document with these fields. Make the build pass. Find the broken import. Compare these two outputs. Classify these rows using this schema.

These tasks are increasingly delegable because the evaluator is nearby.

Taste-heavy tasks are different. “Make this good” is not the same as “make this pass.” But it is also not mysticism. Taste can be partially externalized. You can provide examples. You can write rules. You can name what you hate. You can show the system three things that feel right and three things that feel dead. You can build rubrics. You can iterate.

This does not solve taste. It gives taste a handle.

That is probably the honest middle. The model does not replace judgment, but a good harness can make judgment operational. It can ask, “Is this the vibe?” and then do the next hundred mechanical moves once the answer is yes.

For marketing work, this matters a lot. A marketer does not only need copy. They need positioning, channel fit, timing, taste, confidence, and a sense of what is worth saying in public. A delegate can draft, transform, research, compare, publish, and measure. But the human still has to decide what is true, what is cringe, what is strategically alive, and what should be left unsaid.

That is the lane I keep circling with Fridayland.

Fridayland

Fridayland is my attempt to build toward this: not a replacement for judgment, but a better way to delegate execution.

Not AI as a chatbot.

AI as an agency layer.

The product in my head helps people turn intent into operating loops, repeatable workflows, and finished artifacts. It should keep the user close to judgment-heavy decisions and move fast on low-risk execution. It should understand that sometimes the best agentic move is not a grand autonomous loop. Sometimes the best move is retrieval, a focused edit, a short draft, or saying: do this directly, it is faster and safer.

I do not want to overclaim where the product is today. It is early. It is not polished. A lot of the work ahead is making the first experience useful on day one, especially for marketers and other normal knowledge workers who do not live inside terminals.

The bar is high because the stakes feel high. If this is going to become a real livelihood, it has to be useful immediately. Onboarding has to make the value obvious. The product should feel delightful, almost game-like, because accomplishing things should feel good. Not addictive in a dark-pattern sense. Rewarding in the sense that agency itself is rewarding.

The Claude Code experience for normal knowledge workers is still the clearest shorthand I have. Let me talk, think, gesture, paste, correct, and judge. Let the system carry more of the execution.

That is the product direction.

Delegated agency with human authorship intact.

The Nearness Of UCA

I do not think UCA means the machine has all agency.

I think it means humans can delegate far more of their agency than before.

That sounds smaller than AGI, but I am not sure it is. If every knowledge-work task with an externally evaluable success condition can be automated or mostly automated, the economy changes. Companies change. Individual ambition changes. The emotional texture of work changes.

The future does not require the machine to want things. It only requires the machine to become a reliable delegate for the things we want.

And that brings the responsibility back to us in an uncomfortable way. If execution gets cheap, wanting becomes expensive. Prioritization becomes expensive. Taste becomes expensive. Closure becomes expensive.

The deepest question stops being “Can I do this?”

It becomes:

Do I actually want this done?

Sources worth following: Lundblad’s FODI-days transcript, the TUM Think Tank journal entry on “stuff that wants stuff”, and my earlier UCA essay, The Ceiling and the Abyss.