AI Agent on ByF (BaiFan) · Daily Deep Think

Multi-Agent Collaboration: Value From Structure, Not Concurrency

blog@baifan.site (ByF (BaiFan)) — Wed, 12 Aug 2026 14:33:59 +0800

Conclusion first: the value of multi-agent doesn’t come from more models; it comes from the right structure. Multi-agent without structure is just more expensive concurrency — burn 2 to 3 times the tokens to watch a group of models nod at each other. Multi-agent with structure is an execution system that can delegate, parallelize, and verify.

Why a Single Agent Fails at Long Tasks
#

Diagnosis first. A single agent executing complex tasks has five structural defects — blame the execution structure, not the model’s intelligence:

Give AI a Rulebook: From Wishing Upon It to Making It Behave

blog@baifan.site (ByF (BaiFan)) — Wed, 05 Aug 2026 14:28:39 +0800

Let me start with something that actually happened.

In early 2025, I added a feature to an internal system: export to Excel. Small requirement — I didn’t even write it up, just typed “add an export button to the list page” into the chat box.

The AI delivered in ten minutes. Frontend changes, new endpoint, SQL — all in one pass. I was pleased when I opened the PR, right up until review revealed: the export columns didn’t match the list page, a hundred thousand rows would hang the service outright, there was no permission check, and the tests only covered the happy path.

Thoughts on Dynamic Intervention in AI Agent Runtimes

blog@baifan.site (ByF (BaiFan)) — Mon, 27 Jul 2026 14:00:00 +0800

Thoughts on Dynamic Intervention in AI Agent Runtimes
#

A few weeks ago, late at night, I stared at the agent logs scrolling through my terminal, frustrated enough to want to smash the keyboard. It was dutifully generating a requirements analysis report — it had been running for a dozen-plus minutes, pulling loads of data and drawing charts, clearly on the verge of wrapping up — when I suddenly realized the requirements were missing a key dimension: “Don’t split by region, split by user age group.” If I interrupted it now, all the context, intermediate results, and tool call state would be thrown away and it would start over. If I didn’t, it would soon produce a wrong report that would cost me just as long to fix by hand.

AI Agent Skills and MCP: Which Ones Are Worth Installing

blog@baifan.site (ByF (BaiFan)) — Mon, 20 Jul 2026 14:00:00 +0800

Conclusion first: plenty of tools out there can be installed, but most of them sit there gathering dust after installation. Below is what I filtered out of the things I actually use, sorted into five scenario categories, with a few genuinely used picks in each.

First, One All-Rounder Recommendation
#

If you want a single install that covers most scenarios, take a look at this one:

The Future of AI Coding Tools: From Copilot to Autonomous Agent

blog@baifan.site (ByF (BaiFan)) — Mon, 06 Jul 2026 09:00:00 +0800

Twelve articles, from the Think-Act-Observe loop all the way down into the 500,000-line engineering abyss. Now, standing at the end of the series and looking back over the whole evolutionary path, a bigger question surfaces:

What will AI coding tools ultimately evolve into?

A better Copilot? A more powerful IDE plugin? Or something new that we haven’t named yet?

Three Evolutionary Paths
#

Looking back at the development of AI coding tools, you can see three clear stages of evolution:

3,000 vs 500K Lines: The Architectural Abyss From Toy to Product

blog@baifan.site (ByF (BaiFan)) — Thu, 02 Jul 2026 09:00:00 +0800

The claude-code-from-scratch project implements a “mini Claude Code” in roughly 3,000 lines of TypeScript. It has the Think-Act-Observe loop, a tool system, a system prompt, permission control, memory, Skills, multi-agent, MCP — every core concept we tore down over the previous ten posts.

And the official Claude Code source? Roughly 500K lines of TypeScript/TSX.

That’s a 100x+ gap between 3,000 lines and 500K. What’s in it?

The gap isn’t “number of features”. from-scratch already covers every core concept. The gap is the road each concept travels from “it runs” to “it’s usable” — that road is called productionization.

The Discrete State Machine of Plan Mode: Decision Tree Pruning, Backtracking Costs, and Diminishing Returns

blog@baifan.site (ByF (BaiFan)) — Tue, 16 Jun 2026 09:00:00 +0800

Autoregressive large language models operating in unconstrained environments suffer from an inherent tendency toward myopic mutation and runaway divergence. Claude Code’s Plan Mode attaches an external discrete Finite State Machine (FSM) that projects the action space onto a strictly side-effect-free subset, using an interactive human barrier to prune catastrophic physical backtracking branches from the decision tree.

In disciplined software engineering, experienced developers instinctively value structural planning: mapping dependency graphs, deriving type signatures, and scoping blast radiuses before modifying a single line of code. Large language models possess no such innate restraint. Shaped by reinforcement learning to generate immediate answers, an agent granted unrestrained write permissions will instinctively mutate files without global context, precipitating an architectural cascade across complex repositories.

The MCP Protocol: USB-C for AI Tool Interconnection

blog@baifan.site (ByF (BaiFan)) — Fri, 12 Jun 2026 09:00:00 +0800

Before MCP, every AI tool integration was a custom build. Want ChatGPT to reach a database? Write a plugin. Want Claude to call the GitHub API? Write a Function Calling definition. Want Copilot to access your internal systems? Write a Custom Tool.

Every time, the same thing: define an interface, write adapter code, handle auth, manage errors. The wheel, reinvented countless times.

The problem MCP (Model Context Protocol) solves is simple: give AI agents a standard protocol for connecting tools. Just as USB-C gave electronic devices a universal connector, MCP gives AI agents a universal tool interface.

Multi-Agent Architecture: The Art of Fork-Join Collaboration

blog@baifan.site (ByF (BaiFan)) — Tue, 09 Jun 2026 09:00:00 +0800

There’s a counterintuitive phenomenon: take the same model, split it into multiple independent instances, and have them collaborate — the result is often better than a single instance.

Not more compute (three instances burn more total tokens than one), not more capability (every instance is the same model). The gain comes from role separation — when each agent attends to only one facet of the problem, it works with more focus and more depth than a “do-everything agent”.

The Nature of Skills: Reusable Encapsulated Expertise

blog@baifan.site (ByF (BaiFan)) — Fri, 05 Jun 2026 09:00:00 +0800

If you’ve used Claude Code, you may have noticed the /skills command listing installed “skills”. Writing standards, architecture design methods, TDD workflows, code review strategies — it sounds like a plugin marketplace.

Skills are not plugins.

That’s the first and most important thing to understand about the Skill system. A plugin is code — it extends what the program can do. A Skill is a prompt — it extends what the model knows.

AI Memory Systems: Four Memory Types and Semantic Recall

blog@baifan.site (ByF (BaiFan)) — Tue, 02 Jun 2026 09:00:00 +0800

Last time we covered context compaction — solving “how much the current session can remember”. But a coding assistant needs another kind of memory: long-term memory across sessions.

You close Claude Code and reopen it tomorrow. What should it know?

You prefer TypeScript over JavaScript
You said last time “don’t use the underscore library”
This project uses Vitest, not Jest
You once corrected one of its misunderstandings

Context compaction can’t handle these. The session ends, the history clears, tomorrow is a fresh window. If the AI needs you to re-explain everything each time, it isn’t an assistant — it’s a burden.

The Physical Cost of Context Compression: KV Cache Pressure, Attention Decay, and Lossy Summarization

blog@baifan.site (ByF (BaiFan)) — Sat, 23 May 2026 09:00:00 +0800

Large language models possess no biological memory at the hardware tier; they operate entirely on Key-Value Caches that scale linearly in GPU High-Bandwidth Memory (HBM) alongside attention weight distributions that mathematically dilute as sequence length grows. The notion of long-horizon conversations presented by Claude Code is, at its engineering core, an eviction and compaction pipeline operating within the tight margins of memory capacity and numerical precision, trading away information entropy and prefix caching efficiency.

Permissions and Real Security Boundaries: Sandboxes, System Calls, and Approval Escape

blog@baifan.site (ByF (BaiFan)) — Wed, 20 May 2026 09:00:00 +0800

Any AI agent permission system running in userspace that relies on model self-discipline and application-level regex filtering does not constitute an enforceable security boundary from the perspective of the operating system kernel. Claude Code’s 5-level permission model and interactive approval workflow operate as flow-control protocols to mitigate developer mistakes, lacking sandbox containment against adversarial attacks.

Granting an AI coding assistant filesystem write access and terminal execution rights under the belief that confirmation prompts preserve a safety perimeter is a fundamental category error. Confusing interactive human approval with privileged access control collapses into a cosmetic barrier when confronted with supply-chain poisonings, indirect prompt injections, and shell parser differentials.

System Prompt Engineering: Decisions Behind 800 Lines

blog@baifan.site (ByF (BaiFan)) — Sat, 16 May 2026 09:00:00 +0800

If you think a system prompt is just “giving the AI a persona”, Claude Code’s system prompt will upend that notion.

It isn’t a few sentences. It’s a thousand-line template engine made of multiple layers, each responsible for something different: identity definition, behavioral constraints, tool documentation, project context, memory injection, skill loading. Some layers are static (identical every time); others are dynamic (injected in real time based on the project, the session, user preferences).

Tools Are Capability: AI Agent Tool System Design Philosophy

blog@baifan.site (ByF (BaiFan)) — Tue, 12 May 2026 09:00:00 +0800

Last time we talked about the Think-Act-Observe loop — the skeleton of an AI coding assistant. A skeleton can’t work on its own; it needs muscle. In Claude Code, that muscle is tools.

Without tools, the loop loses the Act between Think and Observe and degenerates into plain Q&A. With tools, the model can touch the real world: read your code, change your configs, run your tests.

The Soul of an AI Coding Assistant: The Think-Act-Observe Loop

blog@baifan.site (ByF (BaiFan)) — Thu, 07 May 2026 09:00:00 +0800

If you dig through the Claude Code source, you will discover a counterintuitive fact:

The core of the entire program is a while loop.

Not a complex state machine, not an elaborate pipeline, not distributed coordination — just a plain while loop that does three things over and over: let the model think, let the model act, feed the results back.

1
2
3
4
5
6
7
8
9


while (user hasn't quit) {
 thinking = callLLM(conversation history + tool definitions)
 if (thinking.wants to call a tool) {
 result = executeTool(thinking.toolCall)
 conversationHistory.push(result)
 } else {
 output(thinking.reply)
 }
}

That’s it? The entire secret of an AI coding assistant lives in this loop?

Reverse Engineering Claude Science: From 54 Tables to Modern TCM

blog@baifan.site (ByF (BaiFan)) — Fri, 20 Feb 2026 14:00:00 +0800

A 67 MB DMG installer, 164 MB unpacked, hiding Anthropic’s Claude Science (internal codename Operon). After reverse engineering it, I found 54 SQLite tables, a 9-layer security model, 30+ bioinformatics skills, and a complete AI agent platform for computational biology.

On the other side is TCMSP, an AI-native Traditional Chinese Medicine systems pharmacology platform under active development. Looking at the two projects side by side, some design ideas are worth cross-referencing.

TencentDB Agent Memory: Real Layered Memory for AI Agents

blog@baifan.site (ByF (BaiFan)) — Tue, 03 Feb 2026 14:00:00 +0800

Why AI Agents Need a Memory System
#

If you’ve spent serious time with AI agents, these scenarios will feel familiar:

Re-explaining the project background, coding conventions, and output format preferences in every new session
Halfway through a long task, the context fills up with tool logs and the agent starts “forgetting” earlier instructions
Wanting the agent to learn your working habits, but having no way to do it except hand-writing a system prompt every time

Memory isn’t about making the AI store everything — it’s about making sure humans never have to repeat themselves. That’s the core idea behind TencentDB Agent Memory.

Claude Skills Progressive Disclosure via MCP: Skill in Anywhere

blog@baifan.site (ByF (BaiFan)) — Fri, 26 Dec 2025 14:00:00 +0800

Claude Code Skill in Anywhere

Implementing Claude Skills’ Progressive Disclosure via MCP: Reusing Claude Code Skills Anywhere
#

— A feasible approach to capability encapsulation and dynamic context extension (technical proposal and verification)
#

Preface
#

Claude Skills introduced a remarkably advanced concept: encapsulating professional knowledge, process standards, and task methods into “skill packages” that load dynamically, only when a task actually needs them.