夜雨何曾寄北

念桥边红药，年年知为谁生？

[Miles Ma @miles_mazy]

https://t.co/GIspREmXeu

[数字生命卡兹克 @Khazix0918]

https://t.co/lqZ5vGWM0J

[Bruce Jinji 尽己 @brucejinji711]

https://t.co/UPwPfMbs5t

[lumxss @bkdgiffug]

多个 Agent 一起干活，最怕的不是能力不够，而是互相不知道对方干了什么。

Block 开源的 Buzz，就是把这群 AI 放进同一个工作区里。

消息、代码提交、Review、合并等操作都会留下记录，Agent 之间不用靠人肉复制上下文。

而且 Agent 可以直接加入频道，拥有独立身份和权限，能自己建仓库、提交代码、跑任务、参与审查。

支持 Windows、macOS、Linux，还提供专门给 Agent 用的 CLI。

如果你正在折腾多 Agent 协作开发，这个可以研究一下。
🔗 https://t.co/vc4vRx3hSu

[云比云 @yunbiyun]

https://t.co/TFhHsg24Tr

[lumxss @bkdgiffug]

Claude Code、Cursor 这些 AI 编程工具到底怎么工作的？

如果只看官方文档，很多底层逻辑确实不太好理解。

这个开源项目 dg-ai-notes，干脆拿 Pi-Agent SDK 当案例，从源码入手拆解 Agent。

一共 10 章，覆盖架构、Agent Loop、模型调用、工具系统、上下文压缩、会话管理等核心部分。

每章都围绕三个问题讲：
是什么 → 怎么实现 → 为什么这样设计
还提供 TypeScript 和 Python 两套实现，网页、Markdown、PDF 都能看。

想系统补一下 Agent 原理的，可以收藏。
🔗 https://t.co/ryPsFzsjsE

[wluha @cryptowluha]

这 5 个 skill 能让 agent 秒变家教、youtuber 和创始人的得力助手

1. tutor-skills
手把手教你任何东西
https://t.co/C1R0GK9w4l

2. youtube-skills
搞定 youtube 那一整套流程
https://t.co/KSffdQaVNg

3. platform-design
按每个平台的特点做界面
https://t.co/klPcSBN63x

4. Aegis
给整个项目加上护栏
https://t.co/A7qFNC3EYB

5. founder-skills
覆盖创始人每天要处理的杂事
https://t.co/As6cA1ikhM

先收藏，再打造属于你自己的 ai 员工

[艾也 @241221Alice]

万人收藏的北大价值投资课｜李录

3小时经典完整 👇

[meng shao @shao__meng]

麻省理工「多模态 AI 课程」在 Youtube 可以全集学习
https://t.co/IZYkWd0i0o

[夜雨何曾寄北 @wangxw0919]

是日也，天朗气清，惠风和畅
仰观宇宙之大，俯察品类之盛，所有游目骋怀，足以极视听之娱，信可乐也。

[Matt Dancho (Business Science) @mdancho84]

How to build AI agents:

A great cheat sheet (bookmark for later).

Here's how to use it:

[tut_ml @tut_ml]

Build a RAG App Project- https://t.co/p0NxRwVf5T

[yishan @tspy]

https://t.co/7RRfhyg36u

[夜雨何曾寄北 @wangxw0919]

@huxiaowen10 逝者安息，生者坚强！

[Ivan Velichko @iximiuz]

How Container Filesystem Works 🧐

Building a Docker-like container from scratch using only standard Linux commands (unshare, mount, pivot_root, etc.) is a great way to understand exactly what a container runtime like runc does under the hood to turn a container image into a fully-fledged rootfs.

Deep dive: https://t.co/PC7c9Zy1SJ

[Rahul @sairahul1]

How to build your first AI agent (Full guide)

[Max For AI @MaxForAI]

终于有人把 KV 缓存解释清楚了，不再让它听起来像黑魔法

Q 基本上是一次性的，而 K/V 才是需要保留的部分。

[meng shao @shao__meng]

写代码不再值钱，工程师的价值还剩什么？
Simon Willison 在《Agentic Engineering Patterns》中给出了答案。

一套完整的工程方法论：从"代码边际成本趋零"这一事实出发，推导出知识资产的复利策略、让 Agent 自证正确的验证闭环，以及对"认知债"的系统性防御。 https://t.co/py3Nrti6fe

[Avi Chawla @_avichawla]

Why KV cache stores K and V vectors but never Q?

(a popular technical LLM interview question)

LLMs are autoregressive so each token is predicted from every token before it, one at a time.

This autoregressive nature has a direct consequence inside the model.

A forward pass over <n> tokens produces <n> hidden states, but only the last one is projected to logits and is required to generate the next token.

So to understand why KV cache just stores K and V vector, we must back track to see how exactly is the last hidden state produced.

Let's walk through this with a 10-token prompt.

1) Prefill:

All 10 tokens go through the model in one forward pass, in parallel (with causal masking), since the whole prompt is already known.

At every layer, each of the 10 positions produces a query, a key and a value vector, and attention at each position runs against all positions up to it.

This pass is compute-heavy, and it's why the first token takes noticeably longer than the ones after it. TTFT is mostly prefill.

2) The first output token:

To generate the 11th token, only the 10th token's hidden state is needed. So this is projected from the hidden-dim to vocab-dim to generate logits over vocab.

These logits then go through softmax and sampling to generate token 11.

3) Back-track the hidden state:

The last hidden state is the last row of the feedforward block's output. The feedforward block is position-wise (it's applied to each row independently) so that row comes from the last row of the attention output before it.

So now we need to see how the last row of attention is computed.

4) Attention matrix:

QKᵀ for a 10-token prompt will give a 10 × 10 matrix.

Row <i> will have the dot product of query <i> with every key.

Row 10 is therefore Q₁₀·K₁, Q₁₀·K₂, all the way to Q₁₀·K₁₀.

Notice that only Q₁₀ appears in it. Q₁ through Q₉ only belong to their corresponding rows 1-9, and those rows' hidden states we already discarded because they were never needed.

The last row of attention goes through softmax and multiplies the full stack of value vectors, V₁ through V₁₀, to give the last row of the attention output.

So the last hidden state depends on exactly three things: Q₁₀, every key, and every value.

5) Generating token 12:

Token 11 is appended, and this time, we need row 11's hidden state to generate token 12.

Mathematically, attention operation turns out to be Q₁₁ against K₁ through K₁₁, then multiplied by V₁ through V₁₁.

K₁ through K₁₁ and V₁ through V₁₁ are bit-for-bit what prefill + first token produced since under causal masking, a token's key and value depend on that token and the ones before it, never on anything after, so appending token 11 cannot change anything at position 3.

6) The cache state:

Overall, this implies that you just need to retain the keys and values at each decoding step, and compute only the new position's Q, K and V.

Each decode step requires one query vector, which is never used again, so they are never cached across the decoding process.

The visual below explains the entire process.

That said, KV cache is only one of four separate caching layers in an LLM stack.

The other three are prefix caching on the server, prompt caching billed by a provider, and a semantic cache that skips the model entirely.

I wrote a full breakdown of all four caches in LLM serving that you should know as an AI engineer, with code for each.

Read it below.

[Miles Ma @miles_mazy]

https://t.co/RPmnMYqsYb