Concise Summary简洁概述
Notion's AI systems are rebuilt roughly every six months rather than frozen after launch, because staying tied to the model frontier requires continual architectural redesign.
Coding agents transformed Simon Last's personal workflow — he hasn't hand-written code since mid-2025 and has run a single agent continuously for 13 days — and Notion now frames its product mission as building tools to manage agents rather than tools to do work directly.
Notion 的 AI 系统大约每六个月重写一次，而不是上线后就固定下来，因为要跟上模型前沿就必须持续重新设计架构。
编码 Agent彻底改变了 Simon Last 的个人工作方式——他从 2025 年年中起就没再手写代码，还曾让一个 Agent 连续运行 13 天；Notion 也把产品使命重新定位为“打造管理 Agent 的工具”，而不是“打造直接做事的工具”。
Infographic信息图
Rewrite every 6 months, on purpose
每六个月主动推倒重来
Notion's AI harness (prompt management, tool-calling, context assembly) gets rewritten roughly every six months, and the cycle is shrinking as models improve. Last frames locking in one architecture as the common industry mistake — the system must be redesigned around the model's current frontier, not the one it launched with.
Notion 的 AI harness（提示词管理、工具调用、上下文拼装）大约每六个月重写一次，且周期还在缩短。Simon 认为很多公司犯的错误是做出一版就固定下来——系统必须围绕模型的当前能力重新设计，而不是停留在上线那一刻的架构。
Verification loops, not vibes
验证循环，而非“凭感觉”
The line between coding-agent output that's more robust than human code and output that's "all slop" is architecture and validation design: what change are you making, how do you verify it's correct, how do you deploy it safely. Notion's own PR culture shifted toward mandatory full unit-test coverage as agents took over authorship.
编码 Agent 产出是比人写代码更健壮，还是全是垃圾，分界线在于架构和验证设计：要改什么、怎么验证是对的、怎么安全部署。随着 Agent 承担更多代码撰写，Notion 内部把“完整单元测试覆盖”变成了强制要求。
APIs redesigned for a non-human user
为非人类用户重新设计 API
Notion replaced its verbose JSON block format with a Markdown dialect for pages and SQLite syntax for databases — formats the model is already fluent in from training data. The design method combines empiricism (trial, measure token cost) with first-principles reasoning about training-data priors.
Notion 把冗余的 JSON block 格式换成了页面用 Markdown 方言、数据库用 SQLite 语法——都是模型训练数据里天然擅长的格式。设计方法是经验主义试错（不断尝试、压缩 token）叠加第一性原理（推演模型的先验知识）。
Coding agents as AGI's kernel
编码 Agent 是 AGI 的内核
Last's strongest claim: an agent that can write and deploy its own code can bootstrap new capabilities from a minimal starting kernel — missing integration? it writes one. This reframes "coding agent" from a developer productivity tool into the generative core of general-purpose agency.
Simon 最有分量的判断：一个能自己写代码并部署的 Agent，可以从一个最小内核自我引导出新能力——缺集成？自己写一个。这把“编码 Agent”从开发者效率工具重新定义为通用智能体能力的生成内核。
Detailed Summary详细解读
The piece opens with an origin beat that sets the interpretive frame for everything after: Notion's founders got early GPT-4 access at a 2022 company offsite in Mexico and immediately split their response into a short-term plan (a writing assistant, shipped in months) and a long-term plan (a general agent with access to every Notion tool). The short-term plan worked instantly; the long-term one "simply didn't work" at the time. This gap — quick wins versus premature ambition — recurs as the piece's structural logic: Notion needed three to four failed attempts at a general agent before timing and model capability caught up in 2025.
The semantic-search section makes an underappreciated point: in the embedding era, workspace organization stops mattering for retrieval quality — the model doesn't care about your folder tree, only whether some chunk of text contains the needed information. This is a genuinely counterintuitive claim worth flagging: it implies that years of "information architecture" advice for knowledge bases may be obsolete for AI-mediated retrieval, even though chunking strategy still matters as an invisible backend decision.
The six-month rewrite cadence functions as the piece's central thesis about organizational process, not just technology. Last explicitly names "build one version and stop" as the common industry mistake, framing rewriting as enjoyable rather than wasteful. This is a strong, falsifiable claim about how AI-native companies should operate, distinct from typical software engineering advice that treats rewrites as technical debt to avoid.
The coding-agent section is the piece's most operational content: it distinguishes agent-produced code that's "more robust than human-written" from code that's "all slop" purely by whether the human designs the verification loop — architecture, correctness checks, safe deployment — versus vibe-coding by request. The concrete evidence is Notion's shift to mandatory full unit-test coverage on agent-authored PRs, which is a real organizational adaptation, not just a rhetorical claim.
Custom Agent versus Personal Agent is presented as a permission-model distinction with real product consequences: Personal Agent inherits the user's existing access and responds reactively; Custom Agent starts with zero permissions and, once granted, runs autonomously in the background on triggers or schedules. Last's own email-sorting and feedback-routing agents illustrate the pattern — start in approval mode, observe several cycles, then remove the human checkpoint entirely once trust is established.
The closing claim — coding agents as "the kernel of AGI" because code is the best primitive for deterministic logic — is presented with minimal pushback in the interview itself. The study-note critique correctly flags that this framing leaves unaddressed how model labs building their own agent platforms would relate to Notion's "Switzerland of models" positioning, and that prompt-injection risk from autonomous agents outnumbering employees goes unmentioned despite being a known open problem in Notion's own documentation.
文章开篇讲的起源故事，为后文定下了解读框架：Notion 两位创始人在 2022 年墨西哥全员大会上拿到 GPT-4 早期测试权限，当场分成短期计划（写作助手，几个月内上线）和长期计划（能访问 Notion 全部工具的通用 Agent）。短期计划立刻见效，长期计划当时“根本跑不通”。这种“快速见效 vs 过早野心”的落差，成为全文的结构性逻辑——Notion 经历了三四次失败，才在 2025 年等到时机和模型能力同时成熟。
关于语义搜索的部分提出了一个容易被忽视的观点：在向量嵌入时代，工作空间的组织方式其实不再影响检索质量——模型不关心你的文件夹树，只关心某段文本里有没有所需信息。这个说法确实有点反直觉，值得单独拎出来：它意味着多年来关于知识库“信息架构”的建议，在 AI 检索时代可能已经过时，尽管分块策略这类对用户透明的后端决策依然重要。
每六个月重写一次的节奏，是全文关于组织流程而非单纯技术的核心论点。Simon 明确把“做一版就固定下来”称为行业常见错误，并把重写描述为令人愉快而非浪费的事。这是一个关于 AI 原生公司应该如何运作的、可证伪的强主张，和传统软件工程里把重写视为要避免的技术债的说法截然不同。
编码 Agent 那部分是全文最具操作性的内容：它把 Agent 产出“比人写的更健壮”和“全是垃圾”的区别，完全归因于人是否设计了验证循环——架构、正确性检查、安全部署，而不是靠随口描述需求的“凭感觉编程”。具体证据是 Notion 把“Agent 撰写的 PR 必须有完整单元测试”变成硬性要求，这是真实的组织适应，不只是修辞主张。
Custom Agent 和 Personal Agent 的区别被呈现为一个有实际产品后果的权限模型差异：Personal Agent 继承用户已有权限、被动响应；Custom Agent 默认零权限，一旦授权就能按触发器或计划在后台自主运行。Simon 自己的邮件分拣和反馈路由 Agent 正是这一模式的例证：先在审批模式下观察数轮，确立信任后彻底取消人工检查点。
结尾的核心主张——编码 Agent 就是“AGI 的内核”，因为代码是表达确定性逻辑的最佳原语——在访谈中几乎没有受到反驳。文章附带的点评准确指出了两个悬而未决之处：其一，如果模型厂商自己也在做 Agent 平台，Notion “模型界瑞士”的定位能维持多久，访谈没有触及；其二，当自主运行的 Agent 数量超过员工数时，prompt injection 风险这个 Notion 官方文档已承认的问题，访谈全程未提。
FAQ常见问答
Why does Notion rewrite its AI harness every six months instead of iterating on one architecture?为什么 Notion 每六个月就要重写 AI harness，而不是在一套架构上持续迭代?
Because model capability shifts fast enough that an architecture optimized for last year's models becomes suboptimal; Last treats "build once and freeze" as the common mistake, and rewriting as a normal, even enjoyable, part of staying aligned with the frontier.
因为模型能力进步太快，为去年模型优化的架构很快就会变得不合时宜；Simon 认为“做一版就固定”是常见错误，重写反而是保持贴近前沿的正常操作，他甚至觉得这个过程挺好玩。
What actually separates "robust" agent-written code from "slop" in Notion's practice?在 Notion 的实践里，Agent 写出“健壮”代码和“垃圾”代码的真正区别是什么？
Not the model, but whether a human designed the verification loop first: what change is being made, how correctness gets checked, how it deploys safely — then lets the agent execute that process, backed by mandatory full unit-test coverage.
不在于模型本身，而在于人是否先设计好了验证循环：要做什么改动、怎么检查正确性、怎么安全部署，再让 Agent 去执行这个流程，并配合强制的完整单元测试覆盖。
Does Notion's approach still work if you don't use the same coding agent tools (Claude Code, Codex)?如果不用 Claude Code、Codex 这类同款编码 Agent 工具，Notion 的方法还适用吗？
The interview doesn't test that — Last's evidence is entirely from his own tool usage. The transferable part is the discipline (verification loops, full test coverage), not any specific tool, but that generalization is asserted rather than demonstrated.
访谈没有验证这一点——Simon 的证据全部来自他自己的工具使用经验。可迁移的是背后的方法论（验证循环、完整测试覆盖），而不是某个具体工具，但这种可迁移性是断言而非被证明的。
What is the security risk of Custom Agents running autonomously in the background, and is it addressed?Custom Agent 在后台自主运行有什么安全风险，访谈里有没有讨论？
Autonomous agents with granted permissions create prompt-injection exposure, especially at scale — Notion says agent count now exceeds employee count. Last doesn't raise this in the interview at all; it's only acknowledged in Notion's own documentation as an area of ongoing investment.
被授权自主运行的 Agent 会带来 prompt injection 风险，尤其是在规模化之后——Notion 自称内部运行的 Agent 数量已超过员工数。Simon 在访谈中完全没有提及这一点，只有 Notion 官方文档承认这是他们正在投入的领域。
If AGI is "a coding agent," what does that imply for platforms like Notion versus the model labs themselves?如果 AGI 就是“一个编码 Agent”，这对 Notion 这类平台和模型厂商本身意味着什么？
It's an open tension the piece flags but doesn't resolve: model labs increasingly build their own agent platforms, which could undercut Notion's "Switzerland of models" neutrality. Last's counter-argument is that managing many agents needs a workspace/board, not a chat window — collaborative infrastructure as the moat.
这是文章指出但没有解答的一个张力：模型厂商越来越倾向自建 Agent 平台，这可能削弱 Notion “模型界瑞士”式中立定位的价值。Simon 给出的反驳方向是，管理大量 Agent 需要的是看板 / 工作空间，而不是聊天窗口——协作基础设施才是真正的壁垒。
In-depth Analysis · Pros & Cons深入解读 · 优缺点
This piece distills a No Priors interview with Notion co-founder Simon Last into a structured account of how Notion's AI stack evolved and how Last himself now works. It moves from origin story to concrete engineering practice to a claim about what AGI ultimately is.
本文把 No Priors 播客对 Notion 联合创始人 Simon Last 的访谈，整理成一条清晰的脉络：Notion AI 栈如何演化，Simon 本人的工作方式又发生了怎样的转变。全文从起源故事一路推进到具体工程实践，最终落到一个关于 AGI 本质的判断。
- Concrete engineering specifics具体的工程细节Rather than vague AI-hype language, the interview names actual design choices — Markdown dialect for pages, SQLite syntax for databases, mandatory unit tests on agent PRs — that other teams can evaluate and borrow.访谈没有停留在空泛的 AI 热词上，而是给出了具体可评估、可借鉴的设计选择——页面用 Markdown 方言、数据库用 SQLite 语法、Agent 提交的 PR 强制单元测试。
- Honest account of failure坦诚讲述失败经历Admitting three to four failed attempts at a general agent, with the explicit diagnosis "timing was too early," is more useful to practitioners than a survivorship-biased success narrative.承认通用 Agent 经历了三四次失败，并明确诊断为“时机太早”，比幸存者偏差式的成功叙事对从业者更有参考价值。
- Personal, verifiable workflow detail个人工作流细节真实可查The 13-day continuous agent run, the email-sorting agent's approval-then-autopilot pattern, and the shift away from hand-writing code since mid-2025 are specific, falsifiable claims about one person's actual practice, not abstractions.连续 13 天运行的 Agent、邮件分拣 Agent 从审批模式到全自动的演变、2025 年年中起不再手写代码——这些都是关于一个人真实工作方式的具体、可证伪的说法，而非空泛概括。
- Reframes the product mission clearly对产品使命的重新定位清晰有力The shift from "tool to do work" to "tool to manage agents" is a sharp, memorable thesis that connects Notion's existing primitives (docs, databases) to a new user class (agents) without discarding prior infrastructure.从“做事的工具”到“管理 Agent 的工具”这一转变，是一个清晰有力、令人印象深刻的论点，把 Notion 既有的原语（文档、数据库）与新的用户类型（Agent）连接起来，而没有推倒既有基础设施。
- Single-source, unchallenged interview单一来源，访谈中缺乏反驳All claims come from one interview subject with an obvious incentive to present Notion's AI strategy favorably; Sarah Guo's questions probe but never push back with counter-evidence or competitor comparisons.所有说法都来自一位显然有动机把 Notion AI 战略往好处讲的受访者；主持人 Sarah Guo 的提问有追问但没有用反证或竞品对比去挑战这些说法。
- "100x engineer" claim is unquantified“100 倍工程师”说法缺乏量化依据The claim that skilled tool users become 100x or 1000x engineers is asserted with no measurement methodology, baseline, or task type specified — it reads as motivational framing more than an evaluable metric.“会用工具的人能成为 100 倍甚至 1000 倍工程师”这一说法没有给出测量方法、基线或任务类型，读起来更像是激励性的修辞，而不是可评估的指标。
- Security risk of autonomous agents left unaddressed自主 Agent 的安全风险未被触及With Notion's internal agent count now exceeding employee count and Custom Agents running unattended, prompt-injection and control risks are real but go entirely unmentioned in the interview itself.Notion 内部运行的 Agent 数量已超过员工数，且 Custom Agent 可无人值守运行，prompt injection 和失控风险是真实存在的，但访谈本身完全没有触及。
- "AGI is a coding agent" is a strong claim stated, not argued“AGI 就是编码 Agent”是断言而非论证The bootstrap-from-a-kernel idea is compelling but sketched in a few sentences with no discussion of alternative AGI architectures, embodiment, or non-code domains where deterministic-logic primitives don't obviously apply.“从内核自我引导”的想法很有吸引力，但只用了几句话带过，没有讨论其他 AGI 架构路径、具身智能，或者那些确定性逻辑原语明显不适用的非代码领域。
Read this if you build AI products or manage engineering teams adopting coding agents — it offers a concrete operational playbook (rewrite cadence, verification-loop discipline, agent-native APIs) rather than hype. Treat the "100x engineer" and "AGI is a coding agent" claims as provocative framing, not measured findings, and note that security risks of autonomous agents go unexamined.
如果你在做 AI 产品或正在带团队引入编码 Agent，值得一读——它提供的是可落地的操作框架（重写节奏、验证循环纪律、面向 Agent 的 API 设计），而不是空洞的炒作。但“100 倍工程师”和“AGI 就是编码 Agent”这类说法应被当作有启发性的框架式表述，而非经过严谨测量的结论，且要留意访谈完全没有触及自主 Agent 的安全风险。
Original Text原文
The English text on this side is an AI translation provided for convenience; the authoritative version is the source in the other language.
Simon Last is a co-founder of Notion and the key force behind Notion AI. He and fellow co-founder Ivan Zhao started Notion in 2013, and the platform now has over 100 million users. In this interview, Simon walks through Notion AI's full journey — from a first taste of GPT-4 at a company all-hands in Mexico in 2022, through a writing assistant, semantic search, three or four failed attempts at a general-purpose agent, up to the recent launch of Custom Agent. He also shares how he works with coding agents (personal record: one agent running for 13 straight days), and how Notion's mission has shifted from "a tool to help people do things" to "a tool to help people manage agents."
Interview source: No Priors podcast, episode 153, March 12, 2026, hosted by Sarah Guo
Original video: https://www.youtube.com/watch?v=1dYThQgOyZU
Key takeaways
Notion's AI harness (the system layer built around the large model) gets torn down and rewritten roughly every six months. Many companies build one version and never touch it again — Simon thinks that's a common mistake.
It took Notion three to four tries to build a usable general-purpose agent. Personal Agent launched in September 2025, and the autonomously-running Custom Agent launched in February 2026.
Used well, coding agents produce output that's more robust than what a human would write; used poorly, the output is all slop. The key is designing the verification loop, not "vibe coding."
Simon's personal record is a coding agent that ran continuously for 13 days. He sets up tasks before bed each night, aiming for the agent to still be unfinished when he wakes up.
Notion designed a new API specifically for agents: pages use a custom Markdown dialect, and databases use SQLite syntax — the original JSON format was too verbose for agents.
Notion calls itself "the Switzerland of models," refusing to lock into any single model vendor, and has already begun rolling out Chinese open-source models.
Notion's mission has fundamentally shifted: from "building the best tools for humans to directly get things done" to "building the best tools for humans to manage agents that do things for them."
The GPT-4 moment in Mexico
Sarah asks Simon whether she's heard right that Notion's first encounter with GPT-4 happened at a company all-hands in Mexico.
Simon says that was in 2022. He'd been following progress in AI, but it wasn't until they got testing access to GPT-4 that things became "very, very real." He and Ivan were both given an early ChatGPT-like interface, and the two of them immediately noticed two things: first, the model was smart enough to understand fairly complex instructions and could help you write and edit things; second, its breadth and depth of knowledge were immense.
"When we played with it, it became just instantly clear to both of us, okay, the time is now to start thinking about how to apply this. It's only going to get better."
They immediately formed a short-term plan and a long-term plan. The short-term one was obvious: a writing assistant inside documents — select text and have the AI rewrite or generate it for you. A small strike team was put together, and it shipped two or three months later. The long-term plan was more ambitious: build a general-purpose agent, give it every tool a human could use inside Notion, and let it create databases, write documents, run searches, and chain all of that together to complete longer tasks on its own.
The short-term plan shipped quickly. The long-term plan simply didn't work at all at that point.
[Note: Simon and Ivan met through the "Tools for Thought" community on Twitter and founded Notion in 2013. Notion hit 100 million users in 2024, with roughly $600 million in ARR in 2025 and a valuation of about $11 billion.]
From writing assistant to semantic search
Notion AI's first feature was AI Writer, opened to all users in February 2023. It was the easiest to build: a single-step task — rewriting and editing text — with no retrieval needed, just a direct call to the model.
Right after that, the team started building Q&A: building a semantic index over the entire workspace (turning text into vectors so it can be retrieved by meaning rather than keyword), then letting users ask questions and having the AI give source-grounded answers. This shipped in October 2023, but it was a far bigger engineering effort, since it wasn't just plugging into a large model — it meant building a real-time-updating indexing system and carefully building out an evaluation framework to guarantee quality.
Once Q&A launched, Simon immediately realized the index should extend beyond Notion itself, so they began connecting to external data sources like Slack and Google Drive.
Sarah pushes back: those platforms' own search isn't even very good — what made you think you could do better?
Simon laughs: yeah, they were puzzled too by why most companies' indexing is so bad. His take is that it comes down to two things. One is an intuition steeped in AI — what he calls "AI-pilled savviness" — a clear sense of what models can and can't do. The other is craftsmanship and attention to detail. Every data source is different — you can't use the same approach for Slack and for Google Drive, since they're completely different kinds of information. You have to try a large number of different queries, use it every day, and keep iterating on your chunking strategy and retrieval pipeline.
Sarah asks: doesn't the huge variety in how Notion workspaces are organized make search a much bigger challenge?
Simon's answer is a bit counterintuitive: in the era of vector embeddings, how a workspace is organized actually matters much less. The AI doesn't care what your folder tree looks like — it only cares whether some chunk of text contains the information you need. He now even tells users, "don't overthink organization, just throw things in."
Of course, technical decisions like chunking strategy (how large a piece a long document gets split into for retrieval) still matter a great deal, but that's invisible to the user and has nothing to do with how they organize their own stuff.
Torn down and rebuilt every six months
Sarah says Ivan made her promise to ask this question: how many times have you rewritten your AI harness?
[Note: here, "harness" refers to the whole system layer built around the large model — prompt management, tool calling, context assembly, output handling, and so on.]
Simon says this has become an inside joke at the company. Roughly every six months they rewrite it, and the cycle keeps getting shorter because the underlying technology is advancing faster.
He thinks this is a critical mistake a lot of companies make: building one version and then leaving it frozen. You have to keep tracking the current state of the art in models and technology, and then deeply redesign your whole system and product around that current state. Which means rewriting roughly every six months.
"I find it pretty fun. It's part of the process. You get to restart and rethink it."
He says they're about to ship a new version of the harness, and they're already thinking about the one after that.
Coding agents changed everything
Sarah follows up: given how willing you are to tear things down and rebuild, haven't coding agents made that whole process a lot easier?
Simon says that's exactly right. He started using Claude Code around April 2025, and it completely changed how he works.
He breaks the evolution of coding agents into a few stages: first came the era of Tab autocomplete, then agents that could help insert and rewrite some code for you — but the real turning point was when agents started being able to implement, verify, and maintain code end to end.
The key is that you need to think seriously about architecture and the verification loop. It's not "vibe coding" — not just tossing off what you want and calling it done. You have to think through: what change am I making? How do I verify it's correct? How do I deploy it safely? Then you let the agent carry out that process for you.
"If you do it well, you can be much more ambitious about what you're building and also make it much more robust than you could have done with humans writing it. And then the flip side is, if you do it badly, it's all slop."
He also mentions an interesting shift inside Notion. The design team built a git repo called Design Playground — essentially a stripped-down version of Notion with a set of basic UI building blocks and a built-in agent. Any designer can quickly assemble a high-fidelity, deployable prototype. Design discussions used to mean pointing at a static image and saying "what would this look like?" — now a designer just hands you a URL you can open.
The whole engineering team is going through this same shift. It feels a little more chaotic internally, but Simon says he likes that chaos: more prototypes, more experiments, every PR more ambitious.
Sarah asks: for high-risk areas like data security, do you draw any lines?
Simon says every PR still goes through code review. PRs today are agent-written, and they're bigger and more complex now — that's the downside. But the upside is that test coverage has gone way up. He personally won't submit any PR now without complete unit tests.
The 100x engineer is real
Sarah asks: what impact have AI tools had on team size and talent structure?
Simon says the core shift is that everyone's output ceiling has risen dramatically, and output increasingly depends on your ability and willingness to use the tools.
But team size hasn't shrunk much as a result. Notion has always liked small strike teams — that was already the right call before AI, and it's maybe slightly more right now, but not a huge change.
Sarah follows up: is the gap widening between average engineers and the ones who are especially good at using these tools?
"The gap is bigger. You can be a 100 or 1,000x engineer if you're using the tools right now. The minimum bar has not changed, but the maximum bar has extremely increased."
After three or four failures, the agent finally shipped
Sarah asks: you said the general-purpose agent didn't work back then — where does it stand now?
Simon says they struggled for years to build the agent. Every time, what they built was "sort of usable" but just not useful enough. The main reason was bad timing — they tried three to four times over the years.
It finally launched in August/September 2025. The AI you use inside Notion now is a full agent that can access almost everything in Notion: create databases, update content, create documents, search the web, do research. Every user has a Personal Agent with the same access permissions as that user.
[Note: this is Notion 3.0, launched on September 18, 2025. Notion positions it as the third major evolution, following 1.0 (document collaboration) and 2.0 (databases and workflows).]
Then, about two weeks before this interview, Notion launched Custom Agent. Unlike Personal Agent, Custom Agent has no permissions by default — you have to manually grant it access to whatever it can use. But once granted, it can run autonomously in the background.
For example, you could give it a database to log tasks in, then connect it to a Slack channel, and it will automatically reply to messages in Slack and create tasks. Or you could have it periodically search the web and your workspace and auto-populate a weekly report database.
[Note: Custom Agent officially launched on February 24, 2026. Notion says early testers have already created more than 21,000 agents, and the number of agents running inside Notion internally has already surpassed the number of employees.]
The core of AGI is the coding agent
Simon says one of the directions he's most excited about is letting an agent bootstrap new capabilities from an initial core. For instance, if some integration doesn't exist yet, the agent can write the code to build that integration itself, deploy it, and then use it.
Sarah confirms: So Notion's Agent uses that broader definition, where writing code is also a kind of tool?
"I think of coding agents as the kernel of AGI. AGI will be a coding agent, and code is just a really useful primitive for representing deterministic logic."
Simon thinks this is especially meaningful for knowledge-work agents: it can "grow" new capabilities on its own. No integration exists? Build it yourself. Need to connect a new data source? Connect it yourself.
The "Switzerland of models"
Sarah raises a competitive-landscape question: Notion is up against much larger productivity platforms and AI labs, which are also trying to build cross-data-source integrations and agents. Why would Notion win?
Simon splits the market into three layers: labs (model providers), software platforms, and infrastructure.
At the model layer, Notion positions itself as "the Switzerland of models": it doesn't lock itself to any single model provider. Customers don't want to be locked in — different models excel in different months — and Notion wants users to always be able to use the best model, and switch between them easily.
Sarah follows up: what about open-source models?
Simon says open-source models have indeed gotten really good. Four Chinese model makers are now "quite good," and they just launched one of them in the Agent, with plans to integrate all of them. These models are much cheaper than frontier models, and better suited to many use cases.
Notion's positioning is: connect all the best models, build high-quality agent implementations, and then provide a workspace truly suited for humans and agents to collaborate.
[Note: as of the interview, Notion supports frontier models like GPT-5 and Claude Sonnet 4, as well as open-source models like MiniMax. Users can choose the model in the Agent settings.]
Redesigning the API for agents
Sarah asks: is Notion's existing structure — blocks, databases — useful for agents?
Simon says it's very useful. But there's a new challenge: making it convenient for agents to use. Notion's API used to be designed for human developers, and now there's a new "customer": the agent itself.
At first this really was a problem. Notion's API represented blocks in a very verbose JSON format, which was clunky and hard for agents to process.
They took on this challenge and did two things: first, they designed a Markdown dialect for reading and writing pages — it looks like standard Markdown but extends support to all Notion block types, and models are very good at this format. Second, database interactions use SQLite syntax, since models are also naturally good at SQL.
Sarah asks how they figure out what's better for agents?
Simon says there are two paths. One is empirical: keep trying things, discovering "oh, it's not good at this" or "oh, this uses too many tokens, how do we compress it?" The other is first principles: what's in the model's training data? What are its priors? What formats is it naturally good at? What's the efficient pattern for the agent loop?
Sarah sums up: So you're doing user research, except the user is an agent.
Simon laughs and says: Right, and this "user" is available to chat anytime, you have unlimited access, and you can even write scripts to batch-test it.
13 days straight
Sarah asks about Simon's personal agent workflow.
Simon says he's working on a new prototype and running several agents at once. His daily tool is the command-line version of Claude Code or Codex — he likes command-line tools for being simple and easy to use.
His current goal is to run as many agents simultaneously as possible, around the clock. Every night before bed, he makes sure to line up enough tasks for the agent so that it still hasn't finished by the time he wakes up the next morning.
Sarah says: that's a win.
"Yes, that's a win. My personal record is that I've had a coding agent running for, I think it was 13 days straight, without stopping and just basically working through tasks."
Sarah admits she's woken up multiple times in the middle of the night this week just to check whether her agent was still running. Simon says he does the same — every night before sleep, he does one last check to make sure it's still going.
Simon's Personal Agent is also his daily tool, since it can access everything in the company workspace. For example, the night before the interview, he had the agent review user feedback after the Custom Agent launch.
But what he's proudest of is an email-triage agent. This agent is connected to all his work and personal inboxes and automatically archives emails he doesn't need to see, every day. Setting it up was simple: create a Custom Agent, give it email access, and give it a blank Notion page as "memory." Then have it look at the emails and, in turn, "interview" Simon — proposing which emails it thinks should be archived, with Simon correcting it. The agent uses that feedback to automatically generate a set of rules. In the first few days Simon was still correcting it; a few weeks later he removed the approval step entirely, and the agent now runs fully automatically.
Simon says this completely solved his email problem. He works mostly in Slack, so he doesn't need to look at 95% of his personal and work emails at all. Now when he opens his inbox, it only contains things that genuinely need his attention.
He also has a feedback-routing agent. Notion has an internal Slack channel where colleagues casually post product feedback and bug reports. Previously, some of this feedback got a response and some got ignored, since it touches too many teams. This agent's entire job is to route feedback to the right place. Using a similar "memory" pattern, it learns routing rules on the fly, and over time has accumulated hundreds of rules. For example, if it's a mobile bug, it knows to route it to the mobile team and create a task in their database.
Simon says early on he'd check whether the rules the agent learned made sense, but once he trusted it was working properly, he stopped checking. Occasionally something goes wrong, and he fixes it then.
His general pattern is: prototype first, watch closely in approval mode, run it for a few rounds to confirm it's working properly, then let go completely.
From "a tool for doing things" to "a tool for managing agents"
Sarah mentions that she and Ivan first met Simon in the Tools for Thought community. After several years of AI transformation, has Notion's core positioning changed?
Simon says the change has been quite significant.
Before AI, Notion's goal was to create the best tool for humans to directly do their work.
Now the goal is to create the best tool for humans to manage agents that do the work for them.
"Before AI, our goal was to create the best tool for humans to directly perform their work. And then now the goal is to create the best tool for humans to manage agents to do the work for them. That's a big shift."
But he then makes an important observation: all the primitives Notion previously built remain very useful in the agent era. Documents are still needed — agents love writing Markdown. Databases are still needed — structured data remains a core requirement. If you have 100 background coding agents working simultaneously, you don't want 100 chat windows, you want a kanban board. Same as before.
Notion just needs to add some new primitives: what is an agent? How does it interact with pages and databases?
Sarah's final question: how has your own way of working changed over the past six months?
Simon says it's completely changed. He hasn't written code by hand since summer 2025.
He went through several stages: humans writing all the code by hand → tab-completion → chatting with an agent to have it do small tasks, but with a human still in the outer loop → now he designs an end-to-end task, including the changes and verification, and he's only responsible for confirmation at the outermost level. If the agent goes off track, he corrects it.
He's now an agent manager, not a programmer.
Enabling non-technical teams to build agents too
Sarah asks how Notion internally helps non-technical teams build intuition for using agents.
Simon says they regularly run internal workshops and hackathons. A month ago he ran one with the People Team, which turned out to be one of the most enthusiastic users of Custom Agents, since their daily work involves a lot of repetitive back-and-forth moving information between Slack and Notion.
His observation is that people are actually excited to try it — they just need a little push to get started. Once you get past the initial technical hurdles like "what is a prompt" and "how does an agent get triggered and woken up," interacting with an agent is actually very intuitive, because you're just talking to it.
The biggest obstacle may not be a capability problem, but a confidence problem: getting people to believe this thing can really work.
Q&A
How often is Notion's AI harness rewritten, and why? About every six months. Because models and technology advance so fast that the system must be designed to closely track the current state — building one version and leaving it unchanged is a common mistake.
Do coding agents affect team size? Individual output ceilings have risen substantially, but Notion's team size hasn't shrunk significantly. Smaller teams have always been better, and that hasn't fundamentally changed before or after AI.
How does Notion design APIs for agents? Reading and writing pages uses a Markdown dialect, and databases use SQLite. The design method combines empirical trial-and-error with first-principles reasoning: looking at how the agent actually performs, as well as thinking about the model's training-data priors.
What's the difference between Custom Agent and Personal Agent? Personal Agent has the same permissions as the user and responds passively to user requests. Custom Agent has no permissions by default and requires authorization; it can run autonomously in the background on a schedule or via triggers.
What does Simon think AGI will look like? AGI is a coding agent. Code is the best primitive for expressing deterministic logic, and an agent that can write code can keep expanding its own capabilities.
Three core messages Simon kept returning to in this conversation: first, AI systems must be continuously rewritten to keep pace with model capability — you can't build one version and stop; second, coding agents are not just a developer productivity tool, they're the key capability behind agents' self-evolution; third, the definition of productivity software is shifting from "a tool people use" to "a tool people use to manage agents."
One question worth pressing further: the security risk of prompt injection from autonomously running Custom Agents wasn't mentioned by Simon in the interview, but Notion's official documentation already states this is an area they're investing in. As the number of agents exceeds the number of employees, security and control problems will only grow.
Another open question: if AGI really is a coding agent, what relationship will the agents built by model vendors themselves have with Notion's agents? In an era when model vendors also want to build platforms, how long can the "Switzerland of models" positioning hold? Still, Simon himself offered a direction: what does someone managing 100 agents need? Not 100 chat windows, but a kanban board. If that judgment holds, then Notion's decade-plus of accumulated collaboration infrastructure isn't a burden — it's a moat.
Original video: https://www.youtube.com/watch?v=1dYThQgOyZU
Simon Last 是 Notion 的联合创始人，也是 Notion AI 背后的核心推动者。他和另一位联合创始人 Ivan Zhao 在 2013 年创办 Notion，目前平台用户超过 1 亿。在这期访谈中，Simon 讲了 Notion AI 从 2022 年墨西哥全员大会上的 GPT-4 初体验开始，经历写作助手、语义搜索、通用 Agent 三四次失败，到最近发布 Custom Agent 的完整历程。他还分享了自己怎么用编码 Agent 工作（个人纪录：一个 Agent 连续跑了 13 天），以及 Notion 的使命如何从“帮人做事的工具”变成“帮人管理 Agent 的工具”。
访谈来源：No Priors 播客第 153 期，2026 年 3 月 12 日，主持人 Sarah Guo
原始视频：https://www.youtube.com/watch?v=1dYThQgOyZU
要点速览
Notion 的 AI harness（围绕大模型构建的系统层）大约每六个月推倒重写一次，很多公司做了一版就不动了，Simon 认为这是常见错误。
Notion 尝试了三到四次才做出能用的通用 Agent。2025 年 9 月发布 Personal Agent，2026 年 2 月发布可自主运行的 Custom Agent。
编码 Agent 用得好，产出比人写的更健壮；用得差，产出全是垃圾。关键在于验证循环的设计，不是“凭感觉编程”。
Simon 的个人纪录是一个编码 Agent 连续运行 13 天不停。他每天睡前安排任务，目标是第二天醒来 Agent 还没做完。
Notion 为 Agent 专门设计了新 API：页面用自定义 Markdown 方言，数据库用 SQLite 语法，原有的 JSON 格式对 Agent 太冗余。
Notion 自称“模型界的瑞士”，不锁定任何一家模型厂商，已开始上线中国开源模型。
Notion 的使命发生了根本转变：从“为人类创造最好的直接做事的工具”变成"为人类创造最好的管理 Agent 来替你做事的工具"。
【1】墨西哥的 GPT-4 时刻
Sarah 问 Simon，听说 Notion 第一次接触 GPT-4 是在墨西哥的公司全员大会上？
Simon 说那是 2022 年。他一直在关注 AI 领域的进展，但直到拿到 GPT-4 的测试权限，事情才变得“非常、非常真实”。当时他和 Ivan 都拿到了一个类似 ChatGPT 的早期界面，两人立刻发现了两件事：一是这个模型够聪明，能理解比较复杂的指令，能帮你写东西、改东西；二是它的知识面极深极广。
当我们试用之后，对我们俩来说立刻就很清楚：现在就是开始思考怎么应用它的时候了。它只会越来越好。 （“When we played with it, it became just instantly clear to both of us, okay, the time is now to start thinking about how to apply this. It's only going to get better.”）
他们立刻形成了一个短期计划和一个长期计划。短期很明显：文档里的写作助手，选中文本让 AI 帮你改写或生成。团队组了一个突击小队，两三个月后就发布了。长期计划更大胆：做一个通用 Agent，给它 Notion 里所有人类能用的工具，让它能自己创建数据库、写文档、做搜索，把这些串起来完成更长链条的任务。
短期计划很快就上线了。长期计划那时候根本跑不通。
【注：Simon 和 Ivan 通过 Twitter 上的 Tools for Thought（思维工具）社区认识，2013 年创办 Notion。Notion 2024 年达到 1 亿用户，2025 年 ARR 约 6 亿美元，估值约 110 亿美元。】
【2】从写作助手到语义搜索
Notion AI 的第一个功能是 AI Writer，2023 年 2 月对所有用户开放。这是最容易实现的：单步任务，改写和编辑文本，不需要检索，直接调用模型。
紧接着团队开始做 Q&A 功能：对整个工作空间做语义索引（semantic index，即把文本转化为向量以便按语义而非关键词检索），然后让用户提问，AI 给出基于来源的回答。这个功能 2023 年 10 月上线，但工程量大得多，因为不是简单接入大模型，而是要做一个实时更新的索引系统，还要认真搭建评估体系来保证质量。
Q&A 上线后，Simon 马上意识到应该把索引扩展到 Notion 之外，于是开始接入 Slack、Google Drive 等外部数据源。
Sarah 追问：这些平台自己的搜索也没做好啊，你们凭什么觉得自己能做得更好？
Simon 笑了：对，我们也很困惑为什么大多数公司做索引做得这么差。他的判断是，关键在于两样东西。一是对 AI 有浸泡出来的直觉（他用的词是 AI-pilled savviness），清楚模型能做什么、不能做什么。二是工匠精神和对细节的关注。每个数据源都不一样，你不能用一套方案处理 Slack 和 Google Drive，它们是完全不同类型的信息。必须大量尝试不同的查询，每天使用，不断迭代分块策略和检索流程。
Sarah 问 Notion 工作空间的组织方式千差万别，这对搜索不是很大挑战吗？
Simon 的回答有点反直觉：在向量嵌入（embedding）时代，工作空间的组织结构其实不那么重要了。 AI 不关心你的文件夹树状结构长什么样，它只关心有没有一段文本包含你需要的信息。他现在甚至建议用户：“不要太纠结组织方式，把东西扔进去就行。”
当然，分块策略（chunking strategy，即把长文档切成多大的片段供检索）这些技术决策依然很关键，但那是对用户透明的，跟用户怎么组织自己的东西无关。
【3】每六个月推倒重来
Sarah 说 Ivan 让她一定要问一个问题：你们的 AI harness 重写了多少次？
【注：harness 在这里指围绕大模型构建的整套系统层，包括提示词管理、工具调用、上下文拼装、输出处理等。】
Simon 说这已经成了内部的一个梗了。大概每六个月重写一次，而且重写周期在缩短，因为技术进步在加速。
他认为这是很多公司犯的一个关键错误：做了一版就固定下来不动了。你必须时刻关注模型和技术的最新状态，然后围绕当前状态深度设计整个系统和产品。这意味着每六个月就得重写。
我觉得这挺好玩的。这是流程的一部分。你可以重新开始，重新思考。 （“I find it pretty fun. It's part of the process. You get to restart and rethink it.”）
他说他们马上要发布新版 harness，同时已经在想下一版了。
【4】编码 Agent 改变了一切
Sarah 接着这个话题问：既然你们这么愿意推倒重来，编码 Agent 是不是让这件事变得更轻松了？
Simon 说完全正确。他 2025 年 4 月左右开始用 Claude Code，从此彻底改变了工作方式。
他把编码 Agent 的演化分了几个阶段：先是 Tab 自动补全的时代，然后是能帮你插入和改写一些代码，但真正的转折是 Agent 开始能端到端地实现、验证和维护代码。
关键在于：你需要认真思考架构和验证循环。不是“凭感觉编程”（vibe coding），不是随口说一句你想要什么就完事了。你得想清楚“我要做什么改动？怎么验证它是对的？怎么安全部署？”然后让 Agent 帮你执行这个过程。
用得好的话，你可以做比以前更雄心勃勃的事情，而且比人写的更健壮。用得差的话，产出全是垃圾。 （“If you do it well, you can be much more ambitious about what you're building and also make it much more robust than you could have done with humans writing it. And then the flip side is, if you do it badly, it's all slop.”）
他还提到了 Notion 内部的一个有趣变化。设计团队做了一个叫 Design Playground 的 git 仓库，就是一个简化版的 Notion，里面有一堆 UI 基础组件和一个内置 Agent。所有设计师都可以快速搭建高保真、可部署的原型。以前讨论设计方案是指着一张静态图说“这个会长什么样？”，现在设计师直接给你一个可以打开的 URL。
整个工程团队都在经历这种变化。内部感觉更混乱了一点，但 Simon 说他喜欢这种混乱：更多原型、更多实验、每个 PR 都更有野心。
Sarah 问：对于涉及数据安全等高风险的部分，你们会画线吗？
Simon 说所有 PR 仍然要做代码审查。现在的 PR 都是 Agent 写的，更大更复杂，这是不好的一面。但好的一面是测试覆盖率大幅提高。他个人现在不会提交任何没有完整单元测试的 PR。
【5】100 倍工程师是真的
Sarah 问：AI 工具对团队规模和人才结构有什么影响？
Simon 说核心变化是：每个人的产出上限都大幅提高了，而产出越来越取决于你使用工具的能力和意愿。
但团队规模没有因此显著缩小。Notion 一直喜欢用小规模的突击小队，这在 AI 之前就是对的，AI 之后可能稍微更对一点，但变化不大。
Sarah 追问：普通工程师和那些特别会用工具的工程师之间，差距会不会越来越大？
差距更大了。如果你现在会用这些工具，你可以成为 100 倍甚至 1000 倍工程师。最低门槛没变，但上限极大地提高了。 （“You can be a 100 or 1,000x engineer if you're using the tools right now. The minimum bar has not changed, but the maximum bar has extremely increased.”）
【6】三四次失败之后，Agent 终于上线了
Sarah 问：你之前说通用 Agent 那时候还跑不通，现在到什么程度了？
Simon 说他们挣扎了好几年来做 Agent。每次做出来“差不多能用”，但就是不够有用。主要原因是时机太早。他们前后尝试了三到四次。
终于在 2025 年 8、9 月上线了。 现在你在 Notion 里用的 AI 就是一个完整的 Agent，可以访问 Notion 里几乎所有东西：创建数据库、更新内容、创建文档、搜索网页、做研究。每个用户都有一个 Personal Agent，拥有和用户相同的访问权限。
【注：这就是 2025 年 9 月 18 日发布的 Notion 3.0。Notion 将其定位为继 1.0（文档协作）和 2.0（数据库与工作流）之后的第三次重大进化。】
然后在访谈的大约两周前，Notion 发布了 Custom Agent。和 Personal Agent 不同，Custom Agent 默认没有任何权限，你需要手动授权它能访问什么。但一旦授权，它可以在后台自主运行。
比如你可以给它一个数据库用来记录任务，然后把它接到一个 Slack 频道，它就会自动回复 Slack 上的消息并创建任务。或者你可以让它定期搜索网页和工作空间，然后自动填充周报数据库。
【注：Custom Agent 于 2026 年 2 月 24 日正式发布。Notion 称其早期测试者已创建了超过 21000 个 Agent，Notion 内部运行的 Agent 数量已超过员工数。】
【7】AGI 的内核是编码 Agent
Simon 说他最兴奋的一个方向是让 Agent 能从一个初始内核出发，自我引导（bootstrap）出新的能力。比如如果某个集成还不存在，Agent 可以自己写代码构建这个集成，部署它，然后使用它。
Sarah 确认：所以 Notion 的 Agent 是那种更广义的定义，写代码也是一种工具？
编码 Agent 就是 AGI 的内核。AGI 就会是一个编码 Agent。代码是表达确定性逻辑非常好的原语。 （“I think of coding agents as the kernel of AGI. AGI will be a coding agent, and code is just a really useful primitive for representing deterministic logic.”）
Simon 认为这对知识工作 Agent 特别有意义：它可以自己”长出”新能力。集成不存在？自己建。需要连接新数据源？自己接。
【8】“模型界的瑞士”
Sarah 提出一个竞争格局的问题：Notion 面对的是规模更大的生产力平台和 AI 实验室，它们也在试图做跨数据源的集成和 Agent。Notion 凭什么赢？
Simon 把市场分成三层：实验室（模型商）、软件平台、基础设施。
在模型层面，Notion 把自己定位为“模型界的瑞士”：不绑定任何一家模型商，客户不想被锁定，不同月份不同模型各有优势，Notion 要让用户随时能用到最好的模型，而且能方便地切换。
Sarah 追问：开源模型呢？
Simon 说开源模型确实变得很好了。有四家中国模型现在都“相当不错”，他们刚在 Agent 中上线了其中一款，计划全部接入。这些模型比前沿模型便宜很多，很多场景用它们更合适。
Notion 的定位是：把最好的模型都接进来，做高质量的 Agent 实现，然后提供一个真正适合人和 Agent 协作的工作空间。
【注：截至访谈时，Notion 已支持 GPT-5、Claude Sonnet 4 等前沿模型，以及 MiniMax 等开源模型。用户可在 Agent 设置中选择模型。】
【9】为 Agent 重新设计 API
Sarah 问：Notion 现有的结构，比如 blocks、数据库，对 Agent 有用吗？
Simon 说非常有用。但有一个新挑战：要让 Agent 用起来方便。以前 Notion 的 API 是为人类开发者设计的，现在多了一个“新客户”，就是 Agent 本身。
最初这确实是个问题。Notion 的 API 用一种非常冗余的 JSON 格式来表示 blocks，对 Agent 来说又啰嗦又难处理。
他们接受了这个挑战，做了两件事：第一，为页面的读写设计了一种 Markdown 方言，看起来像标准 Markdown，但扩展了对所有 Notion block 类型的支持，模型对这种格式非常擅长。第二，数据库交互用 SQLite 语法，模型也天然擅长 SQL。
Sarah 问怎么搞清楚什么对 Agent 更好？
Simon 说两条路。一是经验主义：不断尝试，发现“哦，它不擅长这个”“哦，这个 Token 太多了，怎么压缩？”二是第一性原理：模型训练数据里有什么？它的先验知识是什么？它天然擅长什么格式？Agent 循环的高效模式是什么？
Sarah 总结：所以你们在做用户研究，只不过用户是 Agent。
Simon 笑着说：对，而且这个”用户”随时可以聊天，你有无限的访问权限，还能写脚本批量测试。
【10】13 天不间断
Sarah 问到 Simon 个人的 Agent 工作流。
Simon 说他正在做一个新原型，同时跑着好几个 Agent。他的日常工具是 Claude Code 或 Codex 的命令行版本，他喜欢命令行工具，简单好用。
他现在的目标就是尽可能多地同时运行 Agent，全天候不间断。每天晚上睡觉前，他会确保给 Agent 安排了足够多的任务，保证第二天早上醒来时它还没做完。
Sarah 说：那就是胜利。
对，那就是胜利。我的个人纪录是一个编码 Agent 连续跑了 13 天没停过，一直在按任务列表工作。 （“My personal record is that I've had a coding agent running for, I think it was 13 days straight, without stopping and just basically working through tasks.”）
Sarah 承认自己这周也多次半夜醒来检查 Agent 是不是还在跑。Simon 说他也是，每天睡前都要最后确认一遍它还在转。
Simon 的 Personal Agent 也是他的日常工具，因为它能访问公司工作空间的所有内容。比如访谈前一天晚上，他让 Agent 帮他看 Custom Agent 发布后的用户反馈。
但他最得意的是一个邮件分拣 Agent。这个 Agent 连接了他所有的工作和个人邮箱，每天自动把不需要看的邮件归档。搭建过程很简单：创建一个 Custom Agent，给它邮件访问权限，再给它一个空白 Notion 页面当“记忆”。然后让它去看邮件，反过来“采访”Simon：提出它认为应该归档的邮件，Simon 进行纠正。Agent 用这些反馈自动生成一套规则。头几天 Simon 还在纠正它，几周后他完全取消了审批环节，Agent 就全自动运行了。
Simon 说这彻底解决了他的邮件问题。他工作主要在 Slack 上，95% 的个人邮件和工作邮件他根本不需要看。现在他打开收件箱，里面只有真正需要他处理的内容。
他还有一个反馈路由 Agent。Notion 内部有一个 Slack 频道，同事们会在里面随手发产品反馈和 bug 报告。以前这些反馈有时候有人回应，有时候就被忽略了，因为涉及太多团队。这个 Agent 的全部工作就是把反馈路由到正确的地方。它用类似的“记忆”模式，在实际运行中学习路由规则，久而久之积累了数百条规则。比如如果是移动端的 bug，它知道要路由给移动团队，然后在他们的数据库里创建任务。
Simon 说他在最初会检查 Agent 学到的规则是否合理，但一旦信任它在正常运作，就不再看了。偶尔会出问题，他再去修。
他的通用模式是：先做原型，放在审批模式下密切观察，跑几轮之后确认它在正常工作，然后完全放手。
【11】从“做事的工具”变成“管 Agent 的工具”
Sarah 提到 Simon 和 Ivan 最初是在 Tools for Thought 社区认识的。经过这几年的 AI 变革，Notion 的核心定位变了吗？
Simon 说变化相当大。
AI 之前，Notion 的目标是为人类创造最好的直接执行工作的工具。
现在的目标是为人类创造最好的管理 Agent 来替你工作的工具。
之前的目标是创造最好的工具让人直接做事。现在的目标是创造最好的工具让人管理 Agent 替你做事。这是一个很大的转变。 （“Before AI, our goal was to create the best tool for humans to directly perform their work. And then now the goal is to create the best tool for humans to manage agents to do the work for them. That's a big shift.”）
但他接着说了一个重要的发现：Notion 之前构建的所有原语，在 Agent 时代依然非常有用。文档依然需要，Agent 很喜欢写 Markdown。数据库依然需要，结构化数据依然是刚需。如果你有 100 个后台编码 Agent 在同时工作，你不会想要 100 个聊天窗口，你会想要一个看板。 跟以前一样。
Notion 只需要增加一些新原语：Agent 是什么？它怎么跟页面和数据库交互？
Sarah 最后问：过去六个月，你个人的工作方式有什么变化？
Simon 说完全变了。他从 2025 年夏天起就不再手写代码了。
经历了几个阶段：人手动写所有代码→Tab 补全→跟 Agent 对话让它做小任务，但人还在外层循环→现在他设计一个端到端的任务，包括改动和验证，他只负责最外层的确认。如果 Agent 跑偏了，他去纠正。
他现在是 Agent 管理者，不是程序员。
【12】让非技术团队也能造 Agent
Sarah 问 Notion 内部是怎么帮非技术团队建立用 Agent 的直觉的。
Simon 说他们定期做内部 workshop 和 hackathon。一个月前他刚跟人力资源团队（People Team）做了一次。这个团队反而成了 Custom Agent 最积极的使用者，因为他们日常就有大量在 Slack 和 Notion 之间来回搬运信息的重复工作。
他的观察是，大家其实都很兴奋想试，只是需要一点推动帮他们起步。一旦跨过“什么是 prompt”、“Agent 怎么被触发和唤醒”这些最初的技术门槛，Agent 的交互方式其实非常符合直觉，因为你就是在跟它说话。
最大的障碍可能不是能力问题，而是信心问题：让人们相信这东西真的能用。
Q&A
Notion 的 AI harness 多久重写一次？为什么？ 大约每六个月一次。因为模型和技术进步太快，系统必须紧贴当前状态设计，做完一版就不动是常见错误。
编码 Agent 对团队规模有影响吗？ 个人产出上限大幅提高，但 Notion 的团队规模没有显著缩小。小团队一直更好，这一点在 AI 前后没有本质变化。
Notion 怎么为 Agent 设计 API？ 页面读写用 Markdown 方言，数据库用 SQLite。设计方法是经验主义试错加第一性原理推演：既看 Agent 实际表现，也想模型训练数据的先验。
Custom Agent 和 Personal Agent 有什么区别？ Personal Agent 跟用户有相同权限，被动响应用户请求。Custom Agent 默认无权限需要授权，可以按计划或触发器在后台自主运行。
Simon 认为 AGI 会长什么样？ AGI 就是一个编码 Agent。代码是表达确定性逻辑的最好原语，而能写代码的 Agent 可以不断自我扩展能力。
Simon 在这次对话里反复传递的核心信息有三个：第一，AI 系统必须跟着模型能力持续重写，不能做一版就停；第二，编码 Agent 不只是开发者的效率工具，它是 Agent 自我进化的关键能力；第三，生产力软件的定义正在从“人用的工具”变成“人用来管理 Agent 的工具”。
一个值得追问的问题是：Custom Agent 自主运行带来的 prompt injection 安全风险，Simon 在访谈中没有提及，但 Notion 官方文档里已经写了这是他们正在投入的领域。当你的 Agent 数量超过员工数量时，安全和控制的问题只会越来越大。
另一个悬而未决的点：如果 AGI 真的是编码 Agent，那模型厂商自己做的 Agent 跟 Notion 的 Agent 会是什么关系？“模型的瑞士”这个定位，在模型厂商也想做平台的时代，能维持多久？不过 Simon 自己给出了一个方向：管理 100 个 Agent 的人需要什么？不是 100 个聊天窗口，是一个看板。如果这个判断成立，Notion 十多年积累的协作基础设施就不是包袱，而是壁垒。
原始视频：https://www.youtube.com/watch?v=1dYThQgOyZU
See all posts