Scar's Blog

未命名

Sun, 20 Sep 2026 10:58:35 +0800

在Auto Research泛滥的当下，扎实地做好每一份工作，目前看来是最高效的做法。

未命名

Sun, 20 Sep 2026 09:16:50 +0800

时间安排不合理的原因：对总任务量以及完成所需时间的错误估计。解决方案：尽可能早地去做。还有什么可以补充的吗？

Casual AI 学习笔记

Sat, 11 Jul 2026 23:03:56 +0800

Causal AI 学习笔记

1. 概念

因果推断

因果推断（Causal Inference）是 Causal AI 最核心的任务。

关联（看到，X→Y 映射）：传统AI能做的，比如“看到冰淇淋销量高，游泳溺水人数也多”。
干预（做）：“推断”精髓。例如，假设“如果我把冰淇淋价格提高一倍，那么溺水人数会下降吗？”——答案是不会，因为它们是温度这个“混杂因子”造成的。Causal AI通过干预计算（do-operator）来剔除虚假相关。
反事实（想象，如果当时）：这是最高级的假设。比如“假设我当时没给这位病人开这个药，他现在会怎样？”——这是传统AI完全做不到的，也是Causal AI最厉害的地方。

因果发现

因果发现（Causal Discovery）指的是，让机器在没有任何“标准答案”的情况下，仅凭一堆历史数据，自己“画”出一张因果关系图（即 DAG 有向无环图）。

如果说“因果推断”是拿着假设去考试（验证“X→Y，X是否影响Y”），那么“因果发现”就是连考卷题目都没有，直接让你从数据海洋里捞知识。它的核心任务是找出变量之间箭头指向的方向（到底是X→Y，还是Y→X）。

MySQL Server MCP 真好用

Sat, 07 Mar 2026 15:36:47 +0800

MySQL Server MCP 真好用

TRAE 的 spec 模式

Sat, 07 Mar 2026 15:29:40 +0800

用 spec 模式，附带详细的接口说明（任务交接文档），能显著提升 AI IDE 的长程任务能力。

现在 TRAE 支持根据 Task 自动创建 Sub Coding Agent 了，总体来说还是比较好用的，偶尔会出现子任务卡死的情况。

/spec 请采用 Java 开发最佳实践，完成这个任务 d:\rightnow-core\docs\rightnow-core-接口设计交接文档.md d:\rightnow-core\docs\rightnow-core-后端接口开发指南.md

Agent Framework Philosophy: The Unbitter Lesson

Sat, 07 Feb 2026 21:22:03 +0800

Agent Framework Philosophy: The Unbitter Lesson

1. Introduction: The Burden of Abstraction

The history of software is a history of abstraction. We build layers to hide complexity, creating frameworks, patterns, and objects that promise to make our lives easier. Yet, in the nascent field of agentic AI, this instinct has led us astray. Early attempts at agent frameworks are replete with complex class hierarchies, managers for every conceivable concept (Memory, Task, Tool), and intricate state machines. They are monuments to premature abstraction.

As Gregor Zunic (Cofounder & CEO of Browser Use) puts it, these frameworks fight the very nature of the intelligence they seek to orchestrate [1]. They fail not because the underlying Large Language Models (LLMs) are weak, but because their rigid structures impose a human-centric view of reasoning onto a non-human intelligence. They encode assumptions that are immediately invalidated by the next model breakthrough.

This document outlines a different philosophy, one derived from first principles and validated by the hard-won lessons of industry pioneers like Anthropic, Manus, and OpenAI [2][3][4]. It is a philosophy of radical simplicity, where we seek not to build an agent, but to unleash one.

2. The First Principle: An Agent is a Loop

If we strip away all the noise, what is an agent? It is a process that perceives, thinks, and acts, in a cycle, to achieve a goal. In the context of LLMs, this translates to an almost trivial implementation:

An agent is just a for-loop of messages. The only state an agent should have is: keep going until the model stops calling tools. You don’t need an agent framework. You don’t need anything else. It’s just a for-loop of tool calls. [1]

This loop is the universal constant of agentic systems. It is the engine. Everything else is just fuel and scenery.

# The irreducible core of an agent
while True:
    response = llm.invoke(context, tools)
    if not response.tool_calls:
        break
    for tool_call in response.tool_calls:
        result = execute(tool_call)
        context.append(result)

Our entire architectural philosophy is built upon the foundation of protecting and empowering this simple loop. We must resist the urge to complicate it.

flowchart TD
    Sandbox -->|provide| Context
    Context --> Agent
    Agent -->|act| Tool
    Tool -->|feedback| Agent
    Agent <-->|handoff by Sandbox| Agent-2

3. The Three Pillars of Simplicity

Our design is guided by three core tenets that emerge from observing what works in practice.

Pillar I: The Sandbox is the World

Instead of creating a multitude of objects to represent the agent’s world (Project, Task, Memory, Files), we unify them into a single, holistic concept: the Sandbox. The Sandbox is an isolated execution environment, typically a virtual machine or container, complete with a file system and the ability to run processes.

This is the most profound simplification. The Sandbox is the state.

Memory is the File System: An agent’s memory is not an abstract class; it is the collection of files within its sandbox. This provides an unlimited, persistent, and directly operable memory that the agent can structure and manage itself, a technique proven effective by Manus [3]. The agent learns to write notes, create logs, and manage data just as a human would.
Context is the Sandbox’s History: The context passed to the LLM is simply the append-only log of what has happened inside the sandbox—a stream of actions and observations.
Projects and Tasks are Implicit: A project is not a database entity; it is a directory in the sandbox. A task is not an object to be managed; it is the initial prompt that kicks off the agent loop.

By unifying the agent’s world into the sandbox, we eliminate dozens of unnecessary classes and the complex interactions between them. The agent interacts with its world not through abstract methods, but through concrete tools like shell and file.

Pillar II: An Agent is a Configuration, Not a Class

Traditional frameworks encourage a deep inheritance model: BaseAgent gives rise to ConcreteAgent, which is then subclassed into SoftwareAgent, ResearchAgent, and so on. This is a fallacy. It conflates an agent’s identity and capabilities with its implementation.

In our philosophy, an Agent is merely a configuration. It is a plain-text or JSON object that defines two things:

Instructions: The system prompt that tells the LLM its role, personality, and objectives.
Tools: A list of capabilities it is allowed to use.

The AgentRunner—the engine that executes the core loop—is stateless. On each iteration, it loads the current agent’s configuration, invokes the LLM, and executes the resulting tool calls. An agent is not an object; it is a mode of operation for the runner.

This approach has powerful implications:

Simplicity: There is no Agent class to maintain. Adding a new agent is as simple as writing a new configuration file.
Flexibility: Agents can be composed, modified, and switched dynamically. Multi-agent collaboration becomes trivial: it is simply one agent using a handoff tool to tell the runner to load a different agent’s configuration on the next loop iteration [4].
Transparency: The agent’s entire
definition is explicit and human-readable, making it easy to debug and understand.

Pillar III: Start with Maximum Capability, Then Restrict

Many frameworks begin by offering a small, “safe” set of tools, forcing the developer to add capabilities one by one. This leads to what has been termed the “incomplete action space” problem [1]. The agent is limited not by the model’s intelligence, but by the developer’s foresight.

We invert this. We start from the assumption that the agent should be able to do anything a human can do within the sandbox. We provide powerful, general-purpose tools from the outset: shell, file, browser. The agent has maximal freedom.

Restrictions are then applied as a layer of safety and guidance, not as a foundational constraint. This is the principle of “Mask, Don’t Remove” articulated by Manus [3]. We don’t take tools away; we temporarily make them unavailable based on the agent’s current state or task, guiding the LLM’s attention without crippling its potential. This ensures the action space remains complete and the KV-cache remains intact, preserving performance and adaptability.

4. Conclusion: The Unbitter Lesson

The bitter lesson of AI research is that general methods that leverage computation ultimately outperform systems based on hand-crafted human knowledge. Agent frameworks are at risk of repeating this mistake by encoding too many assumptions into their design.

By embracing radical simplicity, we learn the unbitter lesson: the most powerful agent framework is the one that gets out of the way. It is a minimal, stateless loop engine operating within a unified sandbox. It treats agents as simple configurations and trusts the LLM to be the intelligent, reasoning core.

This philosophy is not about building less; it is about building right. It is about creating a foundation that is not brittle but resilient, not complex but elegant, and that scales not in spite of, but because of, the relentless advance of AI.

References

[1] Zunic, G. (2026, January 16). The Bitter Lesson of Agent Frameworks. Browser Use Blog. Retrieved from https://browser-use.com/posts/bitter-lesson-agent-frameworks

[2] Schluntz, E., & Zhang, B. (2024, December 19). Building effective agents. Anthropic. Retrieved from https://www.anthropic.com/research/building-effective-agents

[3] Ji, Y. (2025, July 18). Context Engineering for AI Agents: Lessons from Building Manus. Manus Blog. Retrieved from https://manus.im/blog/Context-Engineering-for-AI-Agents-Lessons-from-Building-Manus

[4] OpenAI. (2024). Orchestrating Agents: Routines and Handoffs. OpenAI Cookbook. Retrieved from https://developers.openai.com/cookbook/examples/orchestrating_agents/

Spring AI Extractor 提取器（结构化输出）

Fri, 16 May 2025 13:52:23 +0800

Spring 官方的叫法是结构化输出，不过我更喜欢沿用 LangChain 的叫法“提取器（Extractor）”。

官方文档（Structured Output Converter）

https://docs.spring.io/spring-ai/reference/1.0/api/structured-output-converter.html

package net.heimeng.web.test;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import net.heimeng.common.ai.extractor.ExtractorUtils;
import net.heimeng.web.Agent4jWebApplication;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.core.ParameterizedTypeReference;

import java.util.List;

@Slf4j
@SpringBootTest(classes = Agent4jWebApplication.class)
@DisplayName("AI 单元测试")
public class AiUnitTest {

    @Autowired
    private ChatModel model;

    @DisplayName("AI 配置项测试")
    @Test
    void propertiesTest() {
        // Given
        ChatClient client = ChatClient.builder(model).build();

        // Ensure the client is able to use
        log.debug(client.prompt().user("你好").call().content());

        // Result: 你好👋！我是人工智能助手智谱清言，可以叫我小智🤖，很高兴见到你，欢迎问我任何问题。
    }

    @DisplayName("Extractor 提取器测试")
    @Test
    void extractorTest() {
        // Given
        String textAboutPersons = "蔡徐坤（KUN），1998年8月2日出生于浙江省温州市，" +
                "户籍湖南省吉首市，中国内地男歌手、演员、原创音乐制作人、MV导演。" +
                "朱明春的长子朱立科浙农大毕业三年后，针对温州风俗——家逢喜事分红蛋的习惯，研发出了一鸣利市红蛋，" +
                "深受广大市民的喜爱，成为温州市民办喜事的必需品。之后，朱立科倡导的新型奶吧，" +
                "改变了部分温州人糯米饭加紫菜汤的早餐习惯。该模式一经推出大受温州人欢迎。" +
                "2002年在市区横渎开出第一家一鸣真鲜奶吧直营店，如今，一鸣真鲜奶吧直营店、加盟连锁店在温州地区已发展至近400家。";

        String textAboutActors = "Generate the filmography of 5 movies for Tom Hanks and Bill Murray.";

        List<Person> persons = ExtractorUtils.extract(textAboutPersons, new ParameterizedTypeReference<>() {});
        log.debug(String.valueOf(persons));
        Assertions.assertNotNull(persons);

        Person person = ExtractorUtils.extract(textAboutPersons, Person.class);
        log.debug(person.toString());
        Assertions.assertNotNull(person);

        record ActorFilms(String actor, List<String> movies) {}
        List<ActorFilms> actorFilms = ExtractorUtils.extract(textAboutActors, new ParameterizedTypeReference<>() {});
        log.debug(actorFilms.toString());
        Assertions.assertNotNull(actorFilms);
    }

    @Data
    private static class Person {
        // 私有属性
        private String name;
        private int age;
        private String address;
        private List<String> occupations;
    }
}

package net.heimeng.common.ai.extractor;

import net.heimeng.common.ai.model.WithDescription;
import net.heimeng.common.core.util.SpringUtils;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.core.ParameterizedTypeReference;

import java.lang.reflect.InvocationTargetException;
import java.util.Map;

/**
 * 提取器工具类
 *
 * @author InwardFlow
 */
public class ExtractorUtils {

    private static final ChatClient CLIENT = SpringUtils.getBean(ChatClient.class);
    public static <T extends WithDescription> T extractWithDescription(String text, Class<T> clazz) {
        try {
            T instance = clazz.getDeclaredConstructor().newInstance();
            return CLIENT.prompt()
                    .user(u -> u.text("""
                                    Extract information from:
                                     {text}
                                     ---
                                     Here is the description:
                                     {description}
                                """)
                            .params(Map.of("text", text, "description", instance.getDescription())))
                    .call()
                    .entity(new ParameterizedTypeReference<>() {});
        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
            throw new RuntimeException("Unable to create an instance of " + clazz.getName(), e);
        }
    }

    public static <T> T extract(String text, Class<T> clazz) {
        String className = clazz.getSimpleName();
        return CLIENT.prompt()
                .user(u -> u.text("""
                                    Extract information about {className} from {text}
                                """)
                        .params(Map.of("className", className, "text", text)))
                .call()
                .entity(clazz);
    }

    public static <T> T extract(String text, ParameterizedTypeReference<T> typeReference) {
        return CLIENT.prompt()
                .user(u -> u.text("Extract information from: " + text))
                .call()
                .entity(typeReference);
    }

}

Ubuntu 安装 Genius 数学工具

Fri, 25 Apr 2025 08:49:59 +0800

https://www.jirka.org/genius.html

Genius 是一个通用目的的计算器程序。它既可以用作简单的计算器，也可以用作研究或教育工具。语法非常直观，旨在模仿通常的数学书写方式。

GEL 是它的扩展语言名称，它代表 Genius 扩展语言，真聪明，不是吗？事实上，许多标准的 genius 函数本身就是用 GEL 编写的。

使用 cat /etc/issue 可以查看版本号

1. 确保系统已启用 `universe` 仓库

Ubuntu 22.04+ 后，universe 仓库默认已启用。若确认未启用（或旧版本升级后），执行：

apt update  # 刷新软件源
apt install genius -y

2. 旧版本看这里

# apt update && sudo apt install software-properties-common
add-apt-repository universe
apt update
apt install genius

维吉尼亚 Vigenère 密码

Thu, 24 Apr 2025 18:44:12 +0800

工作原理

本质上，Vigenère 密码是几个凯撒密码，其移位值取决于密钥。它可以通过使用Vigenère 表格简单地手动计算。在代码中，可以使用模算术来实现。

编码
编码时，我们首先将每个字母转换为0到25之间的数字，其中A是0，Z是25。如果密钥比消息短，就将其重复直到它们长度相同，例如，如果消息是cryptography，密钥是secretkey：

msg = cryptography
key = secretkeysec
输出O的第i个字符可以使用以下公式从消息M和密钥K计算得出：

O[i] = (M[i] + K[i]) mod 26
解码
将输出O解码为消息M，已知密钥K，同样简单：

M[i] = (O[i] - K[i]) mod 26

准确率、精确率、召回率

Thu, 17 Apr 2025 10:23:57 +0800

准确率是指分类正确的样本数占总样本数的比例。

精确率是针对预测结果而言的，表示预测为正例的样本中有多少是真正的正例。

召回率是针对原来的样本而言的，表示样本中的正例有多少被预测正确了。

Scar's Blog

未命名

未命名

Casual AI 学习笔记

Causal AI 学习笔记

1. 概念

因果推断

因果发现

MySQL Server MCP 真好用

TRAE 的 spec 模式

Agent Framework Philosophy: The Unbitter Lesson

Agent Framework Philosophy: The Unbitter Lesson

1. Introduction: The Burden of Abstraction

2. The First Principle: An Agent is a Loop

3. The Three Pillars of Simplicity

Pillar I: The Sandbox is the World

Pillar II: An Agent is a Configuration, Not a Class

Pillar III: Start with Maximum Capability, Then Restrict

4. Conclusion: The Unbitter Lesson

References

Spring AI Extractor 提取器（结构化输出）

Ubuntu 安装 Genius 数学工具

1. 确保系统已启用 universe 仓库

2. 旧版本看这里

维吉尼亚 Vigenère 密码

准确率、精确率、召回率

1. 确保系统已启用 `universe` 仓库