# Dynamic Software
**作者**: Ashpreet Bedi
**日期**: 2026-04-30T17:33:08.000Z
**来源**: [https://x.com/ashpreetbedi/status/2049904901371633815](https://x.com/ashpreetbedi/status/2049904901371633815)
---
For fifty years, software has been static.
Every program you've ever used is a collection of functions run through a hard-coded control flow: If, else, while, for. The functions do the work. Reading from databases. Calling APIs. Transforming data.
Same Input = Same Output. This was the contract for fifty years.
Then 2024 happened. The control flow came alive and created a new category of software. Software that is alive, dynamic, on-demand.
## Software is dead, long live Software
Static software is a recording. You press play and you get back exactly what was captured. Same notes, same order, every time. The performance happened once, in a devbox, and now it plays the same tune every time.
Dynamic Software is a live orchestra.
The score exists. The instruments exist. The musicians exist. But what happens in the room tonight depends on the maestro, the players, the moment. The model is the maestro. The tools are the instruments. The control flow is the performance, not the recording.
This is what people feel when they use a great agent and can't quite explain why it feels different. They've spent their whole lives interacting with buttons. Now they're in a room with a live performance for the first time. The software is responding to them, here, now, with judgment and presence. It's listening. It's adjusting. It's alive in a way software has never been alive before.
Recordings are perfect. Live performances aren't. A live orchestra makes choices. Sometimes it stumbles. Sometimes it surprises you. The reason we still pay to hear live music is that something different happens in the room.
The performance is the point.
Dynamic Software is alive. It's not deterministic. It's not perfect. And once you've felt the difference, recordings feel like what they always were. Frozen.
We're not building better recordings. We're building the first generation of software that performs.
## Assumptions Dynamic Software breaks
When software comes alive, every assumption built on static software breaks.
Determinism breaks. Same input no longer means same output. The model considers context, memory, learnings. The software does something different on Tuesday afternoon than it did on Monday morning. While this can be (somewhat) controlled in text, we should note that the visual era is next. Charts, dashboards, entire screens generated on-demand. Instead of forcing determinism on non-deterministic software, give in, enjoy the ride.
State and time work differently. Static programs don't need to remember much. The control flow is the same every time, so state lives in a database and is CRUD only. In Dynamic Software, state is context. Memory of past sessions. History of what worked. Knowledge of the domain. The database stops being storage and becomes the context the software runs on.
Sessions follow from this. A static API endpoint is stateless by design. Each request is independent. Dynamic Software is the opposite. A session is a continuous context that spans minutes, days, sometimes weeks. The user comes back, the agent picks up where it left off. Sessions become first-class.
Time changes too. Static software returns in milliseconds, seconds if you don't believe in data co-location. Dynamic Software reasons. It calls tools. It waits for tools to return. It reasons again. A single request takes minutes sometimes. Streaming is the default. Background execution is a core primitive. The HTTP request/response model strains and breaks and so does the default 29s loadbalancer timeout.
The software needs to watch itself. With static software, you can read the code and know what it does. With Dynamic Software, you can't. The control flow is a model and the model is opaque. The only way to know what your software did is to record everything it did. Every reasoning step. Every tool call. Every retrieval. Tracing goes from a debugging tool to the only way to understand your software.
Watching isn't enough. Static programs don't make decisions, so there's nothing to approve. Dynamic Software makes decisions, and decisions have consequences. Some can be made freely. Some need the user. Some need an admin. Your software has to express which is which, and your runtime has to enforce it.
Every one of these is a real engineering problem. Every team building Dynamic Software hits them all. Most spend months solving these from scratch.
## A new category needs a new runtime
Static software has a mature runtime. You write Django or Express, deploy to a managed platform, and don't think about HTTP, sessions, scaling, or recovery. The infrastructure is solved. The platform handles it.
Dynamic Software has no equivalent. You write an agent. Then you build six months of infrastructure around it, fixing every edge case manually. Edge cases you only learn after running agents at scale. SSE + websockets. Streaming + background execution. Sessions that survive restarts. Storage you can actually query, not five vendors stitched together. Approval gates that wait for admin sign-off, not just user confirmation. Per-resource, per-tool RBAC. Agents available on Slack, Telegram, WhatsApp, because no one wants to use a custom UI.
This is why 80% of agents don't work, there's a painful amount of grind in the last mile.
The last shift this big was going from desktop apps to web apps. Web software needed its own runtime, its own protocols, its own infrastructure, its own developer tools. We spent two decades building all of it.
Dynamic Software is here. Starting from scratch. Its own runtime. Its own protocols. Its own infrastructure. Its own developer tools.
## The next decade
Static software took fifty years to mature. Operating systems, databases, web servers, deploy platforms, observability stacks, identity providers. We forget how recent most of it is. Heroku was 2007. Kubernetes was 2014. Vercel was 2015. The infrastructure we now take for granted is younger than most of the people building on it.
Dynamic Software is at year one.
Whoever builds the runtime, the protocols, the developer tools, the platforms, defines the next era of software. The work ahead is enormous. It is also the most interesting work I've done in the past fifteen years.
Come build with us at Agno.
## 相关链接
- [Ashpreet Bedi](https://x.com/ashpreetbedi)
- [@ashpreetbedi](https://x.com/ashpreetbedi)
- [8.5K](https://x.com/ashpreetbedi/status/2049904901371633815/analytics)
- [Agno](https://agno.link/gh)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [1:33 AM · May 1, 2026](https://x.com/ashpreetbedi/status/2049904901371633815)
- [8,510 Views](https://x.com/ashpreetbedi/status/2049904901371633815/analytics)
- [View quotes](https://x.com/ashpreetbedi/status/2049904901371633815/quotes)
---
*导出时间: 2026/5/1 21:56:08*
---
## 中文翻译
# 动态软件
**作者**: Ashpreet Bedi
**日期**: 2026-04-30T17:33:08.000Z
**来源**: [https://x.com/ashpreetbedi/status/2049904901371633815](https://x.com/ashpreetbedi/status/2049904901371633815)
---
五十年来，软件一直处于静态。
你用过的每一个程序都是通过硬编码控制流运行的函数集合：If、else、while、for。函数负责执行任务。从数据库读取。调用 API。转换数据。
相同输入 = 相同输出。这是五十年的契约。
然后 2024 年来了。控制流活了过来，创造了一个新的软件类别。活的、动态的、按需生成的软件。
## 软件已死，软件万岁
静态软件是一场录音。你按下播放键，得到的就是被捕捉到的确切内容。同样的音符，同样的顺序，每次如此。演奏只发生过一次，是在开发者的环境中，而现在它每次都在播放同样的曲调。
动态软件是一支现场管弦乐队。
乐谱存在。乐器存在。乐手存在。但今晚房间里会发生什么，取决于指挥、演奏者和当下时刻。模型是指挥。工具是乐器。控制流是演奏，而不是录音。
这就是人们在使用出色的智能体时感受到的、却难以解释为何感觉不同的体验。他们花了一辈子时间与按钮打交道。现在他们第一次置身于一场现场表演之中。软件正在这里、此刻回应他们，带着判断力和临场感。它在倾听。它在调整。它以一种前所未有的方式活着。
录音是完美的。现场表演不是。现场管弦乐队会做出选择。有时它会磕绊。有时它会给你惊喜。我们仍然付费去听现场音乐的原因，是因为房间里会发生一些不同的东西。
表演才是重点。
动态软件是活的。它不是确定性的。它不完美。一旦你感受到了这种差异，录音就会显露出它们的本来面目。冰封的静止。
我们要打造的不是更好的录音。我们正在构建的是第一代会“表演”的软件。
## 动态软件打破的假设
当软件活过来时，每一个基于静态软件构建的假设都会破灭。
确定性破灭了。相同输入不再意味着相同输出。模型会考量上下文、记忆和学习成果。软件在周二下午做的事情可能与周一早上不同。虽然这在文本领域可以（某种程度上）被控制，但我们应该注意到，视觉时代紧随其后。图表、仪表盘、整个屏幕都按需生成。与其强行对非确定性软件施加确定性，不如顺其自然，享受这趟旅程。
状态和时间的工作方式也变了。静态程序不需要记太多东西。控制流每次都一样，所以状态存在于数据库中，且仅限于增删改查（CRUD）。在动态软件中，状态就是上下文。过去会话的记忆。有效方法的历史。领域的知识。数据库不再仅仅是存储，而变成了软件运行的上下文环境。
会话由此产生。静态 API 端点在设计上是无状态的。每个请求都是独立的。动态软件恰恰相反。会话是一个持续数分钟、数天甚至数周的连续上下文。用户回来了，智能体从中断的地方继续。会话成为了一等公民。
时间也改变了。静态软件在毫秒级返回，如果你不认同数据共置的理念，可能需要几秒。动态软件则需要推理。它调用工具。它等待工具返回。它再次推理。一个请求有时需要数分钟。流式传输成为默认设置。后台执行成为核心原语。HTTP 请求/响应模型紧绷并断裂，默认的 29 秒负载均衡器超时也是如此。
软件需要审视自身。对于静态软件，你可以阅读代码并知道它的作用。对于动态软件，你做不到。控制流是一个模型，而模型是不透明的。要知道你的软件做了什么的唯一方法，就是记录它做过的所有事情。每一个推理步骤。每一个工具调用。每一次检索。追踪从一种调试工具变成了理解你的软件的唯一途径。
光看还不够。静态程序不做决策，所以没有什么需要批准。动态软件会做决策，而决策是有后果的。有些可以自由做出。有些需要用户批准。有些需要管理员批准。你的软件必须表达清楚哪种是哪种，你的运行时必须强制执行这些规则。
每一个都是真正的工程问题。每一个构建动态软件的团队都会遇到所有这些问题。大多数团队花费数月时间从头解决这些问题。
## 一个新的类别需要一个新的运行时
静态软件拥有成熟的运行时。你编写 Django 或 Express，部署到托管平台，然后不用担心 HTTP、会话、扩展或恢复。基础设施已经解决。平台负责处理。
动态软件没有同等的产物。你编写一个智能体。然后你围绕它构建六个月的基础设施，手动修复每一个边缘情况。那些边缘情况只有在大规模运行智能体后才能了解到。SSE + websockets。流式传输 + 后台执行。能在重启后存活的会话。你可以真正查询的存储，而不是拼凑五个供应商。等待管理员签名批准的审批门，而不仅仅是用户确认。针对每种资源、每种工具的 RBAC。在 Slack、Telegram、WhatsApp 上可用的智能体，因为没人想用自定义 UI。
这就是为什么 80% 的智能体不工作，最后一公里有太多痛苦的磨砺。
上次如此巨大的转变是从桌面应用程序到 Web 应用程序。Web 软件需要自己的运行时、自己的协议、自己的基础设施、自己的开发工具。我们花了二十年时间构建了所有这一切。
动态软件来了。从零开始。它自己的运行时。它自己的协议。它自己的基础设施。它自己的开发工具。
## 下一个十年
静态软件花了五十年才成熟。操作系统、数据库、Web 服务器、部署平台、可观测性堆栈、身份提供商。我们忘记了其中大多数技术问世的时间有多近。Heroku 是 2007 年。Kubernetes 是 2014 年。Vercel 是 2015 年。我们现在视为理所当然的基础设施，比大多数在其上构建的人还要年轻。
动态软件处于第一年。
谁构建了运行时、协议、开发工具和平台，谁就定义了软件的下一个时代。前方的工作量巨大。这也是我过去十五年来做过的最有趣的工作。
来 Agno 和我们一起构建吧。
## 相关链接
- [Ashpreet Bedi](https://x.com/ashpreetbedi)
- [@ashpreetbedi](https://x.com/ashpreetbedi)
- [8.5K](https://x.com/ashpreetbedi/status/2049904901371633815/analytics)
- [Agno](https://agno.link/gh)
- [升级到 Premium](https://x.com/i/premium_sign_up)
- [2026年5月1日 凌晨1:33](https://x.com/ashpreetbedi/status/2049904901371633815)
- [8,510 次查看](https://x.com/ashpreetbedi/status/2049904901371633815/analytics)
- [查看引用](https://x.com/ashpreetbedi/status/2049904901371633815/quotes)
---
*导出时间: 2026/5/1 21:56:08*