AI Product Observer

AI Lover

[AI Product Observer @fengzi2016China]

@tianyi 都是数学证明问题

[AI Product Observer @fengzi2016China]

@DirtyHarry68 I barely rely on manual code review to verify correctness anymore.

[AI Product Observer @fengzi2016China]

I’ve noticed a very real pain point in AI coding:

What am I supposed to do while waiting for the AI to come back?

When I code with an AI agent, I often enter a strange state.

I hand a task to the agent.
It starts reading code, editing files, running tests, fixing errors.
It looks like the AI is working for me.
But I don’t actually feel relaxed.
Because I’m still waiting for it.

And this is not ordinary waiting.

If it only takes a few seconds, that’s fine.
But many agent tasks take tens of seconds, minutes, or even longer.

During that time, I get stuck in an awkward state:

I can’t fully leave, because I’ll need to review what it changed, check whether it went off track, and decide what to do next.
But I also can’t really participate, because the execution is currently in the agent’s hands.

So I’m neither focused on work nor truly resting.

I’m just suspended.

This feels surprisingly oppressive.

In traditional software development, we also wait for builds, tests, and deployments.

But that kind of waiting is usually more predictable.
You roughly know what the system is doing.
You know what you’ll do when it finishes.

Waiting for an AI agent feels different.

The agent is thinking, searching files, changing code, generating solutions, and sometimes fixing its own mistakes.

But you don’t know whether it will drift, miss context, introduce bugs, or misunderstand the original intent.
So it’s hard to fully relax.
If I stare at it, I feel anxious.
If I don’t stare at it, I worry it might go wrong.
If I switch to something else, I may not come back easily.

This is a hidden problem in many AI coding products:

They improve execution efficiency,
but they also create a new kind of cognitive burden.

Especially when the waiting time becomes longer, people naturally open something else:

messages, feeds, group chats, another task, an article, another tab.

On the surface, this looks like “using fragmented time.”
But once you truly jump away, the context-switching cost becomes very high.
When you come back, you have to reload everything:

What did I ask the agent to do?
Where is it now?
Why did this diff appear?
Did it actually solve the core problem?
Should I let it continue, or should I take over?

So the AI agent may save execution time,
but if the waiting state is not designed well, part of that saved time gets eaten by attention switching and context recovery.
This made me wonder:

Can we design a better way to handle this waiting time?

Not by forcing people to stare at a progress bar.
Not by encouraging them to start another serious task.
Not by inserting a random feed that pulls them completely away.

But by creating a lightweight middle state:

You stay near the main task,
but you don’t have to stay tense.

You can loosen up a bit,
but you don’t fully derail.

I call this a “waiting capsule.”
It is not a heavy feature.
It is more like a low-friction cognitive buffer next to the AI agent workflow.
When the agent is working, the capsule can show lightweight content:
a related case,
a technical concept,
a piece of industry news,
a product insight,
an old note,
an unfinished question,
or even something light enough to let the brain breathe.

The point is not to “maximize every minute.”
I actually think this should not be too productivity-driven.

It is not about forcing learning into every gap.
It is not about squeezing more value out of waiting time.

Its real value is to help people stay in a more humane state while the AI is executing.

Because humans are not machines that can stay in high-alert monitoring mode forever.
Rigorous judgment does require focus.
But rigor should not depend on constant tension.

If someone stays too long in the state of:

“I must keep watching it.”
“It might go wrong at any second.”
“I may need to rescue it later.”
“I’m bored, but I also don’t want to lose the context.”
Their attention gets drained.
Their judgment narrows.
Their inspiration gets suppressed.

High alert is good for risk detection, inspection, and fallback.
But it is not good for long-term creativity.
It is not good for sustained complex judgment.

A more human work rhythm needs tension and release.

When it’s time to inspect, we should converge.
When it’s time to wait, we should be able to loosen up a little.

Not fully leaving the main thread.
But not staring at a progress bar like a guard either.

This is where the waiting capsule matters.

It is not about making vibe coders lazy.
It is not about distracting people.
It is about providing a low-load, returnable buffer while the AI is executing.
A place where people can briefly touch inspiration, knowledge, news, old notes, or lightweight content.
But unlike an infinite feed, it should not pull them completely away.
If done well, AI coding would feel less like a tense monitoring relationship.
It would feel more like a rhythmic collaboration:
The AI executes.
The human keeps judgment.

The AI pushes the task forward.
The human stays mentally alive.

The AI does not require the human to stare at it like a supervisor.
But the human also does not fully leave the work context.

And if this idea goes deeper, I don’t think the content should only come from the external web.
It should connect with your personal knowledge base.

Because different people need different things while waiting.

Some people want technical background.
Some want industry news.
Some want to review English expressions.
Some want product examples.
Some just want something light.
Some need the feeling of: “I’ve thought about something like this before.”

If the waiting capsule can connect to a personal knowledge base, it becomes more than random recommendation.

It can surface lightly related things from your old notes, saved articles, project retrospectives, reading highlights, question lists, and idea fragments.

It does not need to be as precise as search.

It does not need to feel as heavy as formal learning.
It is more like gently bringing back your past thoughts at the right moment:
“You thought about a similar problem before.”
“This task is related to a case you saved.”
“This connects to a long-term theme you care about.”
For many people, the biggest problem with a personal knowledge base is not the lack of content.

It is that the content is asleep.
Notes are written and forgotten.
Bookmarks keep accumulating.
Project retrospectives are rarely reopened.
AI agent waiting time creates a natural moment to reactivate them.

So the waiting capsule is not about filling empty time.

It is about helping people who code with AI maintain a low-load but connected mental state during the gap where they can’t participate, but also can’t fully leave.
They can come back.
They can still judge.
They can still have new ideas.

A good AI coding product should not make people stare at AI like supervisors.

It should let the AI execute while the human keeps a more natural rhythm:
not constantly tense,
not completely derailed,
not losing context,
and not suppressing inspiration.

[AI Product Observer @fengzi2016China]

最近遇到数据冷启的问题，记录一些数据源仓库：

免费搜集实时新闻数据（包括很多新闻来源，比如aihot,ithome,hackernews,github）：https://t.co/DQj8nEoeqs

免费的英文单词数据（23882个单词）：https://t.co/hVLjILm5bQ

[AI Product Observer @fengzi2016China]

@gkxspace 厉害咯

[AI Product Observer @fengzi2016China]

@NextBullReady @grok 帮我总结下核心内容

[AI Product Observer @fengzi2016China]

@Xudong07452910 @jietang 感觉还是有点抽象了，什么是纯粹

[AI Product Observer @fengzi2016China]

每个社区平台都有自己的特征，人们喜欢在推特上看最新最前沿的知识，喜欢在小红书看情绪的释放，喜欢在抖音里上瘾精神放空，喜欢在微信读书里和名人对话，但是它们本不应该切割得这么严重，应该有个贯穿所有知识碎片的工具，将它们串起来，用ai构建个人认知成长伙伴

量变量变，最终终将质变

[AI Product Observer @fengzi2016China]

@yanhua1010 @grok 总结下

[meng shao @shao__meng]

2026 年 Subagent 的四种管理模式

@_philschmid 把"主 agent 如何驱动其它 agents"按主 agent 对 subagent 生命周期的控制力从弱到强排成四档。模型能力越强，能驾驭的模式越复杂。

模式 1：Inline Tool —— subagent 就是一次函数调用
主 agent 通过 call_agent 工具派一个任务，等结果返回，跟调用 read_file 没本质区别。

· 同步：工具调用阻塞，结果作为 tool response 返回。
· 异步：工具立即返回一个 agent_id，结果完成后以"通知消息"形式注入对话。

适用：自包含任务 —— 资料检索、代码 review、文件分析、测试生成。绝大多数���谓"多 agents"需求其实到这里就够了。 局限：没法中途追加指令、查看进度或取消。任务理解错了，只能等结果出来才知道。 门槛：任何能调用工具的模型都行，包括小模型。

模式 2：Fan-Out —— 派发后再收集
把"派发"和"收集"拆成两个工具：spawn_agent 立即返回 ID，wait_agent 阻塞等结果。

关键差异：派发与等待之间，主 agent 可以做自己的事（读文件、再派新任务）。模型自己决定什么时候 wait_agent。

适用：多个互相独立、可并行的任务。 局限：如果模型一 spawn 完就立刻 wait，等于退化成模式 1。价值依赖模型能合理穿插自身工作。仍然是 fire-and-forget，无法中途纠偏。 门槛：模型要能推理"何时该等"。

模式 3：Agent Pool —— 持久化 agent + 消息通信
subagent ��成长寿命、有状态的成员。工具集扩展为 spawn / send_message / wait / list / kill。主 agent 可以反复给同一个 agent 发消息，对方保留完整上下文。

文中示例：研究员 agent-r 第一次被派去找资料，第二次被叫来对照刚写好的草稿做事实核查 —— 它仍记得上次找到的 5 个来源。

wait_agent 按消息粒度返回，主 agent 可以根据返回内容动态调整下一步指令。

适用：需要专家协作的多步工作流，主 agent 充当信息路由器。 局限：主 agent 要追踪多个 agent 的状态、决定何时发消息何时等待、记得 kill_agent 释放资源。前沿模型大概能 hold 住 2–4 个 agent。

模式 4：Teams —— agents 之间直接对话
主 agent 只负责组队、定角色、启动，然后退场。每个成员都拥有 send_message，可以直接互相寻址（层级路径、文件邮箱或 IPC）。

示例中主 agent 只对 planner 说一句"你的队友是 implementer 和 reviewer，做完汇报给我"，之后 planner <-> implementer <-> reviewer 之间的协作完全发生在主代理上下文之外。主 agent 只在有 agent 显式向它汇报时才收到结果。

适用：协调逻辑本身已经超出单个 agent 能逐步管理的复杂度的大型任务。 局限：
· 每个成员都需要前沿模型能力，不只是主 agent。
· 基础设施问题：环路检测（A 等 B、B 等 A）、写入冲突、关停协调。
· 调试极难，消息链难追踪，失败会级联放大。

# Philipp Schmid 的核心建议
1. 从模式 1 开始。大多数看起来像"需要多 agents"的任务，靠一个 prompt 写得好的内联工具调用就能解决。
2. 真正独立可并行才升级到模式 2。
3. 需要跨步骤协作才上模式 3。
4. 协调逻辑本身爆炸才考虑模式 4。
5. 每升一级，对模型能力的要求陡增。模型不够强，就停在 1 或 2。
6. 框架提供工具，编排由模型决定。今天要 4 个 agents 协作的任务，明天可能一个更强的单 agent 就能解决。

# How Agents Manage Other Agents: Four Subagents Patterns in 2026
https://t.co/IohUScw6Je

[余温 @gkxspace]

涨知识了，这几个网站是真牛逼，每天看一下，根本不会信息焦虑了……

1、NewsNow
仅一个页面看完知乎、微博、B站、虎扑、V2EX……
https://t.co/bZHs8GbSy0

2、今日热榜
GitHub Trending、Product Hunt、Hacker News
https://t.co/0NOgyZAeXN

3、SoPilot
X 上的爆款推文
https://t.co/yJFIicBCpn

[AI Product Observer @fengzi2016China]

@elonmusk 为什么碰到了泡泡不爆炸

[AI Product Observer @fengzi2016China]

AI 时代，有想法的人会爽死，没想法的人会慌死，还没看透的人会开始思考人活着的意义，看透的人会好好健身，保持每一刻的最佳状态

[Bill The Investor @billtheinvestor]

想象一下，你屏幕上的每一个像素都直接从模型实时流式传输而来。没有 HTML，没有布局引擎，没有代码。只有你想要看到的画面。@eddiejiao_obj、@drewocarr 和我构建了一个原型，以探索这在实际中如何运作，并致力于将其变为现实。我们称之为 Flipbook。(1/5)

[AI Product Observer @fengzi2016China]

@LiYanan2004 复现了codex?

[Google for Developers @googledevs]

A2UI v0.9 is the new standard for portable Generative UI, allowing your agents to natively "speak" UI directly to your existing frontends.

✨ React, Flutter, and Angular support
🐍 Python SDK via pip install
⚡ High-performance streaming
🛠️ Design system integration

Learn more via the blog: https://t.co/YOTjKGBDjm

[刘小排 @bourneliu66]

我认为，我们应该多关注Builders（动手做事的人），少关注Influencers（只做自媒体的人）。

根据此原则，我开放了一套日报，解决三个问题：

- 昨天，全世界的独立开发者发布了什么好玩的？
- 昨天，有啥值得独立开发者关注的新闻？
- 今天我有2小时，我可以做点啥？

https://t.co/H0j3QG4SSH

[The Figen @TheFigen_]

It's not easy to win over a female Parakeet. 😂