Raven911-e/acc

ai agent

[Raven911-e/acc @Raven6667jc]

@Azaliamirh @achowdhery thankyou ，you are so beautiful and talent

[Raven911-e/acc @Raven6667jc]

Top 5 AI Agent Protocols to Know in 2026
https://t.co/i2OuMgigLs
1. MCP
2. A2A
3. AG-UI
4. A2UI
5. ACP

[Raven911-e/acc @Raven6667jc]

@Wuhuoqiu 预测市场不会消失，会一直存在。但目前还是炒热度阶段。

[Wolkan Lee @WolkanLee]

https://t.co/xyvjK7vSvO

[Suraj Sharma @suraj_sharma14]

CANCEL your weekend plans.

You NEED to:

• Build an eval harness that runs before every deploy
• Create golden datasets with 100+ test cases minimum
• Implement LLM-as-a-judge with calibrated scoring
• Add regression detection that blocks bad deploys
• Build accuracy metrics beyond simple exact match
• Track hallucination rate with factuality checks
• Measure grounding quality with citation validation
• Add safety evals for toxic/biased outputs
• Build cost-quality tradeoff curves for model selection
• Implement A/B testing framework for prompt variants
• Add human eval workflow for edge cases
• Track latency percentiles (p50, p95, p99)
• Build dashboards showing quality trends over time
• Add alerting when quality drops below threshold
• Create shadow deployment to test in production safely
• Implement canary releases with automatic rollback
• Build eval reports you can show to stakeholders
• Publish your eval methodology publicly

You have way too much to do.

Bookmark & Repost.

[Amit Shekhar @amitiitbhu]

AI Engineering Interview Questions and Answers

- LLM Fundamentals
- Prompt Engineering
- Retrieval-Augmented Generation (RAG)
- AI Agents and Agentic Systems
- Fine-Tuning and Model Adaptation
- Vector Databases and Embeddings
- AI System Design
- LLMOps and Production AI
- Evaluation and Testing
- AI Safety, Ethics, and Responsible AI
- Multimodal AI
- AI Infrastructure and Scalability
- Coding and Practical Implementation
- Behavioral and Scenario-Based Questions

Learn here: https://t.co/WHqlFfvvL9

[micah @micahomnd]

Lilian Weng @ OpenAI on Harness Engineering

a deep breakdown of harness design patterns, workflow automation, persistent memory via file systems, and how modern agents like claude code actually work. the best blog post I've read all month.

link: https://t.co/k5m2QmmUFc

[Kun Chen @kunchenguid]

if you've been using latest frontier LLMs, it's almost certain that you would have noticed by now the newer models have become worse to talk to

they're more robotic, they speak jargons, they spits out verbose text, and do stuff you didn't ask for

how did that happen? well, i'm not the person who trained those models so i can't speak for certain, but i've known enough evidence that gives me a well-educated guess, and i thought it's interesting to share as a crash course of modern LLM training pipelines

so here we go

let's wind back to 2020. GPT-2 and GPT-3 already came out and were widely available, but they could only predict one token at a time - that's what LLMs are at their core

token prediction was offered via API, but there was nothing you could "talk to". so while it generated a lot of excitement in the academic field due to the emergent intelligence, it didn't have any wide adoption

in 2022, ChatGPT changed all that. the research work that led to ChatGPT was a model initially named "InstructGPT". it took GPT-3 as the intelligent base, and used reinforcement learning with human feedback (RLHF) to teach the models how to "chat"

the core idea of RLHF is that you ask the model to generate a few responses, and then let real humans pick which one they like. do this over and over again, and you get a model that knows how to talk

worth noting even as early as InstructGPT, research found that making the model more pleasant to talk to will reduce their pure academic capabilities. this was called "alignment tax", which is an interesting thing we'll come back to in a bit

there were various techniques done to minimize the reliance on humans, but ultimately the reward is modeled after human preference, making these AI assistants easy to talk to

so remember this: RLHF = training the model to be likable by humans

in 2024, there was an inflection point introduced by claude sonnet 3.5 which was the first model that can kind of autonomously finish coding tasks. it led to the first wave of viable "coding agents"

the way sonnet 3.5 achieved this was by training the model with a harness (now it's called an agent) that has bash and file editing tools, throw the agent into a virtual machine, give it a task, and let it try to complete it. these tasks all have a machine-verifiable outcome predefined, mostly via test cases, that can validate whether the model really finished the task or not

then you let the model do billions and billions of attempts in such virtual environments, and some of them would succeed by chance. you keep the successful agent sessions, and use reinforcement learning to teach the model to do that more, and boom - you get a coding agent

that is called reinforcement learning with verifiable rewards (RLVR). if you look closely, you'll see that in this RLVR process, the final text response from the model doesn't matter AT ALL, as long as the code written by the agent could pass the test. it could talk like a jerk and it would still be rewarded

so remember this: RLVR = training the model to be accepted by machines

late 2024 and early 2025, we saw o1 and deepseek R1 came out as the first wave of "reasoning models". this article is getting long so i'm not diving into reasoning models now, but just know that reasoning models also relied heavily on RLVR to scale the training process - let the model think before taking action, and if the thinking led to a machine verifiable outcome, reward the thinking trace and teach the model to think like that more often

the biggest difference between RLVR and RLHF is that RLVR is more scalable. human feedback is expensive to get, especially in domains where only an expert can have a valid opinion on which result is good

with RLHF, if we let the model generate 100 responses, then a human has to review all 100 responses to pick which is good

with RLVR, the human (or sometimes an AI) would define a task and verifier only once, and the model can generate a million responses - the machine verifier will pick which responses are good in an automated way

so as a result, RLVR is becoming more and more dominant in newer models' training pipeline

if you put all these things together:
- RLHF = training the model to be likable by humans
- RLVR = training the model to be accepted by machines
- RLVR is more scalable
- "alignment tax" says "likable by humans" makes the model do worse on verifiable tasks

now you see why the newer models are becoming less and less likable?

this is not just a "frontier labs screwed up their model training" problem - this is a war between machines and humanity, and humanity is losing

we chased after benchmarks, when none of the benchmarks measure whether humans actually enjoy working with the model

we use machines to decide which AI response is better because that's easier and cheaper, when we have no way of making sure those machines actually represent what we humans want

we let AI go dark in a virtual environment on its own and complete predefined tasks at all costs, when in reality we often cannot define a verifiable outcome upfront, and need AI to work with us along the way

i don't have a good solution to this, but i want to call for awareness that we're starting to witness a failure in aligning super intelligence right in front of our eyes

this war between machines vs humanity is one we really can't afford to lose

[Adrian Punk @AdrianPunk115]

https://t.co/NNKlhYJJrv

[goldengrape @goldengrape]

《不止于回答：AI Agent 与科学哲学》
上篇：Agent 基础与多 Agent 协作
https://t.co/hZUZyCLx9P

中篇：科学协作的机制与协议
https://t.co/oG8LqDJzWU

下篇：共同体的记忆、进化与未来
https://t.co/5MlEq5b8XY

[Raven911-e/acc @Raven6667jc]

@nihui 请求通过 喵

[Raven911-e/acc @Raven6667jc]

@jessyshen 哥问一个问题，需要埃及支付通道是做什么的业务

[山景城小路 @Zen_with_AI]

最近越来越觉得：

AI 真正的竞争，很可能已经不是模型，而是 Harness。

如果把 Harness 看成 AI 的操作系统（OS），很多东西一下就想通了。

模型（LLM）越来越像 CPU。

真正决定 Agent 上限的，不再只是模型，而是 Harness。

未来 Harness 至少要解决六件事：

1. Process Management（进程管理）
不是 Multi-Agent，而是真正的进程调度。
Sub-agent = Process，有创建、调度、暂停、恢复、Checkpoint、资源配额、失败重试。

2. File System（文件系统）
Context 是内存，File System 才是磁盘。
长期知识、实验记录、代码、日志都应该落盘，而不是永远塞进 Context。

3. Memory Management（内存管理）
Context Engineering，本质就是内存管理。
什么时候摘要？什么时候换页（Paging）？什么时候重新加载？
未来比拼的可能不是谁 Context 更长，而是谁的 Memory Manager 更聪明。

4. Device Drivers（设备驱动）
MCP、Tool、Skill，就是 AI 世界的驱动程序。
模型无需关心底层是 Browser、Shell 还是 Database，只面对统一接口。

5. Networking（网络）
Agent 与 Agent、Agent 与 Tool、Agent 与 Human，都需要标准通信协议，而不是 Prompt 互相喊话。

6. Security（安全）
Capability、Sandbox、Audit Log、Permission……
未来最重要的问题不是 Agent 能做什么，而是不能做什么。

过去十几年，软件工程围绕的是 Cloud Runtime。
未来十年，软件工程可能会围绕 Agent Runtime（Harness） 展开。
真正的竞争，不只是哪个模型更强，而是谁能做出 AI 世界的 Linux。
LLM 提供 Intelligence。

Harness 提供 Runtime。

[Raven911-e/acc @Raven6667jc]

@paulg it‘s about logic

[siddontang @siddontang]

最近一直在做 TiDB Filesystem，也在思考怎么基于 filesystem 构建 Agent Memory。

实践下来发现：
把 memory 存下来不难。
难的是，让 Agent 在正确的时候，想起正确的事。
Corner case 一多，Agent 很快就会“记忆错乱”——这点很像写完代码三个月后的程序员。

最近读到一篇 paper：
Filesystem-Based Memory for LLM Agents: Organization, Evolution, and Sustainability，https://t.co/IBiGk3DUcv

里面有个很有意思的结论：
组织良好的文件，可以把检索成本降低近一半，但不会自动提升回答质量。

所以：
有 filesystem，不等于有 memory system。
真正困难的是：
写入、修订、遗忘、权限、审计和回滚。

Filesystem is the interface.
Memory is the lifecycle.

这也是 TiDB Filesystem 在做的事情：
让存进去的文件自动带上 database semantics——可检索、可版本化、可审计、可回滚。

不只是多一个目录，而是让文件真正成为 Agent 可以长期依赖的 memory。

[Charles在路上 @Charles77xixi]

最近总看到有人说要写一个自己的 agent，但我想了一下，对大部分个人使用来说， 你并不需要造一个自己的Agent，你只需要让你的Agent足够的私有化、定制化。

Claude Code 和 Codex 这种 Agent 背后是一整个顶尖团队在持续研发的产品，你一个人从头做一个 agent，做出来绝对不如它们，还得自己维护。

大部分人说想要自己的 Agent，真实的诉求是希望手上的Agent用起来更顺、更懂自己，至于它是谁做的其实无所谓。

这个诉求完全成立，但它指向的并不是 agent 本身。一个 agent 到底由什么构成：模型、工具调用循环、交互界面。这三样里没有一样是能够私有化的地方，它们是通用能力。

想让Agent变得更加私有化，真正需要改动的地方反而在外置的可插拔层：数据、规则、skill等等，而不是Agent本身，并且这些可插拔层在技术层面上可以在不同的Agent框架上切换。

1、数据层

你的知识库、笔记、历史决策、真实账户、真实经验，本质上都是你这个人的各类知识和判断在文本层面的投影。

大模型训练的数据本身就只是网络公开数据，通过这些数据训练出来的模型永远只会以共识来回答问题。只有拿到了足够多的私有数据，Agent才能够私有化和定制化

而且数据层不是仅仅把文件堆着就行，它的组织结构需要为被Agent读重新组织一次。

2、工具层

主要是 Skills\MCP\CLI等等，主流 agent 基本都支持这几种工具，你配好一次可以在好几个地方用。

我本地一共有五十多个这样的常用工具，从写作、去 AI 味、封面生成，到发帖前的自检门、账号数据复盘，都是把我反复要做的事固化成了skill。

MCP\CLI 接的是微信读书、日历、项目管理这类外部数据源对外提供的能力。

这里得说句实话，工具层的跨Agent复用会比数据层更麻烦一些。我的 skill 源目录是一份，但要手动软链到三个不同 agent 的目录下，还专门写了个同步脚本，各家对 skill 的加载时机、参数传递、权限模型都有差异，能用不等于零摩擦。

3、规则和流程

这一层才是差距真正拉开的地方。

我有两个全局规则文件，一个管全局怎么干活，七十多行；一个管知识库怎么找东西，五十多行。除此之外还有一套固定流程：出计划、审计划、执行、审结果，每个环节谁来做、什么时候必须停下来复查，都写死了。

发推文也有一套，写之前先过一遍不该发的清单，写完再过一遍发帖前的四个问题，两道门都过了才进草稿箱。

这些东西属于第三类，作用是约束和编排，它不决定 agent 能做什么，但能决定它不做什么。

我的体感是，同样一个 Agent，有rule层和没rule层的体感差别是很大的。

回到开头那个矛盾，我不建议你造 agent，但你确实应该让你的 agent 足够的定制化和私有化，把通用 agent变成私有 agent。

[Raven911-e/acc @Raven6667jc]

CC founder suggests: Clear CLAUDE.md, Skills and hooks every six months.
The accumulation of old skills will continue to burn tokens. After model iteration, most skills are no longer useful. Regular subtraction is necessary to reduce costs and release the model's capabilities

[SCR @SCR01111]

10 YouTube Resources Every AI / LLM Engineer Should Bookmark 📌

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. Andrej Karpathy — Neural Networks: Zero to Hero
https://t.co/0JzLsj5uGW

Best for:
• Neural Networks
• Backpropagation
• GPT from Scratch
• Tokenizers
• Transformers

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

2. https://t.co/CmLFBHy8lC

https://t.co/GgRKdD4BZB

Best for:
• Prompt Engineering
• RAG
• AI Agents
• LangChain
• OpenAI APIs

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

3. Hugging Face

https://t.co/L86nWnzxcU

Best for:
• Transformers
• Fine-Tuning
• Tokenizers
• Open Source LLMs
• Inference

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

4. LangChain

https://t.co/on2gYaJCr7

Best for:
• AI Agents
• LangGraph
• RAG
• Multi-Agent Systems
• MCP

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

5. AI Jason

https://t.co/Uwvj6v5nGo

Best for:
• AI Agents
• MCP
• LLM Apps
• OpenAI SDK
• Automation

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

6. AssemblyAI

https://t.co/NaeETDfOT2

Best for:
• Production AI
• Voice AI
• RAG
• LLM Applications
• AI Engineering

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

7. Sam Witteveen

https://t.co/073SAwgF7Z

Best for:
• LangChain
• LlamaIndex
• RAG
• Agents
• Vector Databases

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

8. IBM Technology

https://t.co/lX4OBsUjBw

Best for:
• Transformers
• Embeddings
• Vector Databases
• AI Concepts
• Enterprise AI

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

9. 3Blue1Brown

https://t.co/Jd8WgfNzoa

Best for:
• Linear Algebra
• Neural Networks
• Deep Learning Mathematics
• Attention Intuition

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

10. Microsoft Developer

https://t.co/krWCaxl62j

Best for:
• Azure AI
• Semantic Kernel
• AI Agents
• Copilot
• Enterprise LLM Development

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Learning Order

1. 3Blue1Brown
↓
2. Andrej Karpathy
↓
3. Hugging Face
↓
4. https://t.co/CmLFBHy8lC
↓
5. LangChain
↓
6. Sam Witteveen
↓
7. AI Jason
↓
8. AssemblyAI
↓
9. IBM Technology
↓
10. Microsoft Developer

Bookmark this.

These resources take you from AI fundamentals to building production-ready LLM applications.

[Raven911-e/acc @Raven6667jc]

@Xudong07452910 就像人新陈迭代一样，根据现有的memory 再根据过去的memory 重新整合新的memory

[Raven911-e/acc @Raven6667jc]

The code then passed all tests after execution.
Now I’d like to ask you: Why did the tests pass? What flaws might exist in the tests that tricked the AI (and even human developers)?

[Raven911-e/acc @Raven6667jc]

Suppose there is a function designed to "calculate the discounted total price of an array". The original bug caused the program to crash when an empty array was encountered. AI fixed the bug by adding just one line of code that only handles the single scenario of an empty array.