jeneser

Artificial intelligence / JavaScript / Kotlin / Python

[jeneser @jeneserwang]

还记得你何时加入 X 吗？我知道！#我的X周年纪念日

[elvis @omarsar0]

Google just published a banger guide on effective context engineering for multi-agent systems.

Pay attention to this one, AI devs! (bookmark it)

Here are my key takeaways:

Context windows aren't the bottleneck. Context engineering is.

For more complex and long-horizon problems, context management cannot be treated as a simple "string manipulation" problem.

The default approach to handling context in agent systems today remains stuffing everything into the prompt. More history, more tokens, more confusion. Most teams treat context as a string concatenation problem.

But raw context dumps create three critical failures:

> cost explosion from repetitive information
> performance degradation from "lost in the middle" effects
> increase in hallucination rates when agents misattribute actions across a system

Context management becomes an architectural concern alongside storage and compute. This means that explicit transformations replace ad-hoc string concatenation. Agents receive the minimum required context by default and explicitly request additional information via tools.

It seems that Google's Agent Development Kit is really thinking deeply about context management. It introduces a tiered architecture that treats context as "a compiled view over a stateful system" rather than a prompt-stuffing activity.

What does this look like?

1) Structure: The Tiered Model

The framework separates storage from presentation across four distinct layers:

1) Working Context handles ephemeral per-invocation views.
2) Session maintains the durable event log, capturing every message, tool call, and control signal.
3) Memory provides searchable, long-lived knowledge outliving single sessions.
4) Artifacts manage large binary data through versioned references rather than inline embedding.

How does context compilation actually work? It works through ordered LLM Flows with explicit processors. A contents processor performs three operations: selection filters irrelevant events, transformation flattens events into properly-roled Content objects, and injection writes formatted history into the LLM request.

The contents processor is essentially the bridge between a session and the working context.

The architecture implements prefix caching by dividing context into stable prefixes (instructions, identity, summaries) and variable suffixes (latest turns, tool outputs). On top of that, a static_instruction primitive guarantees immutability for system prompts, preserving cache validity across invocations.

2) Agentic Management of What Matters Now

Once you figure out the structure, the core challenge then becomes relevance.

You need to figure out what belongs in the active window right now.

ADK answers this through collaboration between human-defined architecture and agentic decision-making. Engineers define where data lives and how it's summarized. Agents decide dynamically when to "reach" for specific memory blocks or artifacts.

For large payloads, ADK applies a handle pattern. A 5MB CSV or massive JSON response lives in artifact storage, not the prompt. Agents see only lightweight references by default. When raw data is needed, they call LoadArtifactsTool for temporary expansion. Once the task completes, the artifact offloads. This turns permanent context tax into precise, on-demand access.

For long-term knowledge, the MemoryService provides two retrieval patterns:

1) Reactive recall: agents recognize knowledge gaps and explicitly search the corpus.

2) Proactive recall: pre-processors run similarity search on user input, injecting relevant snippets before model invocation. Agents recall exactly the snippets needed for the current step rather than carrying every conversation they've ever had.

All of this reminds me of the tiered approach to Claude Skills, which does improve the efficient use of context in Claude Code.

3) Multi-agent Context

Single-agent systems suffer from context bloat. When building multi-agents, this problem amplifies further, which easily leads to "context explosion" as you incorporate more sub-agents.

For multi-agent coordination to work effectively, ADK provides two patterns. Agents-as-tools treats specialized agents as callables receiving focused prompts without an ancestral history. Agent Transfer, which enables full control handoffs where sub-agents inherit session views. The include_contents parameter controls context flow, defaulting to full working context or providing only the new prompt.

What prevents hallucination during agent handoffs? The solution is conversation translation. Prior Assistant messages convert to narrative context with attribution tags. Tool calls from other agents are explicitly marked. Each agent assumes the Assistant role without misattributing the broader system's history to itself.

Lastly, you don't need to use Google ADK to apply these insights. I think these could apply across the board when building multi-agent systems.

(image courtesy of nano banana pro)

[jeneser @jeneserwang]

I just deployed a high performance cloud server on https://t.co/EY1kzA2Zhi ! #ILoveVultr #Cloud https://t.co/trdgOJyuD5

[Guillaume Chau @Akryum]

Beautiful 😻
https://t.co/DLWbrafWfy

[Daniel Beauchamp @pushmatrix]

A stroller is such a great use case for AR shopping. How big is it? How much space does it take up on a sidewalk? Will it fit in my car?

You have to try this out: https://t.co/ZfMFb3KafV

[Jérémie Patonnier @JeremiePat]

Today's good news: @FirefoxNightly has support for SVG Geometry Properties ! Hell yes! Now you can change x, y, cx, cy, r, rx, ry values through CSS ❤️❤️❤️ https://t.co/MJOxgSeSkP Stable target is @Firefox 69 (late summer) https://t.co/zteANwIrLX 😍😙 /cc @heycam @jwatt

[ruanyf @ruanyf]

MacOS 动态壁纸下载网站，壁纸会随着一天里面的时间不同，自动变换。https://t.co/ZHw9IJBKHs

[jeneser @jeneserwang]

Learn to be a developer that is well versed in programming paradigm and don’t get too hung up or attached to any one thing. Dig deep into architecture structures, designing and developing components, understanding how data flows through...@dottedSquirrel https://t.co/pxTcnVJZgl

[ruanyf @ruanyf]

Chrome 75 将原生支持图片的惰性加载，写成 <img loading=lazy>，就可以滚动到视口加载图片。https://t.co/B8gi36D03k

[Pulumi @PulumiCorp]

Serverless, the Pulumi Way:

⌨️ Real code
⚡️ Event handlers
☁️ Any cloud (AWS, Azure, GCP, K8s)
⚙️ Infrastructure as Code
👥 CD, GitOps, and teams
🤩 Easy and fun
🚫 YAML

Open source, and free to use.

https://t.co/GKa1Yowd65

[jeneser @jeneserwang]

oh，god

[Miguel Ángel Durán @midudev]

¡OJO con @pika/web! 👀⚡️

📦 Instala tus dependencias npm y úsalas directamente en el navegador.
✨ Sin bundlers, ni configuraciones de ningún tipo.
⚡️ Nativo, ESM, optimizado para http2... ¡y MUY rápido!

¡Muy pronto, vídeo más completo y artículo en https://t.co/uc7bPEkbXB 👨‍💻!

[ruanyf @ruanyf]

Let's encrypt 的通配符（wildcard）证书今天上线了。从此，所有子域名开启免费的 HTTPS ，就轻而易举了。https://t.co/QOuANoXRm2

[ruanyf @ruanyf]

CSS 垂直居中的最简单写法：容器元素设为 flex 布局，子元素只要写 margin: auto 即可。（图片 via @bharatramnani94）

[ruanyf @ruanyf]

对于新思想，为什么应该特别关注？

新思想可能会导致新工具，新工具可能会导致新市场，新市场可能会导致人类新的集体行为。由此就会诞生许许多多的机会。

[ruanyf @ruanyf]

许多JS开发者喜欢省略行尾的分号，让引擎自动添加。

现在，TC39委员会正式写入ES6规格：请不要省略分号！一个主要原因是，即将进入规格的 class field 是以分号结尾，省略会有危险。另外，自动添加分号的机制是靠猜的，但软件运行不应该靠猜。https://t.co/Hkg0HocrQB

[ruanyf @ruanyf]

今天，Github 排行榜第一名，是一个梦幻项目。神经网络通过深度学习，自动把设计稿变成 HTML 代码。

作者号称三年后，人工智能彻底改变前端开发。https://t.co/voAdmewFDC

[ruanyf @ruanyf]

不知道大家有没有这个感觉，前端在2017年退烧了。虽然还是发展得很快，但已经不是最热门的领域，行业热点完全转向了人工智能和加密货币。

我相信这将成为常态。UI 问题其实已经解决了，更大的机会将出现在其他领域。UI 工程师还应该掌握其他技能。

[jeneser @jeneserwang]

小熊成长计划第一步: 早睡早起。👻

[ruanyf @ruanyf]

2018年的一大看点，将是 Web USB 技术。

厂商们发现，从此不必为USB硬件提供各种平台的驱动，只需提供JS驱动就可以了。因为浏览器是一个沙盒，硬件在里面做什么都行，不会有安全顾虑。

[jeneser @jeneserwang]

天气大好，晒晒被子，出去走走...