How much can you delegate to agents?
- ID: 5c3c4b50
- 原文链接: https://newsletter.posthog.com/p/agent-autonomy
- 作者: Jina Yoon
- 发布时间: 2026-07-28
- 抓取时间: 2026-07-30
中文导读
PostHog 用两个轴给 agent 自治定级：结果好不好查 × 搞砸了好不好撤销。四级：L0 难查难撤（助手）、L1 难查易撤（人审草稿）、L2 易查难撤（今日多数 dev 默认上限）、L3 易查易撤（自驾）。要抬自治上限，靠的是确定性检查、可回滚边界、scoped 目标与 skills，而不是等下一代模型。
为什么值得关注
Agent 自治上限不取决于模型强弱，取决于任务可查性×可撤销性
原文摘录
How much can you delegate to agents?
作者: Jina Yoon
发布时间: 2026-07-27T18:01:16.169Z
原文链接: https://newsletter.posthog.com/p/agent-autonomy
Discover more from build mode
Tools, tactics, and taste for product builders
Over 79,000 subscribers
Already have an account? Sign in
How much can you delegate to agents?
A simple guide to agent autonomy
[
](https://substack.com/@jinajay)
Jul 28, 2026
34
1
5
Share
People are trusting their agents to do more work without supervision, but how do you decide when to trust them?
Some think the answer depends on how good the model is – i.e. when models get better, you can trust them to do more. But trusting your agents just because the models got smarter is like skipping your seatbelt because you got a nicer car.
The real answer has nothing to do with the model, and everything to do with the _task_. You need to build a mental model for when to delegate and how much, which you can then adapt.
Here’s a simple guide to maximizing agent autonomy, so you can ship fast _without_ breaking things.
- * *
The two factors that set the ceiling
You need to ask yourself two questions first:
1\. Is it easy to check the agent’s work?
To run safely on their own, agents need immediate feedback when they’re wrong. This is possible for most code with deterministic checks, like unit and integration tests. But subjective tasks, like renaming a parameter for clarity, are harder without human taste and judgment.
2\. Is it cheap to undo an agent’s mistake?
Just like in traditional software engineering, if you want to trust an agent run without supervision, you need a guaranteed Ctrl+Z for worst case scenarios. That’s why StampHog, our PR approval agent, routes anything that contains deny-list keywords to a human.
Together, these two factors1 point you to one of four levels for any task:
- Level 0: Agent as assistant. For tasks that are hard to check and hard to undo. Necessary when dealing with tricky and sensitive code.
- Level 1: Human-in-the-loop. For tasks that are hard to check and easy to undo. Usually when you need subjective evaluation.
- Level 2: Agent delegation. For tasks that are easy to check and hard to undo. The default ceiling for most dev work today.
- Level 3: Self-driving mode. For tasks that are easy to check and easy to undo. Everything is accelerating towards this.
You can map these four levels to a very simple decision tree, which you can apply to any task:
[
This helps you make decisions about how much to delegate to your agents, but you still can engineer your pipeline to enable higher autonomy for any specific task.
- * *
Level 0: Agent as assistant
_When the work is hard to check + costly to undo_
This is the lowest level of agent autonomy. Think asking ChatGPT for advice, or auto-complete in Cursor, just like the good ol’ days of 2024.
But just because it’s old-fashioned doesn’t mean it’s bad; this mode is ideal when dealing with tricky problems in sensitive code surfaces.
For example, when Dylan updated our feature flag engine to support generic property targeting last year, he had to migrate an assumption that was indirectly baked into every feature flag at PostHog.
This would have been hard for agents to check deterministically since it wasn’t possible to grep for. The update also had a huge blast radius since it touched live customer flags, API response shapes, and reason-scoring functions.
How to level up from here
Break the task down. Small pieces make it obvious where delegation is safe or not. Dylan handed off less critical work, like propagating the new targeting logic across our JavaScript, PHP, Ruby, and Flutter SDKs, to agents while doing the riskier core migration by hand.
- * *
Level 1: Human-in-the-loop
_When the work is hard to check + cheap to undo_
This level of agent autonomy is common for tasks that need subjective evaluation since it’s hard to teach agents taste and judgment (for now, at least).
[
Human-in-the-loop tasks are considered cheap to undo since the code stays in draft mode and won’t get merged until it’s verified by a human. An undo just means kicking off another iteration.
[This code readability refactor](https://github.com/PostHo
[... 原文已截断，完整内容见链接 ...]