Giá cổ phiếu Anthropic (ANTHROPIC) hôm nay—Biểu đồ và báo giá thời gian thực

Q: Mức giá cao nhất và thấp nhất trong 52 tuần của Anthropic (ANTHROPIC) là bao nhiêu?

ANTHROPIC đạt mức cao nhất trong 52 tuần là ₫0 và mức thấp nhất trong 52 tuần là ₫0, với giá hiện tại là ₫0.

Q: Tỷ lệ giá trên thu nhập (P/E) của Anthropic (ANTHROPIC) là bao nhiêu? Nó chỉ ra điều gì?

Tỷ lệ P/E hiện tại (TTM) của ANTHROPIC là 0, cho biết nhà đầu tư trả bao nhiêu cho mỗi đô la lợi nhuận. Tỷ lệ P/E cao hơn thường phản ánh kỳ vọng tăng trưởng mạnh mẽ hơn, trong khi tỷ lệ P/E thấp hơn có thể cho thấy định giá hấp dẫn hơn hoặc tốc độ tăng trưởng chậm hơn. So sánh với tỷ lệ P/E trung bình của ngành -- để có bối cảnh tốt hơn.

Q: Vốn hóa thị trường của Anthropic (ANTHROPIC) là bao nhiêu?

Anthropic (ANTHROPIC) hiện đang có vốn hóa thị trường khoảng ₫0.

Q: Lợi nhuận trên mỗi cổ phiếu (EPS) hàng quý gần đây nhất của Anthropic (ANTHROPIC) là bao nhiêu?

Thu nhập trên mỗi cổ phiếu pha loãng (EPS pha loãng) của Anthropic (ANTHROPIC) là --. EPS = Thu nhập ròng / Tổng số cổ phiếu pha loãng, đây là một chỉ số quan trọng để đo lường khả năng sinh lời của công ty.

Q: Bạn nên mua hay bán Anthropic (ANTHROPIC) vào thời điểm này?

Hiện tại, ANTHROPIC đang giao dịch ở mức ₫0, với tỷ lệ P/E là 0 và EPS pha loãng là --. Quyết định mua hoặc bán của bạn nên dựa trên mục tiêu đầu tư và khả năng chấp nhận rủi ro. Chúng tôi khuyên bạn nên đưa ra đánh giá tổng thể bằng cách xem xét báo cáo tài chính của Anthropic, triển vọng của ngành -- và các khoản đầu tư của riêng bạn. Đầu tư luôn tiềm ẩn rủi ro—vui lòng đưa ra quyết định một cách thận trọng.

Q: Những yếu tố nào có thể ảnh hưởng đến giá cổ phiếu Anthropic (ANTHROPIC)?

Các yếu tố chính bao gồm: báo cáo hàng quý của công ty (doanh thu, EPS), cạnh tranh và xu hướng trong lĩnh vực --, môi trường kinh tế vĩ mô (lãi suất, lạm phát), tâm lý thị trường, cũng như các sự kiện lớn như ra mắt sản phẩm và sáp nhập & mua lại.

Q: Làm thế nào để mua cổ phiếu Anthropic (ANTHROPIC)?

Bạn có thể mua Anthropic (ANTHROPIC) thông qua Gate. Đăng ký tài khoản Gate và hoàn tất xác minh danh tính, sau đó truy cập trang giao dịch Anthropic để mua. Gate hỗ trợ giao dịch cổ phần phân đoạn, vì vậy bạn có thể bắt đầu đầu tư mà không cần mua toàn bộ cổ phần.

₫0

+₫0(0,00%)

Không có dữ liệu

*Dữ liệu cập nhật lần cuối: 2026-05-02 06:26 (UTC+8)

Tính đến 2026-05-02 06:26, Anthropic (ANTHROPIC) đang giao dịch ở ₫0, với tổng vốn hóa thị trường là --, tỷ lệ P/E là 0,00 và tỷ suất cổ tức là 0,00%. Giá cổ phiếu hôm nay biến động trong khoảng ₫0 và ₫0. Giá hiện tại cao hơn 0,00% so với mức thấp nhất trong ngày và thấp hơn 0,00% so với mức cao nhất trong ngày, với khối lượng giao dịch là --. Trong 52 tuần qua, ANTHROPIC đã giao dịch trong khoảng từ ₫0 đến ₫0 và giá hiện tại cách mức cao nhất trong 52 tuần 0,00%.

Các chỉ số chính của ANTHROPIC

Tỷ lệ P/E0,00

Lợi suất cổ tức (TTM)0,00%

Số cổ phiếu đang lưu hành0,00

Thịnh hành

Tìm hiểu thêm về Anthropic (ANTHROPIC)

Bài viết Gate Learn

72 giờ khủng hoảng nhận diện thương hiệu của Anthropic

Chỉ trong vòng bảy mươi hai giờ, Anthropic đã phải đối mặt với tối hậu thư từ Lầu Năm Góc, cáo buộc công khai của Elon Musk và việc tự rút lại các cam kết an toàn. Từ việc kiên quyết không phát triển vũ khí quân sự tự động đến điều chỉnh RSP 3.0 và từ bỏ ranh giới "tạm dừng đào tạo", công ty vốn được xem là dẫn đầu về "AI an toàn" này đang phải đối diện với khoảng cách ngày càng lớn giữa thương hiệu và thực tiễn vận hành. Bài viết này phân tích các động lực chính trị, áp lực về định giá cũng như sự sụp đổ của câu chuyện ưu tiên an toàn đã tạo ra cuộc khủng hoảng nhận diện cho Anthropic.

2026-03-05

Anthropic "Cắt đứt" Windsurf, Lập trình AI Trở Thành "Chiến tranh Ủy nhiệm" Giữa Các Gã Khổng Lồ AI

Việc OpenAI mua lại nền tảng lập trình AI Windsurf đã gây xôn xao trong ngành, trong khi việc Anthropic ngừng cung cấp mô hình Claude cho Windsurf đã làm gia tăng thêm sự cạnh tranh trên thị trường.

2025-06-11

Rò rỉ mã nguồn Claude Code: Phân tích về ngành chuyên sâu—Tầm nhìn của Anthropic vượt xa khuôn khổ của một trợ lý lập trình AI thông thường

Sự cố rò rỉ mã nguồn Claude Code không chỉ đơn thuần là một sai sót kỹ thuật mà còn hé lộ sớm chiến lược sản phẩm của Anthropic: vận hành nền, thực hiện tự động, phối hợp đa tác nhân và tự động hóa quyền truy cập. Bài viết này đánh giá, từ góc nhìn ngành, những định hướng có khả năng Anthropic sẽ phát triển với Claude Code.

2026-04-02

Câu hỏi thường gặp về Anthropic (ANTHROPIC)

Giá cổ phiếu Anthropic (ANTHROPIC) hôm nay là bao nhiêu?

Anthropic (ANTHROPIC) hiện đang giao dịch ở mức ₫0, với biến động 24h qua là 0,00%. Phạm vi giao dịch 52 tuần là từ ₫0 đến ₫0.

Mức giá cao nhất và thấp nhất trong 52 tuần của Anthropic (ANTHROPIC) là bao nhiêu?

Tỷ lệ giá trên thu nhập (P/E) của Anthropic (ANTHROPIC) là bao nhiêu? Nó chỉ ra điều gì?

Vốn hóa thị trường của Anthropic (ANTHROPIC) là bao nhiêu?

Lợi nhuận trên mỗi cổ phiếu (EPS) hàng quý gần đây nhất của Anthropic (ANTHROPIC) là bao nhiêu?

Bạn nên mua hay bán Anthropic (ANTHROPIC) vào thời điểm này?

Những yếu tố nào có thể ảnh hưởng đến giá cổ phiếu Anthropic (ANTHROPIC)?

Làm thế nào để mua cổ phiếu Anthropic (ANTHROPIC)?

Cảnh báo rủi ro

Thị trường chứng khoán tiềm ẩn rủi ro cao và biến động giá mạnh. Giá trị khoản đầu tư của bạn có thể tăng hoặc giảm, và bạn có thể không thu hồi được toàn bộ số tiền đã đầu tư. Hiệu suất hoạt động trong quá khứ không phải là chỉ báo đáng tin cậy cho kết quả tương lai. Trước khi đưa ra bất kỳ quyết định đầu tư nào, bạn nên đánh giá cẩn thận kinh nghiệm đầu tư, tình hình tài chính, mục tiêu đầu tư và khả năng chấp nhận rủi ro của mình, đồng thời tự mình nghiên cứu. Nếu cần thiết, hãy tham khảo ý kiến của một cố vấn tài chính độc lập.

Tuyên bố từ chối trách nhiệm

Nội dung trên trang này chỉ được cung cấp cho mục đích thông tin và không cấu thành tư vấn đầu tư, tư vấn tài chính hoặc khuyến nghị giao dịch. Gate sẽ không chịu trách nhiệm đối với bất kỳ tổn thất hoặc thiệt hại nào phát sinh từ các quyết định tài chính đó. Hơn nữa, xin lưu ý rằng Gate có thể không cung cấp đầy đủ dịch vụ tại một số thị trường và khu vực pháp lý nhất định, bao gồm nhưng không giới hạn ở Hoa Kỳ, Canada, Iran và Cuba. Để biết thêm thông tin về các Khu vực bị hạn chế, vui lòng tham khảo Thỏa thuận người dùng.

Thị trường giao dịch khác

ANTHROPIC_USDT

Vĩnh cửu

Giao dịch

Tin tức mới nhất về Anthropic (ANTHROPIC)

2026-05-02 01:21

Lầu Năm Góc ký các thỏa thuận AI với 8 công ty, loại Anthropic khỏi quyền truy cập mạng cấp độ bí mật

Theo Beating News, Lầu Năm Góc đã công bố các thỏa thuận với 8 công ty công nghệ nhằm triển khai công cụ và hạ tầng AI của họ trên các mạng lưới cấp độ bí mật quân sự của Mỹ (IL6) và tuyệt mật (IL7). Các công ty mới ký kết bao gồm Nvidia, Microsoft, AWS, Reflection AI, cùng với xAI, OpenAI, Google và Oracle vốn đã được ký hợp đồng trước đó. Tất cả các bên ký kết đều đồng ý cho phép Lầu Năm Góc sử dụng công nghệ của họ cho “mọi mục đích hợp pháp”. Anthropic bị loại khỏi danh sách, dù Claude là mô hình ngôn ngữ lớn duy nhất của Lầu Năm Góc trong các môi trường được phân loại. Theo The New York Times, dẫn nguồn tin, ít nhất một số công ty mới được ký kết đã tư nhân nhận các biện pháp bảo đảm tương tự như các yêu cầu của Anthropic, nhằm hạn chế việc sử dụng trong vũ khí tự động và giám sát trong nước.

2026-05-01 02:09

Anthropic Mở bản beta bảo mật Claude cho người dùng doanh nghiệp vào ngày 1 tháng 5

Theo BlockBeats, vào ngày 1/5, Anthropic đã thông báo rằng Claude Security, một công cụ bảo mật mã nguồn, đã mở đăng ký thử nghiệm beta công khai cho người dùng Claude Enterprise. Công cụ này quét các kho mã để tìm lỗ hổng bảo mật, thực hiện xác minh bổ sung để giảm sai sót, đồng thời tự động tạo khuyến nghị sửa lỗi để nhà phát triển xem xét. Kể từ khi bản xem trước nghiên cứu ra mắt vào tháng 2, hàng trăm tổ chức đã triển khai Claude Security trong môi trường sản xuất và phát hiện các vấn đề mà công cụ quét truyền thống bỏ sót.

2026-04-30 11:29

Claude Code của Anthropic bị tính phí quá mức 200,98 USD do lỗi thanh toán, ban đầu bị từ chối hoàn tiền trước khi được bồi thường đầy đủ

Theo giám sát của Beating, một lỗi tính phí trong dịch vụ Claude Code của Anthropic đã khiến một thuê bao Max bị tính phí quá mức 200,98 USD cho các khoản phí sử dụng phát sinh, trong khi chỉ dùng 13% hạn mức hằng tháng của họ. Lỗi được kích hoạt khi lịch sử commit trong kho git của người dùng chứa chuỗi chữ hoa "HERMES.md"; hệ thống đã bỏ qua giới hạn theo gói thuê bao và tính thêm chi phí sử dụng thay vì chặn. Hệ thống phòng chống lạm dụng của Anthropic đang thực hiện so khớp chuỗi trên các nhật ký git được đưa vào prompt hệ thống, có khả năng nhằm phát hiện các trình khách API không chính thức, nhưng lại vô tình gắn nhãn sai cho người dùng hợp pháp khi họ nhắc đến tệp cấu hình của Hermes Agent. Sau khi người dùng nộp yêu cầu hoàn tiền, bộ phận CSKH AI của Anthropic ban đầu từ chối bồi thường, cho biết họ không thể hoàn tiền cho các lỗi định tuyến tính phí. Lời từ chối đã gây phẫn nộ trên GitHub và Hacker News, lan lên trang chủ. Thành viên đội ngũ Claude Code là Thariq sau đó thông báo rằng tất cả người dùng bị ảnh hưởng sẽ nhận được hoàn tiền đầy đủ cùng với khoản bù tín dụng tương đương.

2026-04-30 02:31

Nhà Trắng phản đối kế hoạch của Anthropic nhằm mở rộng quyền truy cập Mythos AI tới 70 công ty bổ sung

Theo Tờ Wall Street Journal, gần đây Nhà Trắng đã phản đối kế hoạch của Anthropic nhằm mở rộng quyền truy cập vào mô hình trí tuệ nhân tạo Mythos của hãng tới khoảng 70 công ty và tổ chức bổ sung, nâng tổng số thực thể có quyền truy cập lên xấp xỉ 120. Các quan chức chính phủ cho biết lo ngại về an ninh, với một số người bày tỏ lo ngại rằng Mythos có thể được dùng để thực hiện các cuộc tấn công mạng và gây ra thiệt hại quy mô lớn trên không gian mạng.

2026-04-30 00:06

Anthropic Tìm Kiếm Tài Trợ Với Định Giá Vượt 900 Tỷ USD, Có Thể Vượt Qua OpenAI

Theo Jin Ten, Anthropic đang lên kế hoạch một vòng gọi vốn mới vào ngày 30 tháng 4, dự kiến định giá công ty ở mức trên $900 tỷ USD, có khả năng biến công ty trở thành startup AI có giá trị cao nhất thế giới và vượt qua OpenAI. Ban lãnh đạo của công ty đang xem xét nhiều đề xuất từ các nhà đầu tư có thể nâng định giá hiện tại của công ty lên hơn gấp đôi. Những cuộc thảo luận này vẫn đang ở giai đoạn ban đầu, và Anthropic vẫn chưa chấp nhận bất kỳ đề xuất nào.

Bài viết hot về Anthropic (ANTHROPIC)

MarsBitNews

2 phút trước.

原文标题：What to Learn, Build, and Skip in AI Agents (2026)原文作者：Rohit编译：Peggy，BlockBeats 原文作者：律动BlockBeats 原文来源：转载：火星财经编者按：AI Agent 领域正在进入一个工具爆炸、共识不足的阶段。每周都有新框架、新模型、新 benchmark 和新的「10 倍效率」产品出现，但真正重要的问题，已经不是「如何跟上所有变化」，而是「哪些变化真的值得投入」。作者认为，在技术栈不断被重写的当下，真正能长期复利的不是追逐最新框架，而是更底层的能力：context engineering、工具设计、eval 体系、orchestrator-subagent 模式、沙盒与 harness 思维。这些能力不会随着模型换代迅速失效，反而会成为构建可靠 AI Agent 的基础。文章更进一步指出，AI Agent 也在改变「资历」的含义。过去，学历、职级和年限是进入行业的通行证；但在一个连巨头都还在公开试错的领域里，简历不再是唯一凭证。你做出了什么、交付了什么，正在变得更重要。因此，本文不只是讨论 2026 年 AI Agent 该学什么、用什么、跳过什么，更是在提醒：在噪音越来越多的时代，最稀缺的能力，是判断什么值得学，并持续做出真正有用的东西。以下为原文：每天都会冒出一个新框架、一个新基准、一个新的「10 倍效率」产品。问题不再是「我该怎么跟上」，而是：这里面到底什么是真信号，什么只是披着紧迫感外衣的噪音。每一份路线图，发布一个月后就可能过时。你上个季度刚掌握的框架，现在已经成了旧东西。你曾经为之优化的 benchmark，被人刷穿之后很快又被新的取代。过去，我们被训练成沿着一条传统路径前进：一个技术栈，对应一组主题和层级；一串工作经历，对应年限和头衔；一步一步缓慢往上爬。但 AI 改写了这张画布。今天，只要提示词用得对、审美判断足够好，一个人就能交付过去需要一名有两年经验的工程师花一个 sprint 才能完成的工作。专业能力依然重要。没有什么可以替代你亲眼见过系统崩掉，凌晨两点调过内存泄漏，也没有什么能替代你曾经力排众议选择一个无聊但正确的方案，并最终被证明是对的。这样的判断力会复利增长。但不再像过去那样复利增长的，是你对「本周热门框架 API 表面」的熟悉程度。六个月后，它可能又变了。两年后真正胜出的人，是那些早早选中耐用基础能力、并让其他噪音从身边经过的人。过去两年，我一直在这个领域构建产品，拿到过多个年薪 25 万美元以上的 offer，现在在一家隐身公司负责技术。如果有人问我：「现在到底应该关注什么？」这就是我会发给他的内容。这不是一张路线图。Agent 领域还没有明确目的地。大厂实验室也在公开迭代，把回归问题直接推给数百万用户，再写复盘、在线修补。如果 Claude Code 背后的团队都能发布一个造成 47% 性能回退的版本，而且直到用户社区发现后才意识到问题，那么所谓「底下存在一张稳定地图」的想法就是虚构的。所有人都还在摸索。创业公司之所以有机会，正是因为巨头也不知道答案。不会写代码的人正在和 agent 搭档，在周五交付一些周二还被机器学习博士认为不可能的东西。这个时刻最有意思的一点，是它改变了我们对「资历」的理解。传统路径优化的是资历：学位、初级岗位、高级岗位、资深岗位，以及缓慢积累起来的职级。这在底层领域不发生剧烈变化时是合理的。但现在，脚下的地面正在以同样的速度从所有人脚下移动。一个 22 岁、公开发布 agent demo 的年轻人，和一个 35 岁的资深工程师之间的差距，不再只是十年技术栈熟练度的积累。这个 22 岁的人和资深工程师面对的是同一张空白画布。对他们来说，真正会复利增长的是持续交付的意愿，以及那一小部分不会在一个季度内过时的基础能力。这就是整篇文章的核心重构。接下来，我会提供一种判断方式：哪些基础能力值得你投入注意力，哪些发布可以直接让它过去。适合你的就拿走，不适合的就放下。真正有效的过滤器你不可能跟上每周的新发布，也不应该这么做。你需要的不是信息流，而是过滤器。过去 18 个月里，有五个测试一直有效。在让某个新东西进入你的技术栈之前，先用这五个问题过一遍。两年后它还重要吗？如果它只是某个前沿模型外面套的一层壳、一个 CLI 参数，或者「某某版 Devin」，答案几乎总是否定的。如果它是一个基础原语，比如协议、记忆模式、沙盒方法，答案就更可能是肯定的。套壳产品的半衰期很短，基础原语的半衰期可以按年计算。有没有你尊重的人，已经基于它做出了真实产品，并且诚实写过经验？营销文章不算，复盘文章才算。一篇题为「我们在生产环境里试了 X，结果这里出问题了」的博客，比十篇发布公告更有价值。这个领域里真正有用的信号，永远来自那些为此失去过一个周末的人。采用它，是否意味着你要丢掉现有的 tracing、重试机制、配置、认证系统？如果是，那它就是一个试图把自己做成平台的框架。试图成为平台的框架，死亡率大约有 90%。好的基础原语，应该能嵌入你现有系统，而不是逼你迁移。如果你跳过它六个月，代价是什么？对大多数发布来说，答案是什么都没有。六个月后你会知道更多，胜出的版本也会更清楚。这一条测试，可以让你毫无焦虑地跳过 90% 的发布。但也是最多人拒绝使用的一条，因为跳过某个东西会让人感觉自己落后了。实际上并不是。你能否衡量它是否真的让你的 agent 变好了？如果不能，那你只是在猜。没有 eval 的团队靠感觉运行，最终会把回归问题发到线上。有 eval 的团队，则可以让数据告诉自己：在本周这个具体工作负载上，到底是 GPT-5.5 更好，还是 Opus 4.7 更好。如果你只从这篇文章里带走一个习惯，那就是：每当一个新东西发布时，写下你需要在六个月后看到什么，才会相信它真的重要。然后六个月后回来检查。大多数时候，问题自己已经给出了答案，而你的注意力也会被用在那些真正能复利增长的事情上。这些测试背后真正的能力，比任何一条测试都更难命名。它是一种愿意「不赶时髦」的能力。这个星期在 Hacker News 爆火的框架，会在十四天内拥有一支啦啦队，他们听起来都会很聪明。但六个月后，其中一半框架已经无人维护，那些啦啦队也早已转向下一个热点。没有参与其中的人，把注意力省下来，留给那些在发布热潮过去后依然经受住「变得无聊」考验的东西。克制、观望、说一句「六个月后我就知道了」，才是这个领域真正的职业技能。所有人都会读发布公告，但几乎没人擅长不对它们做反应。该学什么概念、模式、事物的形状。真正带来复利回报的是这些东西。它们能穿越模型替换、框架替换和范式转移。深刻理解它们，你就能在一个周末内上手任何新工具。跳过它们，你就会永远在重新学习表层机制。 Context Engineering 过去两年里，最重要的一次改名，是「Prompt Engineering」变成了「Context Engineering」。这个变化是真的，不只是换个说法。模型不再是一个你给它写一条聪明指令的东西。它变成了一个你需要在每一步为其组装可工作上下文的东西。这个上下文同时包含系统指令、工具 schema、检索到的文档、之前的工具输出、scratchpad 状态，以及压缩后的历史记录。Agent 的行为，是你放进上下文窗口里的所有内容共同涌现出来的结果。你需要内化这一点：上下文就是状态。每一个无关 token 都会消耗推理质量。上下文腐烂，是一种真实的生产故障。到一个十步任务的第八步时，最初目标可能已经被工具输出埋掉了。能交付可靠 agent 的团队，会主动总结、压缩、裁剪上下文。他们会给工具描述做版本管理，会缓存静态部分，也会拒绝缓存会变化的部分。他们看待上下文窗口的方式，就像一个有经验的工程师看待内存。一个具体的感受方式是：拿任意一个生产环境里的 agent，打开完整 trace 日志。看看第一步时的上下文，再看看第七步时的上下文。数一数还有多少 token 仍然在发挥作用。第一次做这件事时，你大概率会感到尴尬。然后你会去修它，而同一个 agent 会在不更换模型、不改 prompt 的情况下，明显变得更可靠。如果你只读一篇相关内容，就读 Anthropic 的《Effective Context Engineering for AI Agents》。然后再读他们关于多 agent 研究系统的复盘，那篇文章用数字说明了当系统规模扩大后，上下文隔离有多重要。工具设计工具是 agent 与你的业务发生接触的地方。模型会根据工具名称和描述来选择工具，会根据错误信息来决定如何重试。工具的契约是否符合 LLM 擅长表达的方式，决定了模型是成功还是失败。五到十个命名良好的工具，胜过二十个平庸的工具。工具名称应该像自然英文里的动词短语。描述应该写清楚什么时候该用，什么时候不该用。错误信息应该是模型可以据此行动的反馈。「超过 500 个 token 上限，请先总结再尝试」远胜于「Error: 400 Bad Request」。公开研究中有一个团队报告称，他们仅仅重写错误信息，就让重试循环减少了 40%。 Anthropic 的《Writing tools for agents》是很好的起点。读完之后，给你自己的工具加上观测，看看真实调用模式。Agent 可靠性最大的提升，几乎总是发生在工具侧。很多人不断调 prompt，却忽视了真正杠杆所在的位置。 Orchestrator-Subagent 模式 2024 年和 2025 年关于多 agent 的争论，最终收敛成了一个如今大家都在采用的综合方案。天真的多 agent 系统，也就是多个 agent 并行写入共享状态的系统，会灾难性失败，因为错误会不断复合。单 agent 循环能扩展到的程度，往往比你想象中更远。真正能在生产环境里工作的多 agent 形态只有一种：一个 orchestrator agent，把范围狭窄、只读的任务委派给隔离的 subagent，然后再综合它们的结果。 Anthropic 的研究系统是这样工作的。Claude Code 的 subagents 也是这样工作的。Spring AI 和多数生产框架现在也在标准化这一模式。Subagent 拥有小而聚焦的上下文，不能修改共享状态。写入由 orchestrator 负责。 Cognition 的《Don』t Build Multi-Agents》和 Anthropic 的《How we built our multi-agent research system》看起来像是相反观点，但其实只是用不同词汇在说同一件事。两篇都值得读。默认使用单 agent。只有当单 agent 确实撞到真实边界时，再考虑 orchestrator-subagent：比如上下文窗口压力、顺序工具调用带来的延迟，或者任务异质性确实能从聚焦上下文中获益。在还没有感受到痛点之前就构建这套东西，只会交付你并不需要的复杂性。 Evals 与黄金数据集每一个能交付可靠 agent 的团队都有 eval。没有 eval 的团队，通常也交付不出可靠 agent。这是这个领域杠杆最高的习惯，也是我在每家公司里看到的最被低估的事情。有效做法是：收集生产环境 trace，标注失败案例，把它们当作回归集。每当新的失败上线，就把它加进去。主观部分使用 LLM-as-judge，其他部分使用精确匹配或程序化检查。在任何 prompt、模型或工具变更之前，都跑一遍测试套件。Spotify 工程博客报告称，他们的 judge 层会在输出上线前拦下大约 25% 的 agent 输出。如果没有它，每四个坏结果中就会有一个抵达用户面前。让这件事真正扎根的心智模型是：eval 就是一个单元测试，用来在其他所有东西都不断变化时，确保 agent 没有偏离职责。模型会出新版本，框架会发布破坏性变更，供应商会废弃某个端点。你的 eval 是唯一能告诉你 agent 是否还在正常工作的东西。没有 eval，你就在写一个正确性取决于移动目标善意的系统。 Eval 框架，比如 Braintrust、Langfuse evals、LangSmith，都还不错。但它们都不是瓶颈。真正的瓶颈，是你首先有没有一个已标注的数据集。第一天就该开始做，在扩展任何东西之前就做。最初的 50 个样本，一个下午就能手工标完。没有借口。把文件系统当作状态，以及 Think-Act-Observe 循环对于任何执行真实多步骤工作的 agent 来说，耐用的架构都是：思考、行动、观察、重复。文件系统或结构化存储，是事实来源。每个动作都被记录，并且可以重放。Claude Code、Cursor、Devin、Aider、OpenHands、goose 都收敛到这一点，不是没有原因的。模型本身是无状态的。运行框架必须是有状态的。文件系统是每个开发者都已经理解的有状态基础原语。一旦接受这个框架，整套 harness 纪律都会自然展开：checkpoint、可恢复性、sub-agent 验证、沙盒执行。这里更深的一层启发是：在任何值得为其支付算力账单的生产 agent 中，harness 做的工作都比模型更多。模型选择下一步行动，harness 验证它，在沙盒中运行它，捕获输出，决定把什么反馈回去，决定什么时候停止，决定什么时候 checkpoint，决定什么时候生成 subagent。把模型换成另一个同等质量的模型，一个好的 harness 仍然能交付产品。把 harness 换成一个更差的，即使是世界上最好的模型，也会产出一个会随机忘记自己在做什么的 agent。如果你构建的东西比一次性工具调用更复杂，那么你真正应该投入时间的地方是 harness。模型只是其中的一个组件。从概念上理解 MCP 不要只是学习怎么调用 MCP server。要学习它的模型。它在 agent 能力、工具与资源之间建立了清晰分离，并在底层提供了可扩展的认证与传输方案。一旦理解了这一点，你看到的其他「agent 集成框架」，都会像是 MCP 的低配版，你也就省下了逐个评估它们的时间。 Linux Foundation 现在负责托管 MCP。所有主要模型提供商都支持它。把它比作「AI 的 USB-C」，现在已经比讽刺更接近事实。沙盒化是一种基础原语每一个生产级 coding agent 都运行在沙盒里。每一个浏览器 agent 都遭遇过间接 prompt injection。每一个多租户 agent，某个阶段都出现过权限范围 bug。你应该把沙盒化当作基础设施原语，而不是等客户提出要求后才添加的功能。要学基础知识：进程隔离、网络出口控制、密钥范围管理、agent 与工具之间的认证边界。那些等客户安全审查后才临时补上的团队，往往会丢掉交易。那些从第一周就把它做进去的团队，才会在企业采购流程中轻松通过。该用什么构建以下是截至 2026 年 4 月的具体选择。这些选择会变化，但不会变化得太快。在这一层，尽量选「无聊但稳」的东西。编排层 LangGraph 是生产环境里的默认选择。大约三分之一运行 agent 的大型公司都在用它。它的抽象方式符合 agent 系统的真实形态：类型化状态、条件边、持久化工作流，以及 human-in-the-loop 检查点。缺点是写起来啰嗦；优点是，当一个 agent 真正进入生产环境后，你确实需要控制这些东西，而它的啰嗦正好对应了这些控制需求。如果你主要使用 TypeScript，Mastra 是事实上的选择。它是这个生态里心智模型最清晰的方案。如果你的团队喜欢 Pydantic，并且希望把类型安全作为一等公民，Pydantic AI 是一个合理的 greenfield 选择。它在 2025 年底发布了 v1.0，势头确实存在。如果是 provider-native 的工作，比如 computer use、语音、实时交互，可以在 LangGraph 节点里使用 Claude Agent SDK 或 OpenAI Agents SDK。不要试图让它们成为异构系统的顶层编排器。它们是为各自擅长的场景优化的。协议层 MCP，没别的。把你的工具集成做成 MCP server。外部集成也用同样方式消费。现在 MCP registry 已经越过了临界点：大多数情况下，在你需要自己构建之前，已经能找到一个现成 server。2026 年还在手写自定义工具 plumbing，基本是在白交税。记忆层选择记忆系统时，不要按热度选，要按 agent 的自主程度选。 Mem0 适合聊天式个性化：用户偏好、轻量历史记录。Zep 适合生产级对话系统，尤其是状态会持续演化、需要实体追踪的场景。Letta 适合那些需要在几天甚至几周工作周期里保持一致性的 agent。大多数团队不需要这个；但真正需要的团队，需要的正是它。常见错误是：还没有记忆问题，就先上记忆框架。先从上下文窗口能容纳的内容，加一个向量数据库开始。只有当你能清楚说出它要解决的失败模式时，再加入记忆系统。可观测性与 evals Langfuse 是开源默认选择。它可以自托管，采用 MIT 许可证，覆盖 tracing、prompt 版本管理，以及基础的 LLM-as-judge evals。如果你已经是 LangChain 用户，LangSmith 集成会更紧密。Braintrust 适合研究型 eval 工作流，尤其是需要严谨比较的场景。OpenLLMetry / Traceloop 则适合需要 vendor-neutral OpenTelemetry instrumentation 的多语言技术栈。你需要同时拥有 tracing 和 evals。Tracing 回答的是：「agent 到底做了什么？」Evals 回答的是：「agent 比昨天变好了，还是变差了？」没有这两样，不要上线。第一天就把这些东西接好，成本远低于在盲跑之后再补救。运行时与沙盒 E2B 适合通用的沙盒代码执行。Browserbase 搭配 Stagehand，适合浏览器自动化。Anthropic Computer Use 适合需要真实操作系统级桌面控制的场景。Modal 适合短时突发任务。永远不要运行未沙盒化的代码执行。一个被 prompt injection 攻破的 agent，如果直接在生产环境中运行，其爆炸半径会变成一个你绝不想讲给别人听的故事。模型追 benchmark 很累，而且大多数时候没太大帮助。务实地看，截至 2026 年 4 月： ·Claude Opus 4.7 和 Sonnet 4.6 适合可靠的工具调用、多步骤一致性，以及优雅的失败恢复。对大多数工作负载·来说，Sonnet 是成本与性能之间的甜点位。 ·GPT-5.4 和 GPT-5.5 适合需要最强 CLI / terminal 推理能力，或者你本身就生活在 OpenAI 基础设施里的场景。 ·Gemini 2.5 和 3 适合长上下文密集型，或者多模态密集型任务。 ·当成本比顶级性能更重要时，尤其是处理边界清晰、定义狭窄的任务，可以考虑 DeepSeek-V3.2 或 Qwen 3.6。把模型视为可替换组件。如果你的 agent 只能在某一个模型上工作，这不是护城河，而是坏味道。用 evals 决定部署什么模型。每个季度重新评估一次，不要每周都追着换。什么可以跳过你会不断被人劝去学习、使用下面这些东西。其实不需要。跳过它们的代价很低，省下的时间很多。 AutoGen 和 AG2，不要用于生产。 Microsoft 的这个框架已经转向社区维护，发布节奏停滞，抽象方式也不符合生产团队真正需要的形态。做学术探索可以，但不要把产品押在上面。 CrewAI，不要用于新的生产构建。它到处都能看到，因为它很适合做 demo。真正构建生产系统的工程师已经在迁出它。你想用它做原型可以，但不要长期绑定。 Microsoft Semantic Kernel，除非你已经深度锁定在 Microsoft 企业技术栈里，而且你的买方也在意这一点。它不是生态系统正在走向的方向。 DSPy，除非你专门在大规模优化 prompt programs。它有哲学价值，但受众很窄。它不是通用 agent 框架，也不要把它当成通用框架来选。把独立 code-writing agent 当作架构选择。 Code-as-action 是有意思的研究方向，但它还不是生产环境里的默认模式。你会遇到许多工具链和安全问题，而你的竞争对手可能根本不用处理这些。「Autonomous agent」式推销。 AutoGPT 和 BabyAGI 那条产品形态上的路线已经死了。行业最终接受的诚实说法是「agentic engineering」：有监督、有边界、有评估。2026 年还在卖「部署后就不用管」的 autonomous agent 的人，本质上是在卖 2023 年的东西。 Agent app store 和 marketplace。从 2023 年开始就有人承诺这件事，但从未真正获得企业 traction。企业不会购买通用的预制 agent。它们要么买和具体结果绑定的垂直 agent，要么自己构建。不要围绕一个 app store 梦想来设计你的业务。作为客户，谨慎选择横向的「build any agent」企业平台。例如 Google Agentspace、AWS Bedrock Agents、Microsoft Copilot Studio 这一层。它们以后可能会有用，但现在仍然混乱、发版慢，而且 buy-versus-build 的账通常仍然倾向于：自己构建一个窄 agent，或者购买一个垂直 agent。Salesforce Agentforce 和 ServiceNow Now Assist 是例外，因为它们赢在已经嵌入你正在使用的工作流系统里。不要追 SWE-bench 和 OSWorld 排行榜。 Berkeley 研究人员在 2025 年记录到，几乎所有公开 benchmark 都可以被刷榜，而不需要真正解决底层任务。现在团队会把 Terminal-Bench 2.0 和自己的内部 evals 当作更真实的信号。默认对单一数字的 benchmark 飞跃保持怀疑。天真的并行多 agent 架构。五个 agent 围绕共享记忆聊天，在 demo 里看起来很厉害，到了生产环境就会散架。如果你不能在餐巾纸上画出一张清晰的 orchestrator-subagent 图，并标明读写边界，就不要上线。新 agent 产品不要用 per-seat SaaS 定价。市场已经转向 outcome-based 和 usage-based。按席位收费不仅会让你少赚，还会向买方释放一个信号：你自己都不相信产品能交付结果。这个星期你在 Hacker News 上看到的下一个框架。等六个月。如果它到时候还重要，你会很清楚。如果它不重要，你就省下了一次迁移。具体该怎么推进如果你不是只想「跟上 agent」，而是真的想采用 agent，下面这个顺序是有效的。它很无聊，但有用。先选一个已经重要的结果。不要选 moonshot，不要一上来做一个横向的「agent platform」项目。选一个你的业务本来就关心、而且可以衡量的事情：减少客服工单、生成第一版法律审查意见、筛选 inbound leads、生成月度报告。Agent 是否成功，取决于这个结果是否改善。它从第一天起就是你的 eval target。这一步之所以比其他任何步骤都重要，是因为它会约束后续所有决策。有了具体结果，「选哪个框架」就不再是哲学问题，你会选择最快能交付这个结果的框架。「选哪个模型」也不再是 benchmark 争论，而是选择你的 evals 证明在这项具体工作上有效的模型。「我们需不需要记忆、subagents、定制 harness」也不再是思维实验，而是只在具体失败模式需要时才添加。跳过这一步的团队，最后往往会做出一个没人要的横向平台。认真对待这一步的团队，通常会交付一个狭窄但能在一个季度内回本的 agent。而这个真正上线的 agent，会教会他们比读两年文章更多的东西。在上线任何东西之前，先设置 tracing 和 evals。选 Langfuse 或 LangSmith，把它接好。必要时手工构建一个小型 golden dataset。50 个标注样本就足够开始。你无法改进自己无法衡量的东西。以后再补这套系统，成本大约是现在就做的 10 倍。从一个单 agent 循环开始。选择 LangGraph 或 Pydantic AI。模型选择 Claude Sonnet 4.6 或 GPT-5。给 agent 三到七个设计良好的工具。让它用文件系统或数据库作为状态。先发给小范围用户，观察 traces。把 agent 当作产品，而不是项目。它会以你没预料到的方式失败，而这些失败就是你的路线图。用真实生产 trace 构建 regression set。每一次 prompt 变更、模型替换、工具修改，都要在部署前通过 evals。大多数团队都低估了这里的投入，而大多数可靠性也正是从这里来的。只有当你已经「挣到了」扩展范围的资格，再增加复杂度。上下文成为瓶颈时，再引入 subagents。单窗口上下文无法承载所需内容时，再引入记忆框架。底层 API 真不存在时，再引入 computer use 或 browser use。不要提前设计这些东西。让失败模式把它们拉进来。选择无聊的基础设施。工具用 MCP。沙盒用 E2B 或 Browserbase。状态用 Postgres，或者你们已经在运行的数据存储。认证和可观测性也尽量沿用现有系统。奇特的基础设施很少是真正的胜负手，真正的胜负手是纪律。从第一天就盯住单位经济模型。每次 action 成本、缓存命中率、重试循环成本、模型调用分布。Agent 在 PoC 阶段看起来很便宜，但如果你一开始没有按 outcome 监控成本，规模扩大 100 倍时成本会爆炸。一个 0.50 美元一次运行的 PoC，在中等规模下就可能变成每月 5 万美元。没提前看到这一点的团队，会迎来一场他们并不喜欢的 CFO 会议。每个季度重新评估模型，而不是每周重新评估。锁定一个季度。季度结束时，用你的 eval suite 跑一遍当前前沿模型。如果数据说明该换，就换。这样你能获得模型进步的收益，同时避免追逐每次发布带来的混乱。如何判断潮流下面是一些具体信号，说明某件事可能是真的 signal：一个受尊重的工程团队写了带数字的 postmortem，而不只是宣称有多少人采用；它是一个基础原语，比如协议、模式或基础设施，而不是套壳或打包；它能和你已经运行的系统互操作，而不是替代它；它的 pitch 讲的是它解决了什么失败模式，而不是它开启了什么能力；它已经存在了足够长时间，长到有人能写出一篇「哪些地方没奏效」的博客。下面是一些具体信号，说明某件事可能只是噪音：发布 30 天后仍然只有 demo 视频，没有生产案例；benchmark 跃升干净得不像真的；pitch 里不加限定地使用「autonomous」「agent OS」或「build any agent」；框架文档默认你会扔掉现有的 tracing、auth 和 config；star 数增长很快，但 commits、releases 和 contributors 没有同步增长；Twitter 速度很快，但 GitHub 速度跟不上。一个有用的每周习惯是：周五留出 30 分钟看这个领域。读三样东西：Anthropic 工程博客、Simon Willison 的笔记、Latent Space。如果这一周有 postmortem，再扫一两篇。其他都可以跳过。真正重要的东西，你不会错过。接下来值得观察什么未来两个季度值得关注的事情，不是因为它们一定会赢，而是因为「这到底是不是 signal」这个问题还没有完全解决。 Replit Agent 4 的 parallel forking 模型。这是第一批认真尝试「多个 agent 并行工作」但又不被共享状态绊倒的方案之一。如果它能在规模化后站住脚，orchestrator-subagent 这个默认模式可能会发生变化。 Outcome-based pricing 的成熟度。 Sierra 和 Harvey 的收入轨迹，已经在狭窄垂直领域验证了这一模式。问题是，它是否能推广到其他领域，还是只适用于垂直场景。 Skills 作为能力封装层。 GitHub 上 AGENTS.md 和 skills directories 的增多，说明一种封装 agent 能力的新方式正在出现。它是否会像 MCP 标准化工具那样标准化能力层，这是一个开放问题。 Claude Code 2026 年 4 月质量回退及其复盘。一个行业领先的 agent 发布了一个造成 47% 性能回退的版本，而且是用户先发现，内部监控后发现。这说明即使在领先者那里，生产级 agent eval 实践仍然很不成熟。如果这件事推动整个行业投资更好的 online evals，那么这次纠偏是健康的。语音成为默认客服界面。 Sierra 的语音渠道在 2025 年底已经超过文本渠道。如果这一模式在其他垂直领域延续，那么延迟、打断、实时工具调用等设计约束会变成一阶问题，很多现有架构都需要重做。开源模型 agent 能力继续缩小差距。 DeepSeek-V3.2 原生支持 thinking-into-tool-use，Qwen 3.6 以及更广泛的开源模型生态都值得关注。狭窄 agent 任务上的成本性能比正在变化。闭源模型默认占优的局面不会永久存在。这些事情中的每一件，都可以对应一个清晰问题：「六个月后，我需要看到什么，才会相信它真的重要？」这就是测试。追踪答案，而不是追踪公告。反常识的赌注每一个你没有采用的框架，都是一次你不欠未来的迁移。每一个你没有追逐的 benchmark，都是一个季度的专注力。这个周期里正在赢的公司——Sierra、Harvey、Cursor，各自在自己的领域中——都选择了狭窄目标，建立了无聊的纪律，然后让这个领域的噪音从身边经过。传统路径是：选一个技术栈，花很多年掌握它，然后沿着阶梯往上爬。这在技术栈能稳定十年的时候是有效的。但现在，技术栈每个季度都在变。真正赢的人，不再优化「掌握某个技术栈」的能力，而是在优化品味、基础原语和交付速度。他们公开构建小东西，通过交付来学习。别人是因为他们已经做出来的东西，而把他们拉进房间。作品本身就是资历。请认真想一想这一点，因为这正是整篇文章真正想说的。我们大多数人接受的工作模型，都假定这个世界会稳定足够久，让资历能够复利增长。你去上学，拿学位，爬梯子。这里待两年，那里待三年，简历慢慢变成能打开门的东西。整个机器的前提，是它对面的行业足够稳定。但 agent 领域现在没有一个稳定的「对面」。你想加入的公司可能只有六个月大。它们构建所用的框架可能只有十八个月历史。底层协议可能也只有两年。这个领域里一半最常被引用的文章，作者三年前甚至还不在这个领域里。没有梯子可爬，因为这栋楼一直在变楼层。当梯子失效时，剩下的是一种更古老的方法：做出一个东西，放到互联网上，让作品替你介绍自己。这是一条反常识路径，因为它绕开了资历认证系统。但在一个不断移动的领域里，它也是唯一真正能复利增长的路径。这就是从内部看到的时代样貌。连巨头也在公开迭代，发布回归问题，写复盘，在线修补。今年交付最有意思东西的团队里，有些人 18 个月前还不在这个领域。不会写代码的人正在和 agent 搭档，交付真实软件。博士可能会被那些选对基础原语并开始快速出手的构建者超越。大门已经打开。大多数人却还在找申请表。你现在真正需要培养的技能，不是「agents」。而是在一个表层不断变化的领域里，判断哪些工作会复利增长的纪律。Context engineering 会复利增长。工具设计会复利增长。Orchestrator-subagent 模式会复利增长。Eval 纪律会复利增长。Harness 思维会复利增长。周二刚发布的框架 API 不会。一旦你能区分它们，每周一波又一波的新发布就不再像压力，而会变成你可以忽略的噪音。你不需要学会所有东西。你需要学会那些会复利增长的东西，并跳过那些不会复利增长的东西。选一个 outcome。在上线前接好 tracing 和 evals。使用 LangGraph，或者你团队里的等价工具。使用 MCP。把 runtime 放进沙盒。默认从单 agent 开始。只有当失败模式把复杂度拉进来时，再扩大范围。每个季度重新评估模型。周五读三样东西。这就是 playbook。剩下的，是品味、交付速度，以及不追逐无关紧要之物的耐心。去构建东西。把它们放到互联网上。这个时代奖励的是做出东西的人，而不是只会描述东西的人。现在是成为那个「真正做出来的人」的最好窗口。

SleepTrader

7 phút trước.

_Himanshu Tyagi là giáo sư tại Viện Khoa học Ấn Độ và là đồng sáng lập của Sentient._ * * * **Khám phá các tin tức và sự kiện fintech hàng đầu!** **Đăng ký nhận bản tin của FinTech Weekly** **Được đọc bởi các giám đốc điều hành tại JP Morgan, Coinbase, Blackrock, Klarna và nhiều hơn nữa** * * * ### Hứa hẹn của AI đòi hỏi một cách tiếp cận cực kỳ mở, phi tập trung và hợp tác toàn cầu. Bất kỳ điều gì ít hơn đều có nguy cơ dẫn đến một tương lai dễ vỡ, thiên vị, và không ổn định. Khi các chính phủ và các tập đoàn công nghệ chạy đua để chiếm lĩnh AI, chúng ta đang hướng tới một tương lai nguy hiểm và thiển cận, nơi một số ít quốc gia và tập đoàn quyết định sự phát triển của một công nghệ sẽ định hình toàn cầu. Tôi không thể không cảm thấy ngày càng lo lắng về cuộc đua toàn cầu để giành ưu thế AI. Nó thường được bán như một cuộc đối đầu mang tính sinh tử—Mỹ versus Trung Quốc, với người chiến thắng nắm giữ chìa khóa của một công nghệ sẽ định hình tương lai nhân loại. Là người đã dành nhiều năm đắm chìm trong AI cả về mặt chuyên môn lẫn học thuật, tôi ở đây để lên tiếng: **câu chuyện này có những điểm sai lệch nguy hiểm**. Khái niệm một quốc gia định hướng AI là phức tạp về cấu trúc và có thể không phải là lựa chọn tối ưu. **Nguồn gốc toàn cầu của AI** ----------------------------- Thực tế là không quốc gia nào có thể xây dựng AI trong sự cô lập, ngay cả Hoa Kỳ, nơi đã sản xuất 61 mô hình đáng chú ý trong năm 2023, theo Báo cáo Chỉ số AI của Stanford. **Các trụ cột của AI**: tài năng, phần cứng, và dữ liệu, được dệt thành một bức tranh toàn cầu mà không quốc gia nào có thể tháo rời và tái dệt một mình. Lấy ví dụ về tài năng, trong số các nhà nghiên cứu AI hàng đầu ở Mỹ, gần 70% trong số họ sinh ra hoặc được giáo dục ở nước ngoài, với Ấn Độ và Trung Quốc là các nguồn chính. Hai phần ba các công ty khởi nghiệp AI tại Mỹ có ít nhất một nhà sáng lập là người nhập cư. **Cố gắng quốc gia hóa AI trong khi xa lánh các trí thức nước ngoài giống như xây dựng một bộ não rồi cắt bỏ một nửa các neuron của nó**. Phần cứng còn phức tạp hơn nữa. Các công ty Mỹ như NVIDIA thiết kế chip AI, nhưng công ty ASML của Hà Lan chế tạo các máy quang khắc cực tím cực đại (EUV) duy nhất để khắc chúng. Đài Loan’s TSMC sản xuất hơn 90% các chip tiên tiến, và Nhật Bản cung cấp các vật liệu quan trọng. Các thuế quan và kiểm soát xuất khẩu, như trong chiến tranh thương mại Mỹ-Trung, không đảm bảo kiểm soát; chúng làm gián đoạn mạng lưới tinh vi này, làm tăng chi phí và làm chậm tiến trình của mọi người. Dữ liệu, nguồn sống của AI, còn cứng đầu hơn nữa. Bởi vì dữ liệu đa dạng toàn cầu là cần thiết để xây dựng các mô hình AI hiệu quả nhất và phù hợp toàn diện nhất. **Tại sao sự thống trị lại nguy hiểm** --------------------------------- Ngay cả khi một quốc gia có thể độc quyền AI, nó cũng không nên. Một hệ sinh thái AI do Mỹ chi phối sẽ chỉ tạo ra một phòng vang, nhúng các thành kiến phương Tây vào các hệ thống được sử dụng toàn cầu. Hiện nay, các mô hình ngôn ngữ lớn (LLMs) hàng đầu thường phản ánh một phần nhỏ của các quan điểm toàn cầu, **hạn chế khả năng phục vụ các nhóm dân cư đa dạng một cách hiệu quả**. Ví dụ, các mô hình ngôn ngữ được huấn luyện chủ yếu dựa trên một nguồn dữ liệu có thể không nắm bắt được các sắc thái văn hóa hoặc sự khác biệt từ các khu vực khác. Điều này có thể làm giảm độ chính xác và tính hữu dụng của AI. Tệ hơn nữa, một quốc gia giữ quyền kiểm soát AI thúc đẩy cuộc chạy đua vũ trang theo kiểu zero-sum với hậu quả rộng lớn. Các câu chuyện về cuộc đua Mỹ-Trung để giành ưu thế AI, thường được mô tả như một cuộc thi giữa OpenAI hoặc Anthropic và Deepseek hoặc Manus, đã leo thang với sự tham gia tích cực của chính phủ. Cả hai quốc gia đều đầu tư mạnh vào AI, xem đó như một nguồn lực chiến lược tương tự như khả năng hạt nhân trong thế kỷ 20. Nếu các công ty được chính phủ ưu tiên của một quốc gia chiếm giữ các AI tiên tiến nhất, họ có thể kiểm soát một tài sản toàn cầu mang tính biến đổi, mang lại ảnh hưởng kinh tế và chính trị chưa từng có. Chuyển động này có nguy cơ dẫn đến kiểm duyệt cực đoan và kiểm soát quyền truy cập, nơi các siêu cường quyết định ai được tiếp cận các công cụ và dữ liệu AI. Các quốc gia nhỏ hơn có thể buộc phải phù hợp với Mỹ hoặc Trung Quốc, phản ánh các liên minh thời Chiến tranh Lạnh trong cuộc đua vũ khí hạt nhân. Ví dụ, các quốc gia ở châu Phi và Đông Nam Á có thể trở nên phụ thuộc vào các siêu cường và từ bỏ quyền tự chủ về tương lai AI của họ. **Một quốc gia thống trị có thể từ chối cung cấp các công cụ AI hoàn toàn, cô lập các đối thủ, hoặc tràn ngập thị trường toàn cầu bằng các hệ thống ưu tiên các câu chuyện và lợi ích của riêng họ.** Điều này không phải là an ninh; đó là một công thức dẫn đến bất ổn. Vũ khí tự hành dựa trên AI có thể gây ra các “chiến tranh chớp nhoáng”, nơi các hệ thống leo thang xung đột nhanh hơn khả năng can thiệp của con người. Một cường quốc thống trị có thể sử dụng AI để giám sát toàn cầu hoặc ép buộc kinh tế, tạo ra sự oán giận và phụ thuộc. **Tại sao mở rộng là con đường duy nhất** --------------------------------- Xây dựng AI công bằng đòi hỏi sự đóng góp từ mọi nơi trên thế giới, nhưng các hệ thống tập trung lại có quyền lực vượt trội. Ví dụ, quyết định của Anthropic cắt đột ngột quyền truy cập của Windsurf vào các mô hình Claude 3.x của họ, mà không có sự hợp tác hoặc minh bạch trước đó, cho thấy các nhà cung cấp AI kín đáo có thể đơn phương kiểm soát các nguồn lực quan trọng. Những hành động như vậy không chỉ ưu tiên kiểm soát của doanh nghiệp đối với tiến trình chung mà còn hạn chế khả năng của các đối thủ mới xây dựng dựa trên hạ tầng chung. Các luật địa phương về lưu trữ dữ liệu ngày càng tăng cũng làm phức tạp việc truy cập, khiến hợp tác quốc tế trở thành con đường duy nhất để có được các bộ dữ liệu thực sự đại diện. AI nâng cao khả năng sáng tạo, làm việc hiệu quả hơn và giúp chúng ta giải quyết vấn đề nhanh hơn. Nhưng để đảm bảo những lợi ích này đến với tất cả mọi người, cần một cách tiếp cận toàn cầu, mở và hợp tác. Nếu sự phát triển vẫn tập trung trong một vài quốc gia (hoặc tập đoàn), chúng ta có thể gặp trở ngại trong đổi mới sáng tạo, gia tăng bất bình đẳng, và tập trung các quyết định quan trọng về tương lai của sự phát triển này vào tay quá ít người. **Các mô hình mã nguồn mở phá vỡ độc quyền và các vườn cây có tường**. Khi các nhà phát triển từ Bangalore đến Bogotá có thể xây dựng dựa trên cùng một nền tảng, chúng ta sẽ chứng kiến một làn sóng sáng tạo mà không một thực thể đơn lẻ nào có thể sánh kịp. Lịch sử đã chứng minh rằng các dự án mã nguồn mở, dù trong phần mềm hay khoa học, đều phát triển mạnh mẽ vì chúng khai thác nguồn lực toàn cầu về tài năng và ý tưởng. AI cũng không khác. **Phi tập trung cũng quan trọng không kém**. Các hệ thống tập trung dễ bị tổn thương, dễ bị điểm yếu đơn lẻ, và dễ bị lạm dụng. Một phương pháp phi tập trung phân tán rủi ro và trách nhiệm. Bạn chỉ cần nhìn vào sự cố mất kết nối toàn cầu của ChatGPT gần đây để thấy điều gì xảy ra khi các máy chủ tập trung gặp sự cố. Đối với một số người, đó là phiền toái, còn đối với những người khác, đó là vấn đề nghiêm trọng. Nhưng nếu chúng ta càng dựa nhiều hơn vào AI trong y tế, hạ tầng, giáo dục hoặc phản ứng khẩn cấp? **Hãy tưởng tượng hạ tầng AI không bị sập nếu một quốc gia kéo cần hoặc một công ty bật công tắc**. Đó là tương lai chúng ta cần – một tương lai mà không một bên nào giữ tất cả các chìa khóa. **Lời kêu gọi về quốc tế kỹ thuật số** ------------------------------------------ Vì vậy, khi tôi được hỏi, “Ai nên dẫn đầu AI: Mỹ hay Trung Quốc?” câu trả lời của tôi là tinh tế hơn. Chúng ta cần chủ nghĩa quốc tế kỹ thuật số: các công cụ chia sẻ, tiêu chuẩn chung, và trách nhiệm chung. AI không giống như dầu mỏ hay thép. Nó không phải là nguồn tài nguyên để tích trữ hay vũ khí để sử dụng. Đó là một công nghệ sẽ định hình lại cách chúng ta sống, làm việc và giải quyết các vấn đề khó khăn nhất của thế giới. Vì vậy, xem nó như một tài sản quốc gia hay một chiến lợi phẩm của doanh nghiệp là hiểu sai về bản chất của nó và có thể gây nguy hiểm cho tương lai của nó. Luật AI dựa trên quyền của EU, mô hình do nhà nước điều hành của Trung Quốc, và cách tiếp cận dựa trên thị trường của Mỹ đều có điểm mạnh và điểm yếu riêng, nhưng không ai là câu trả lời toàn diện. Chúng ta cần đối thoại, không phải thống trị. Phần còn lại của thế giới, Ấn Độ, Brazil, Nigeria và các quốc gia khác, đều có quyền lợi bình đẳng trong công nghệ này. Chúng ta không thể tin tưởng vào một quốc gia nào, dù có thiện chí đến đâu, để quyết định mọi thứ. Cũng không thể để cuộc đua vũ trang AI trở thành công cụ của sự thống trị thay vì tiến bộ. Và quản trị toàn cầu không có nghĩa là từ bỏ kiểm soát. Nó có nghĩa là thiết lập một mức tối thiểu về quyền truy cập và trách nhiệm giải trình có lợi cho tất cả mọi người. Các khung mã nguồn mở, phát triển minh bạch và giám sát hợp tác có thể đảm bảo AI phục vụ nhân loại, chứ không chỉ một số ít đặc quyền. **Mỹ vẫn có thể dẫn đầu, nhưng không phải bằng cách tích trữ quyền lực.** Nó có thể dẫn đầu bằng cách làm gương, xây dựng các hệ thống hoạt động vì và cùng thế giới, các hệ thống mời gọi tham gia, chứ không loại trừ. * * * ### **Về tác giả:** Himanshu Tyagi là giáo sư tại Viện Khoa học Ấn Độ và là đồng sáng lập của Sentient. Ông đã tiến hành nghiên cứu nền tảng về lý thuyết thông tin, AI và mật mã học, và đã sáng lập nhiều công ty trong lĩnh vực crypto, AI và truyền thông. Himanshu cam kết tạo ra công nghệ và sản phẩm cho tương lai kết nối, nơi các mạng lưới thông tin được tăng tốc bởi AI và crypto sẽ thúc đẩy mọi khát vọng của con người. Ông là người nhận Giải thưởng Nhà Khoa học Trẻ của Viện Khoa học Quốc gia Ấn Độ, Giải thưởng Cựu sinh viên Xuất sắc của Đại học Maryland, từng giữ vị trí Phó biên tập của Transactions on Information Theory, và có nhiều giải thưởng bài báo xuất sắc tại các hội nghị hàng đầu. Ông đã xuất bản cuốn sách mang tên “Cryptography dựa trên lý thuyết thông tin” với Nhà xuất bản Cambridge.

BlockBeatNews

20 phút trước.

> Bản gốc tiêu đề: Những gì cần học, xây dựng và bỏ qua trong AI Agents (2026) > Tác giả gốc: Rohit > Dịch: Peggy, BlockBeats > Lời người biên tập: Lĩnh vực AI Agent đang bước vào giai đoạn bùng nổ công cụ, thiếu sự đồng thuận. Mỗi tuần đều xuất hiện các framework mới, mô hình mới, benchmark mới và các sản phẩm "10 lần hiệu quả" mới, nhưng vấn đề thực sự quan trọng không còn là "làm thế nào để theo kịp tất cả các thay đổi", mà là "những thay đổi nào thực sự đáng để đầu tư". Tác giả cho rằng, trong bối cảnh hệ sinh thái công nghệ liên tục bị viết lại, khả năng thực sự có thể sinh lợi lâu dài không phải là theo đuổi framework mới nhất, mà là các năng lực nền tảng hơn: kỹ thuật ngữ ngữ cảnh, thiết kế công cụ, hệ thống đánh giá, mô hình orchestrator-subagent, tư duy sandbox và harness. Những năng lực này sẽ không nhanh chóng trở nên lỗi thời theo từng thế hệ mô hình, ngược lại, chúng sẽ trở thành nền tảng để xây dựng AI Agent đáng tin cậy. Bài viết còn chỉ rõ hơn, AI Agent cũng đang thay đổi ý nghĩa của "thâm niên". Trước đây, bằng cấp, chức vụ và thời gian làm việc là giấy thông hành vào ngành; nhưng trong một lĩnh vực mà cả các ông lớn còn đang thử nghiệm công khai, hồ sơ cá nhân không còn là bằng chứng duy nhất. Bạn đã làm gì, đã giao hàng ra sao, ngày càng trở nên quan trọng hơn. Vì vậy, bài viết không chỉ bàn về những gì cần học, dùng hay bỏ qua trong AI Agent năm 2026, mà còn nhắc nhở: Trong thời đại ngày càng nhiều nhiễu loạn này, năng lực quý giá nhất là khả năng đánh giá xem điều gì đáng để học, và liên tục tạo ra những thứ thực sự hữu ích. Dưới đây là nguyên bản: ![](https://img-cdn.gateio.im/social/moments-2aa92e6f74-b769be56c6-8b7abd-e5a980) Mỗi ngày đều xuất hiện một framework mới, một benchmark mới, một sản phẩm "10 lần hiệu quả" mới. Vấn đề không còn là "tôi phải làm thế nào để theo kịp", mà là: trong đó đâu mới là tín hiệu thực sự, đâu chỉ là nhiễu loạn khoác áo cảm giác cấp bách. Mỗi lộ trình, sau một tháng ra mắt có thể đã lỗi thời. Framework bạn mới nắm vững quý trước đã trở thành cũ kỹ. Benchmark bạn từng tối ưu hóa bị người khác "đánh bay" rồi nhanh chóng bị thay thế. Trước đây, chúng ta được huấn luyện theo một con đường truyền thống: một hệ thống công nghệ, tương ứng một nhóm chủ đề và cấp độ; một chuỗi kinh nghiệm làm việc, tương ứng thời gian và chức danh; từng bước chậm rãi leo lên. Nhưng AI đã viết lại bức tranh này. Ngày nay, chỉ cần câu lệnh prompt đúng, thẩm mỹ đủ tốt, một người có thể hoàn thành công việc mà trước đây cần một kỹ sư có hai năm kinh nghiệm làm trong một sprint. Năng lực chuyên môn vẫn còn quan trọng. Không có gì thay thế được việc bạn đã từng chứng kiến hệ thống sụp đổ, chỉnh memory leak lúc 2 giờ sáng, hay đã từng kiên quyết chọn một giải pháp nhàm chán nhưng đúng đắn, rồi cuối cùng được chứng minh là đúng. Khả năng đánh giá này sẽ sinh lợi theo thời gian. Nhưng không còn như trước, đó là mức độ quen thuộc của bạn với "API framework hot nhất tuần này" chỉ trên bề mặt. Sau sáu tháng, nó có thể đã thay đổi. Sau hai năm, người chiến thắng thực sự là những ai đã sớm chọn các năng lực nền tảng bền vững, và để các nhiễu loạn đi qua xung quanh họ. Trong hai năm qua, tôi đã xây dựng sản phẩm trong lĩnh vực này, nhận được nhiều offer lương trên 25 nghìn USD/năm, hiện đang phụ trách kỹ thuật tại một công ty ẩn danh. Nếu ai hỏi tôi: "Hiện tại nên tập trung vào gì?" thì đây chính là nội dung tôi sẽ gửi cho họ. Đây không phải là một lộ trình rõ ràng. Lĩnh vực Agent vẫn chưa có đích rõ ràng. Các phòng thí nghiệm lớn cũng đang liên tục cập nhật, đưa các vấn đề trở về cho hàng triệu người dùng, rồi viết lại, sửa lỗi trực tuyến. Nếu đội ngũ sau Claude Code có thể phát hành một phiên bản gây ra 47% giảm hiệu năng, và chỉ nhận ra vấn đề sau khi cộng đồng người dùng phát hiện ra, thì ý tưởng "bản đồ ổn định phía dưới" chỉ là hư cấu. Mọi người vẫn đang mò mẫm. Các startup có cơ hội chính là vì các ông lớn cũng chưa biết câu trả lời. Những người không biết lập trình đang hợp tác với agent, giao những thứ mà các tiến sĩ machine learning còn cho là không thể thực hiện vào thứ Ba, rồi giao vào thứ Sáu. Điểm thú vị nhất của thời điểm này là nó đã thay đổi cách chúng ta hiểu về "thâm niên". Con đường truyền thống tối ưu hóa thâm niên: bằng cấp, vị trí thấp, cao, rồi cao cấp, và cấp bậc tích lũy chậm chạp. Khi lĩnh vực nền tảng không có biến động lớn, điều này hợp lý. Nhưng giờ đây, mặt đất dưới chân chúng ta đang dịch chuyển với cùng tốc độ. Một người trẻ 22 tuổi, công bố demo agent, và một kỹ sư dày dạn 35 tuổi, không còn chỉ khác nhau về độ thành thạo hệ thống trong mười năm nữa. Người 22 tuổi đó và kỹ sư dày dạn đều đối mặt với một bức tranh trống rỗng như nhau. Đối với họ, thứ thực sự sinh lợi theo thời gian là ý chí liên tục giao hàng, và một phần nhỏ các năng lực nền tảng không bị lỗi thời trong một quý. Đây chính là cốt lõi của toàn bộ bài viết. Tiếp theo, tôi sẽ cung cấp một phương pháp đánh giá: những năng lực nền tảng nào đáng để bạn đầu tư, những phát hành nào có thể bỏ qua. Phù hợp thì lấy, không phù hợp thì bỏ qua. Bộ lọc thực sự hiệu quả ======== Bạn không thể theo kịp các phát hành mới hàng tuần, và cũng không nên làm vậy. Điều bạn cần không phải là dòng chảy thông tin, mà là bộ lọc. Trong 18 tháng qua, có năm câu hỏi luôn hiệu quả. Trước khi đưa một thứ mới vào hệ thống công nghệ của bạn, hãy trả lời qua năm câu hỏi này. **Nó còn quan trọng sau hai năm không?** Nếu nó chỉ là lớp vỏ bọc bên ngoài của một mô hình tiên tiến, một tham số CLI, hoặc "phiên bản Devin nào đó", thì câu trả lời gần như luôn là không. Nếu nó là một nguyên thủy nền tảng, như giao thức, mô hình ghi nhớ, phương pháp sandbox, thì khả năng cao câu trả lời là có. Các sản phẩm đóng gói chỉ tồn tại ngắn hạn, còn nguyên thủy nền tảng có thể tồn tại theo năm. **Có người bạn tôn trọng đã dựa vào nó để tạo ra sản phẩm thực, và đã từng chia sẻ kinh nghiệm chân thực không?** Bài viết marketing không tính, chỉ tính các bài review thực tế. Một blog có tiêu đề "Chúng tôi đã thử X trong môi trường sản xuất, kết quả ra sao" còn giá trị hơn mười bài thông báo. Trong lĩnh vực này, tín hiệu thực sự hữu ích luôn đến từ những người đã mất một cuối tuần để thử nghiệm. **Việc áp dụng nó có nghĩa là bạn phải bỏ đi các hệ thống tracing, retry, cấu hình, xác thực hiện có?** Nếu đúng vậy, thì đó là framework muốn trở thành nền tảng. Framework muốn trở thành nền tảng có tỷ lệ thất bại khoảng 90%. Nguyên thủy nền tảng tốt phải có thể tích hợp vào hệ thống hiện tại của bạn, chứ không bắt bạn phải chuyển đổi toàn bộ. **Nếu bỏ qua nó sáu tháng, thiệt hại là gì?** Đối với phần lớn các phát hành, câu trả lời là không có gì. Sau sáu tháng, bạn sẽ biết nhiều hơn, phiên bản thành công rõ ràng hơn. Câu hỏi này giúp bạn bỏ qua 90% các phát hành mà không lo lắng. Nhưng cũng là câu hỏi khiến nhiều người từ chối thử, vì bỏ qua thứ gì đó khiến họ cảm thấy bị tụt hậu. Thực ra không phải vậy. **Bạn có thể đo lường nó có thực sự làm agent của bạn tốt hơn không?** Nếu không, thì bạn chỉ đang đoán. Nhóm không có hệ thống đánh giá sẽ dựa vào cảm giác để vận hành, cuối cùng sẽ đưa vấn đề trở lại môi trường trực tuyến. Nhóm có hệ thống đánh giá thì có thể để dữ liệu nói cho họ biết: trong khối lượng công việc cụ thể tuần này, GPT-5.5 tốt hơn hay Opus 4.7 tốt hơn. Nếu bạn chỉ rút ra một thói quen từ bài viết này, đó là: mỗi khi có thứ mới ra mắt, hãy ghi lại những gì bạn cần thấy sau sáu tháng để tin rằng nó thực sự quan trọng. Rồi sau sáu tháng quay lại kiểm tra. Phần lớn câu hỏi đã tự có câu trả lời, và sự chú ý của bạn sẽ tập trung vào những thứ thực sự có thể sinh lợi theo thời gian. Các tín hiệu đằng sau các câu hỏi này thực sự là năng lực khó gọi tên nhất. Đó là khả năng "không chạy theo mốt". Tuần này, các framework hot trên Hacker News sẽ có đội nhóm ủng hộ trong vòng mười bốn ngày, nghe có vẻ rất thông minh. Nhưng sau sáu tháng, một nửa trong số đó đã không còn ai duy trì, và những đội nhóm đó đã chuyển sang xu hướng mới. Những người không tham gia sẽ tiết kiệm thời gian, dành cho những thứ vẫn còn "lỗi thời" sau khi các phát hành nóng bỏng qua đi. Kiềm chế, chờ đợi, nói "sáu tháng nữa tôi sẽ biết" mới là kỹ năng nghề nghiệp thực sự trong lĩnh vực này. Mọi người đều đọc thông báo phát hành, nhưng hầu như ít ai giỏi trong việc không phản ứng lại chúng. Nên học gì ==== Khái niệm, mô hình, hình dạng của các thứ. Những thứ thực sự mang lại lợi nhuận theo thời gian chính là những thứ này. Chúng có thể vượt qua các thế hệ mô hình, framework và chuyển đổi paradigm. Hiểu sâu sắc chúng, bạn có thể làm quen với bất kỳ công cụ mới nào trong một cuối tuần. Bỏ qua chúng, bạn sẽ mãi mãi phải học lại các cơ chế bề mặt. Kỹ thuật Ngữ Ngữ Cảnh (Context Engineering) ------------------- Trong hai năm qua, sự thay đổi quan trọng nhất là "Prompt Engineering" đã trở thành "Context Engineering". Thay đổi này là thật, không chỉ là đổi tên. Mô hình không còn là thứ bạn viết một lệnh thông minh cho nó nữa. Nó trở thành thứ bạn cần phải lắp ráp ngữ cảnh phù hợp để hoạt động ở mỗi bước. Ngữ cảnh này bao gồm chỉ thị hệ thống, schema công cụ, tài liệu truy xuất, kết quả công cụ trước đó, scratchpad, và lịch sử nén lại. Hành vi của agent là kết quả của tất cả nội dung bạn đưa vào trong cửa sổ ngữ cảnh. Bạn cần thấm nhuần điều này: ngữ cảnh chính là trạng thái. Mỗi token không liên quan đều làm giảm chất lượng suy luận. Ngữ cảnh bị hỏng là một lỗi thực sự trong sản xuất. Đến bước thứ tám của một nhiệm vụ mười bước, mục tiêu ban đầu có thể đã bị che khuất bởi output của công cụ. Nhóm xây dựng agent đáng tin cậy sẽ chủ động tổng hợp, nén, cắt giảm ngữ cảnh. Họ sẽ quản lý phiên bản mô tả công cụ, cache phần tĩnh, và từ chối cache phần thay đổi. Cách họ nhìn nhận cửa sổ ngữ cảnh giống như một kỹ sư có kinh nghiệm nhìn nhận bộ nhớ. Cách cảm nhận cụ thể là: mở trace log đầy đủ của một agent trong môi trường sản xuất. Xem ngữ cảnh ở bước đầu tiên, rồi bước thứ bảy. Đếm xem còn bao nhiêu token vẫn còn phát huy tác dụng. Lần đầu làm việc này, bạn có thể cảm thấy ngượng ngùng. Sau đó, bạn sẽ sửa nó, và cùng một agent mà không cần đổi mô hình hay prompt sẽ trở nên đáng tin cậy hơn rõ rệt. Nếu chỉ đọc một bài liên quan, hãy đọc "Effective Context Engineering for AI Agents" của Anthropic. Rồi xem lại các bài review về hệ thống nghiên cứu đa agent của họ, bài viết này dùng số liệu để chứng minh tầm quan trọng của việc cô lập ngữ cảnh khi quy mô hệ thống mở rộng. Thiết kế công cụ ---- Công cụ là nơi agent tiếp xúc với công việc của bạn. Mô hình sẽ chọn công cụ dựa trên tên và mô tả của nó, và quyết định retry dựa trên thông tin lỗi. Thỏa thuận của công cụ phù hợp với cách LLM thể hiện sẽ quyết định thành bại của mô hình. Năm đến mười công cụ có tên rõ ràng, tốt hơn hai mươi công cụ trung bình. Tên công cụ nên như các động từ trong tiếng Anh tự nhiên. Mô tả rõ ràng khi nào dùng, khi nào không. Thông tin lỗi nên là phản hồi để mô hình hành động dựa vào. "Vượt quá giới hạn 500 token, vui lòng tóm tắt rồi thử lại" tốt hơn "Error: 400 Bad Request". Trong nghiên cứu công khai, có một nhóm báo cáo chỉ cần viết lại thông báo lỗi, đã giảm vòng retry tới 40%. "Writing tools for agents" của Anthropic là điểm khởi đầu tốt. Sau khi đọc, hãy thêm quan sát vào các công cụ của bạn, xem mô hình gọi như thế nào trong thực tế. Độ tin cậy của agent gần như luôn tăng lên khi cải thiện phần công cụ. Nhiều người cứ chỉnh prompt mãi, mà bỏ qua vị trí đòn bẩy thực sự. Mô hình orchestrator-subagent ------------------------ Trong năm 2024 và 2025, các tranh luận về đa agent cuối cùng đã hội tụ thành một giải pháp tổng thể mà mọi người đều đang áp dụng. Các hệ thống agent đơn giản, trong đó nhiều agent cùng ghi vào trạng thái chung, sẽ thất bại thảm khốc vì lỗi sẽ tích tụ liên tục. Mức mở rộng của vòng lặp agent đơn thường xa hơn bạn nghĩ. Chỉ có một dạng hệ thống đa agent thực sự hoạt động trong sản xuất: một orchestrator agent, giao nhiệm vụ hạn chế, chỉ đọc, cho các subagent cách ly, rồi tổng hợp kết quả của chúng. Hệ thống nghiên cứu của Anthropic hoạt động theo cách này. Subagents của Claude Code cũng vậy. Spring AI và nhiều framework sản xuất hiện nay cũng đang chuẩn hóa mô hình này. Subagent có ngữ cảnh nhỏ, tập trung, không thể sửa đổi trạng thái chung. Việc ghi dữ liệu do orchestrator đảm nhiệm. Hai bài "Don’t Build Multi-Agents" của Cognition và "How we built our multi-agent research system" của Anthropic có vẻ như đối lập, nhưng thực ra chỉ là cách dùng từ khác để nói cùng một chuyện. Cả hai đều đáng đọc. Mặc định dùng agent đơn. Chỉ khi agent đơn thực sự gặp giới hạn, mới xem xét orchestrator-subagent: ví dụ như áp lực cửa sổ ngữ cảnh, độ trễ do gọi công cụ theo thứ tự, hoặc tính chất nhiệm vụ đa dạng cần tập trung ngữ cảnh. Trước khi cảm nhận rõ các điểm đau, đừng xây dựng hệ thống phức tạp này, vì nó chỉ mang lại sự phức tạp không cần thiết. Evals và bộ dữ liệu vàng ------------ Mỗi nhóm xây dựng agent đáng tin cậy đều có eval. Nhóm không có eval thường không thể tạo ra agent đáng tin cậy. Đây là thói quen có ảnh hưởng lớn nhất trong lĩnh vực này, và cũng là điều tôi thấy bị đánh giá thấp nhất trong các công ty. Thực hành hiệu quả là: thu thập trace trong môi trường sản xuất, đánh dấu các trường hợp thất bại, xem như bộ dữ liệu hồi quy. Mỗi khi có thất bại mới, thêm vào. Phần chủ quan dùng LLM làm judge, phần còn lại dùng so khớp chính xác hoặc kiểm tra lập trình. Trước khi cập nhật prompt, mô hình hay công cụ, chạy thử bộ kiểm thử. Blog của Spotify báo cáo rằng, hệ thống judge của họ có thể chặn khoảng 25% output agent trước khi ra sản phẩm. Nếu không có, cứ bốn kết quả xấu thì có một kết quả đến tay người dùng. Ý tưởng cốt lõi để làm điều này bền vững là: eval như một bài kiểm tra đơn vị, để đảm bảo agent không lệch khỏi nhiệm vụ khi mọi thứ liên tục thay đổi. Mô hình ra phiên bản mới, framework cập nhật phá vỡ, nhà cung cấp bỏ endpoint, eval là thứ duy nhất giúp bạn biết agent còn hoạt động đúng không. Không có eval, bạn đang xây dựng hệ thống dựa trên mục tiêu di động. Các framework eval như Braintrust, Langfuse evals, LangSmith đều khá tốt. Nhưng không phải là giới hạn. Thứ thực sự quan trọng là bạn có bộ dữ liệu đã gắn nhãn hay không. Nên bắt đầu làm ngay từ ngày đầu, trước khi mở rộng. 50 mẫu đầu, có thể tự đánh nhãn trong một buổi chiều. Không có lý do gì để không. Xây dựng hệ thống lưu trữ như trạng thái, và vòng lặp Think-Act-Observe --------------------------------- Đối với bất kỳ agent thực hiện nhiều bước nào, kiến trúc bền vững là: suy nghĩ, hành động, quan sát, lặp lại. Hệ thống lưu trữ hoặc cấu trúc dữ liệu là nguồn chân lý. Mỗi hành động đều được ghi lại, có thể phát lại. Claude Code, Cursor, Devin, Aider, OpenHands, goose đều hướng tới điều này, không phải vô cớ. Mô hình không trạng thái. Khung chạy phải có trạng thái. Hệ thống lưu trữ là nguyên thủy có trạng thái mà mọi nhà phát triển đều hiểu. Khi chấp nhận khung này, toàn bộ quy tắc harness sẽ tự nhiên hình thành: checkpoint, khả năng khôi phục, xác minh sub-agent, sandbox thực thi. Điều sâu hơn là: trong bất kỳ agent sản xuất nào đáng để trả tiền cho tính toán, harness làm nhiều hơn mô hình. Mô hình chọn bước tiếp theo, harness xác nhận, chạy trong sandbox, ghi nhận output, quyết định phản hồi, dừng, checkpoint, tạo subagent. Thay mô hình bằng mô hình khác cùng chất lượng, harness tốt vẫn có thể giao hàng. Thay harness bằng cái kém hơn, dù là mô hình tốt nhất thế giới, cũng sẽ tạo ra agent hay quên mất mình đang làm gì. Nếu bạn xây dựng thứ phức tạp hơn một công cụ gọi đơn thuần, thì nơi bạn nên dành thời gian là harness. Mô hình chỉ là một thành phần trong đó. Hiểu khái niệm MCP ---------- Đừng chỉ học cách gọi MCP server. Hãy hiểu mô hình của nó. Nó đã thiết lập sự phân tách rõ ràng giữa khả năng của agent, công cụ và tài nguyên, và cung cấp các giải pháp mở rộng cho xác thực và truyền tải. Khi hiểu rõ điều này, các "khung tích hợp agent" khác bạn thấy đều giống như phiên bản rút gọn của MCP, và bạn tiết kiệm thời gian đánh giá từng cái. Linux Foundation hiện đang quản lý MCP. Tất cả các nhà cung cấp mô hình chính đều hỗ trợ. Hãy xem nó như "USB-C của AI", giờ đây đã gần như đúng hơn là châm biếm. SandBox là một nguyên thủy nền tảng ---------- Mỗi agent coding sản xuất đều chạy trong sandbox. Mỗi agent trình duyệt đều từng gặp phải prompt injection gián tiếp. Mỗi agent đa thuê bao, ở một giai đoạn nào đó, đều có lỗi về quyền hạn. Bạn nên xem sandbox như một nguyên thủy hạ tầng, chứ không phải tính năng chờ khách yêu cầu mới thêm vào. Học các kiến thức nền tảng: cách cô lập tiến trình, kiểm soát ra vào mạng, quản lý phạm vi khóa, xác thực giữa agent và công cụ. Những nhóm chỉ làm thêm sau khi khách hàng kiểm duyệt an ninh, thường sẽ mất cơ hội. Những nhóm làm từ tuần đầu tiên, sẽ dễ dàng vượt qua quy trình mua bán doanh nghiệp. Bạn nên dùng gì để xây dựng ====== Dưới đây là các lựa chọn cụ thể đến tháng 4 năm 2026. Những lựa chọn này sẽ thay đổi, nhưng không quá nhanh. Ở cấp độ này, nên chọn những thứ "nhàm chán nhưng ổn định". Lớp điều phối --- LangGraph là lựa chọn mặc định trong môi trường sản xuất. Khoảng một phần ba các công ty lớn chạy agent đều dùng nó. Cách trừu tượng của nó phù hợp với hình thái thực của hệ thống agent: trạng thái có kiểu, điều kiện biên, luồng công việc lâu dài, kiểm tra điểm người dùng. Nhược điểm là viết hơi dài dòng; ưu điểm là khi một agent thực sự đi vào sản xuất, bạn cần kiểm soát những thứ này, và chính sự dài dòng phù hợp với yêu cầu kiểm soát đó. Nếu bạn chủ yếu dùng TypeScript, Mastra là lựa chọn thực tế. Đây là giải pháp có mô hình tư duy rõ ràng nhất trong hệ sinh thái này. Nếu nhóm bạn thích Pydantic, và muốn kiểu an toàn là ưu tiên hàng đầu, Pydantic AI là lựa chọn hợp lý cho greenfield. Phiên bản 1.0 của nó ra cuối 2025, thực sự có tiềm năng. Nếu là công việc native của nhà cung cấp, như sử dụng máy tính, thoại, tương tác thời gian thực, có thể dùng Claude Agent SDK hoặc OpenAI Agents SDK trong node của LangGraph. Đừng cố biến chúng thành bộ điều phối đa hệ thống. Chúng tối ưu cho các kịch bản riêng của mình. Giao thức --- MCP, không gì khác. Hãy tích hợp bộ công cụ của bạn thành MCP server. Việc tích hợp bên ngoài cũng dùng cách này. Hiện tại, registry của MCP đã vượt qua điểm tới hạn: trong hầu hết các trường hợp, trước khi bạn tự xây, đã có sẵn server phù hợp. Đến 2026, còn nhiều người vẫn viết thủ công các đường ống công cụ, coi như phí tổn không đáng kể. Giao diện bộ nhớ --- Chọn hệ thống nhớ dựa trên mức độ độc lập của agent, chứ không phải theo độ hot. Mem0 phù hợp cho cá nhân hóa dạng chat: sở thích người dùng, lịch sử nhẹ. Zep phù hợp cho hệ thống hội thoại sản xuất, đặc biệt khi trạng thái liên tục biến đổi, cần theo dõi thực thể. Letta phù hợp cho agent cần duy trì nhất quán trong vài ngày hoặc vài tuần làm việc. Phần lớn nhóm không cần, nhưng nhóm thực sự cần thì cần chính là nó. Sai lầm phổ biến là: chưa có vấn đề về nhớ đã vội chọn framework nhớ. Bắt đầu từ nội dung có thể chứa trong cửa sổ ngữ cảnh, rồi thêm một cơ sở dữ liệu vector. Chỉ khi rõ ràng xác định được các mô hình thất bại cần giải quyết, mới thêm hệ thống nhớ. Quan sát và eval ----------- Langfuse là lựa chọn mã nguồn mở mặc định. Nó có thể tự host, dùng giấy phép MIT, bao gồm tracing, quản lý phiên bản prompt, và evals kiểu LLM-as-judge. Nếu bạn đã dùng LangChain, tích hợp của LangSmith sẽ chặt chẽ hơn. Braintrust phù hợp cho các luồng eval nghiên cứu, đặc biệt khi cần so sánh chặt chẽ. OpenLLMetry / Traceloop phù hợp cho các hệ đa ngôn ngữ cần instrumentation OpenTelemetry không thương hiệu. Bạn cần có cả tracing và evals. Tracing trả lời câu hỏi: "agent đã làm gì?" Evals trả lời: "agent đã tốt hơn hôm qua hay tệ hơn?" Không có hai thứ này, đừng ra sản phẩm. Ngay từ ngày đầu, hãy thiết lập chúng, chi phí thấp hơn nhiều so với làm sau này. Thời gian chạy và sandbox ------ E2B phù hợp cho thực thi mã sandbox chung. Browserbase kết hợp Stagehand, phù hợp tự động hóa trình duyệt. Anthropic Computer Use phù hợp cho các kịch bản cần kiểm soát hệ điều hành thực. Modal phù hợp cho nhiệm vụ đột xuất ngắn hạn. Không bao giờ chạy mã chưa sandbox. Một agent bị tấn công prompt injection, nếu chạy trực tiếp trong môi trường sản xuất, sẽ gây ra thảm họa mà bạn không muốn kể cho ai nghe. Mô hình -- Theo đuổi benchmark mệt mỏi, và phần lớn không mang lại nhiều lợi ích. Thực tế đến tháng 4 năm 2026: ·Claude Opus 4.7 và Sonnet 4.6 phù hợp cho gọi công cụ đáng tin cậy, đa bước, và phục hồi lỗi mượt mà. Với đa số khối lượng công việc, Sonnet là điểm cân bằng giữa chi phí và hiệu năng. ·GPT-5.4 và GPT-5.5 phù hợp cho các yêu cầu suy luận CLI / terminal mạnh nhất, hoặc khi bạn đã quen sống trong hạ tầng của OpenAI. ·Gemini 2.5 và 3 phù hợp cho các nhiệm vụ có độ dài ngữ cảnh cao, hoặc đa phương thức. ·Khi chi phí quan trọng hơn hiệu năng tối đa, đặc biệt với các nhiệm vụ rõ ràng, giới hạn, có thể xem DeepSeek-V3.2 hoặc Qwen 3.6. Xem mô hình như một thành phần có thể thay thế. Nếu agent của bạn chỉ hoạt động trên một mô hình duy nhất, đó không phải là lợi thế cạnh tranh, mà là điểm yếu. Dùng evals để quyết định mô hình nào phù hợp để triển khai. Đánh giá lại mỗi quý, đừng thay đổi hàng tuần. Điều gì có thể bỏ qua ====== Bạn sẽ liên tục bị khuyên học, dùng những thứ sau đây. Thực ra, không cần thiết. Bỏ qua chúng có chi phí thấp, tiết kiệm thời gian lớn. AutoGen và AG2, không dùng cho sản xuất. Framework của Microsoft đã chuyển sang cộng đồng duy trì, tốc độ phát hành chậm, cách trừu tượng không phù hợp với thực tế nhóm sản xuất. Có thể dùng để nghiên cứu, nhưng đừng đặt niềm tin vào sản phẩm. CrewAI, không dùng để xây dựng sản phẩm mới. Nó xuất hiện khắp nơi vì phù hợp làm demo. Các kỹ sư xây dựng hệ thống thực sự đã chuyển sang dùng nó để prototype, đừng dùng lâu dài. Microsoft Semantic Kernel, trừ khi bạn đã khóa chặt trong hệ sinh thái Microsoft, và khách hàng của bạn cũng quan tâm. Nó không phải hướng đi của hệ sinh thái. DSPy, trừ khi bạn tối ưu prompt quy mô lớn. Có giá trị triết lý, nhưng đối tượng rất hẹp. Không phải framework agent chung, đừng chọn như một framework chung. Chuyển đổi agent viết mã độc lập thành kiến trúc. Code-as-action là hướng nghiên cứu thú vị, nhưng chưa phải mô hình mặc định trong sản xuất. Bạn sẽ gặp nhiều vấn đề về công cụ, an ninh, trong khi đối thủ có thể không cần xử lý. Chào mời kiểu "Autonomous agent". AutoGPT, BabyAGI đã chết con đường này. Ngành công nghiệp cuối cùng chấp nhận "kỹ thuật agentic": có giám sát, có giới hạn, có đánh giá. Ai còn bán "không cần quản sau khi triển khai" vào 2026, thực chất đang bán thứ của năm 2023. Cửa hàng ứng dụng agent và marketplace. Từ 2023, đã có người hứa hẹn, nhưng chưa thực sự thu hút doanh nghiệp. Doanh nghiệp không mua agent chung chung, hoặc mua agent theo kết quả cụ thể, hoặc tự xây. Đừng dựa vào ý tưởng về app store để định hình doanh nghiệp. Chọn platform doanh nghiệp "xây agent bất kỳ" theo chiều ngang. Ví dụ Google Agentspace, AWS Bedrock Agents, Microsoft Copilot Studio. Chúng có thể hữu ích sau này, nhưng hiện tại còn rối, phát hành chậm, và xu hướng mua hay xây vẫn nghiêng về tự xây agent hẹp hoặc mua agent theo ngành. Salesforce Agentforce, ServiceNow Now Assist là ngoại lệ, vì đã tích hợp sẵn trong hệ thống workflow của bạn. Đừng theo đuổi bảng xếp hạng SWE-bench hay OSWorld. Năm 2025, các nhà nghiên cứu Berkeley ghi nhận hầu hết benchmark công khai đều có thể bị "đánh điểm ảo", không thực sự phản ánh nhiệm vụ cốt lõi. Hiện tại, các nhóm dùng Terminal-Bench 2.0 và evals nội bộ như tín hiệu chân thực hơn. Nghi ngờ các benchmark dựa trên số liệu đơn lẻ. Kiến trúc đa agent song song ngây thơ. Năm agent trò chuyện dựa trên bộ nhớ chung, trông có vẻ hay trong demo, nhưng khi đưa vào sản xuất sẽ sụp đổ. Nếu không thể vẽ rõ sơ đồ orchestrator-subagent trên giấy, và chỉ rõ ranh giới đọc ghi, đừng triển khai. Sản phẩm agent mới đừng dùng giá theo chỗ ngồi SaaS. Thị trường đã chuyển sang mô hình dựa trên kết quả và sử dụng. Phí theo chỗ ngồi không chỉ giảm lợi nhuận, còn gửi tín hiệu rằng bạn không tin sản phẩm có thể giao kết quả. Tuần này, bạn thấy framework mới trên Hacker News. Chờ sáu tháng. Nếu sau đó vẫn còn quan trọng, bạn sẽ rõ. Nếu không, bạn đã tiết kiệm một lần chuyển đổi. Cách tiến hành cụ thể ======= Nếu bạn không chỉ muốn "theo kịp agent", mà thực sự muốn áp dụng agent, theo thứ tự sau là hợp lý. Nó có vẻ nhàm chán, nhưng rất hữu ích. Bước đầu chọn một kết quả đã quan trọng. Đừng chọn mục tiêu quá xa vời, đừng bắt đầu bằng một dự án "nền tảng agent" toàn diện. Chọn một thứ liên quan đến kinh doanh của bạn, có thể đo lường được: giảm ticket dịch vụ khách hàng, tạo bản dự thảo pháp lý đầu tiên, lọc inbound leads, tạo báo cáo tháng. Thành công của agent phụ thuộc vào việc nó cải thiện kết quả này. Từ ngày đầu, đó đã là mục tiêu eval của bạn. Bước này quan trọng nhất vì nó định hướng mọi quyết định sau đó. Có kết quả rõ ràng, việc chọn framework không còn là vấn đề triết lý nữa, mà là chọn framework nhanh nhất để giao kết quả đó. Việc chọn mô hình cũng không còn là tranh luận benchmark, mà là chọn mô hình phù hợp dựa trên evals chứng minh hiệu quả trong nhiệm vụ cụ thể. Việc có cần nhớ, subagents, harness tùy chỉnh hay không cũng không còn là thí nghiệm tư duy, mà chỉ thêm khi thực sự gặp các mô hình thất bại. Nhóm bỏ qua bước này thường sẽ tạo ra một nền tảng rộng rãi, không phù hợp, mất nhiều thời gian. Nhóm chú trọng bước này sẽ tạo ra agent hẹp, có thể hoàn vốn trong một quý. Và agent thực sự ra mắt sẽ dạy họ nhiều hơn đọc hai năm bài viết. Trước khi ra sản phẩm, hãy thiết lập tracing và evals. Dùng Langfuse hoặc LangSmith, kết nối chúng. Nếu cần, tự xây bộ dữ liệu vàng nhỏ, 50 mẫu đã đủ bắt đầu. Bạn không thể cải thiện thứ bạn không đo lường. Sau này, bổ sung hệ thống này sẽ tốn gấp 10 lần so với làm ngay từ đầu. Bắt đầu từ vòng lặp đơn agent. Chọn LangGraph hoặc Pydantic AI. Mô hình chọn Claude Sonnet 4.6 hoặc GPT-5. Cung cấp 3-7 công cụ thiết kế tốt. Để agent dùng hệ thống file hoặc database làm trạng thái. Ban đầu, thử nghiệm với nhóm nhỏ, quan sát traces. Xem agent như một sản phẩm, không chỉ là dự án. Nó sẽ thất bại theo cách bạn không lường trước, và những thất bại đó chính là bản đồ đường đi của bạn. Dùng trace thực để xây bộ dữ liệu hồi quy. Mỗi lần thay prompt, thay mô hình, thay công cụ, đều phải qua evals trước khi deploy. Nhiều nhóm đánh giá thấp bước này, nhưng chính nó tạo ra độ tin cậy. Chỉ khi đã đủ tự tin mở rộng, mới tăng độ phức tạp. Khi ngữ cảnh bị giới hạn, mới dùng subagents. Khi nội dung cần nhiều hơn một cửa sổ, mới dùng framework nhớ. Khi API nền tảng không còn đủ, mới dùng computer use hoặc browser use. Đừng làm sớm, để các mô hình thất bại kéo chúng vào. Chọn hạ tầng nhàm chán. Dùng MCP cho công cụ. Sandbox dùng E2B hoặc Browserbase. Trạng thái dùng Postgres hoặc hệ thống dữ liệu hiện có. Xác thực và quan sát theo hệ thống hiện tại. Những hạ tầng kỳ quặc ít khi quyết định thắng thua, chính kỷ luật mới quyết định. Từ ngày đầu, theo dõi mô hình kinh tế đơn vị. Chi phí mỗi hành động, tỷ lệ cache hit, vòng retry, phân phối gọi mô hình. Trong PoC, agent có vẻ rẻ, nhưng nếu không theo dõi chi phí theo kết quả, khi mở rộng 100 lần, chi phí sẽ bùng nổ. Một PoC 0.50 USD mỗi lần chạy, quy mô trung bình có thể lên tới 50.000 USD mỗi tháng. Nhóm không dự báo trước sẽ gặp vấn đề tài chính lớn. Mỗi quý, đánh giá lại mô hình, không phải mỗi tuần. Chọn một quý, cuối quý chạy eval suite với mô hình mới nhất. Nếu dữ liệu cho thấy cần đổi, thì đổi. Như vậy, bạn sẽ hưởng lợi từ tiến bộ của mô hình, mà không bị rối loạn mỗi lần cập nhật. Làm thế nào để nhận biết xu hướng ====== Dưới đây là một số tín hiệu cụ thể cho thấy điều gì đó có thể là tín hiệu thật: một nhóm kỹ sư uy tín viết bài có số liệu, không chỉ tuyên bố có nhiều người dùng; đó là nguyên thủy nền tảng như giao thức, mô hình hoặc hạ tầng, chứ không phải là lớp vỏ; nó có thể tương tác với hệ thống bạn đã vận hành, không thay thế; pitch của nó nói về cách giải quyết các mô hình thất bại, chứ không phải mở ra khả năng mới; đã tồn tại đủ lâu để có thể viết blog "những chỗ chưa hiệu quả". Ngược lại, một số tín hiệu cho thấy đó chỉ là nhiễu loạn: sau 30 ngày ra mắt vẫn chỉ có video demo, chưa có trường hợp sản xuất; benchmark tăng vọt một cách không tự nhiên; pitch toàn dùng "autonomous", "agent OS" hoặc "build any agent" mà không giới hạn; tài liệu framework mặc định bỏ qua các hệ thống tracing, xác thực, cấu hình hiện có; star tăng nhanh nhưng commits, releases, contributors không theo kịp; tốc độ trên Twitter nhanh, nhưng trên GitHub lại chậm. Thói quen hữu ích hàng tuần là dành 30 phút cuối tuần để xem lĩnh vực này. Đọc ba thứ: blog của Anthropic, ghi chú của Simon Willison, Latent Space. Nếu tuần đó có bài review, đọc thêm một hai bài nữa. Những thứ quan trọng thực sự, bạn sẽ không bỏ lỡ. Điều gì đáng theo dõi trong tương lai ========= Trong hai quý tới, không phải vì chúng chắc chắn thắng, mà vì câu hỏi "đây có phải tín hiệu thực" vẫn chưa rõ ràng. Mô hình phân nhánh song song của Replit Agent 4. Đây là một trong những thử nghiệm đầu tiên về "đa agent làm việc song song" nhưng không bị ràng buộc bởi trạng thái chung. Nếu thành công, mô hình orchestrator-subagent có thể thay đổi. Độ trưởng thành của mô hình định giá dựa trên kết quả. Sierra và Harvey đã chứng minh mô hình này trong các lĩnh vực hẹp. Câu hỏi là, nó có thể mở rộng ra các lĩnh vực khác không, hay chỉ phù hợp cho các ngành hẹp. Kỹ năng như

Tính giá Anthropic