Synapse: Hành trình xây dựng hệ thống Agent cá nhân có trí nhớ và tự tiến hóa

Hơn một tháng trước, tôi nhìn vào đống script Python lởm chởm đang tự động hóa vài việc lặt vặt: nào là cron job gửi tin nhắn Telegram, nào là mấy đoạn code gọi ChatGPT để tóm tắt email. Chúng “hoạt động”, nhưng như một lũ zombie — không có ký ức, không học hỏi, chỉ biết lặp đi lặp lại đúng những gì đã được lập trình. Nếu tôi muốn chúng hoạt động tốt hơn, tôi phải tự tay mổ xẻ code mỗi lần.

Tôi đã hỏi: Điều gì sẽ xảy ra nếu tôi xây dựng một hệ thống agent thực sự dành cho cá nhân? Một hệ thống không chỉ thực thi công việc, mà còn ghi nhớ mọi thứ nó đã làm, rút ra bài học từ sai lầm và tự cải thiện theo thời gian mà tôi không cần can thiệp nhiều?

Câu trả lời là Synapse — hệ thống agent cá nhân tôi thiết kế để vừa là trợ lý tự động, vừa là đối tác học tập suốt đời. Nó được xây dựng trên một “bộ não” riêng biệt mang tên Engram (vết ký ức). Bài viết này là câu chuyện chi tiết về kiến trúc, triết lý thiết kế, và lộ trình từng bước để biến ý tưởng đó thành hiện thực — ngay cả khi bạn chỉ là một lập trình viên đơn độc với chiếc máy tính cá nhân.

Lưu ý với người mới bắt đầu: Đừng sợ những thuật ngữ như “Engram” hay “Instinct Crystallization”. Tôi sẽ giải thích chúng một cách trực quan khi đi qua từng phần. Bài viết dài, nhưng được chia thành các phần rõ ràng để bạn có thể nhảy đến bất kỳ đâu.

Mục lục

Tại sao lại là một hệ thống Agent cá nhân?
Triết lý thiết kế: 5 nguyên tắc bất di bất dịch
Kiến trúc tổng thể: Ba lớp, hai thành phần
Đi sâu vào các thành phần cốt lõi
Vòng lặp tự cải thiện (Self-Improvement Loop)
Lộ trình xây dựng: Từ số 0 đến hệ thống tự vận hành trong 16 tuần
Các mẫu thiết kế và “bẫy” cần tránh
Bài học cá nhân và lời khuyên cho người xây dựng
Kết luận: Hành trình của một kỹ sư AI

1. Tại sao lại là một hệ thống Agent cá nhân?

Trước khi bắt tay vào viết code, tôi đã thử hầu hết các giải pháp trên thị trường: Zapier/n8n để nối workflow không cần code, LangChain/CrewAI để build agent nhanh, thậm chí cả những nền tảng AI đóng hộp như Manus hay Genspark. Tất cả đều có một điểm chung: chúng không thực sự học hỏi từ chính hành vi của tôi. Chúng hoặc là workflow cố định, hoặc là mô hình đen (black box) không cho tôi kiểm soát dữ liệu và khả năng tùy chỉnh sâu.

Tôi muốn một thứ gì đó khác biệt:

Tự động hóa công việc hàng ngày một cách thông minh, biết thích nghi theo lịch trình và thói quen của tôi.
Mở rộng được: từ một agent nhỏ thành một đội quân agent phối hợp nhịp nhàng.
Có khả năng tự cải thiện: nếu hôm nay nó phân loại email sai, ngày mai nó có thể tự động học cách không lặp lại sai lầm đó.

Và điều quan trọng nhất: toàn bộ hệ thống phải local-first, mã nguồn mở, và tách biệt rõ ràng giữa trí nhớ (memory) và hành động (execution). Không ai khác giữ dữ liệu của tôi, và tôi có thể mang “bộ não” này gắn vào bất kỳ ứng dụng nào khác trong tương lai.

Kết quả là Synapse ra đời. Còn Engram là thành phần lưu trữ ký ức độc lập, có thể dùng riêng lẻ như một thư viện.

2. Triết lý thiết kế: 5 nguyên tắc bất di bất dịch

Trước khi viết dòng code đầu tiên, tôi đã đặt ra 5 nguyên tắc sống còn. Chúng là la bàn cho mọi quyết định về sau:

1. Memory và Execution phải tách rời

Trong hầu hết các framework agent hiện nay (kể cả Letta/MemGPT), vòng lặp suy luận và bộ nhớ được ghép chặt vào nhau. Agent tự quản lý lịch sử hội thoại, dẫn đến khó chia sẻ trí nhớ giữa các agent và khó debug.
Giải pháp của tôi: Engram là bộ nhớ dùng chung. Agent chỉ đọc/ghi qua Engram, không tự giữ memory riêng. Nó giống như một cái “bảng đen” (blackboard) trong phòng thí nghiệm: mọi agent đều viết lên đó và đọc từ đó.

2. Mọi giao tiếp giữa các agent đều qua Engram

Sub-agent không bao giờ nói chuyện trực tiếp với nhau. Chúng trao đổi thông tin bằng cách ghi observation vào Engram, và agent khác sẽ được kích hoạt khi có sự kiện mới. Mô hình này gọi là Blackboard Pattern, giúp toàn bộ hệ thống trở nên tường minh, có thể lần theo dấu vết và kiểm tra được từng trạng thái.

3. Cách ly ngữ cảnh triệt để cho sub-agent

Khi một agent chính (main agent) gọi một sub-agent để thực hiện tác vụ con, main agent không bao giờ thấy toàn bộ quá trình suy luận của sub-agent. Nó chỉ nhận được kết quả cuối cùng. Điều này giúp tránh hiện tượng “ăn” context window của nhau và bảo vệ tính riêng tư trong suy nghĩ của từng agent. Tôi gọi đây là Zero-Context-Cost Evolution.

4. Mỗi agent là một kỹ năng (skill) theo chuẩn agentskills.io

Thay vì định nghĩa agent bằng code rời rạc, mỗi agent được đóng gói trong một file SKILL.md kèm theo script. Thêm agent mới chỉ đơn giản là tạo một thư mục mới. Điều này nhất quán với tầng Knowledge của Engram sau này, và cho phép tôi xuất khẩu, chia sẻ agent như một “brainshard” (mảnh não).

5. Vòng lặp tự cải thiện là tính năng cốt lõi, không phải phần thêm vào

Mỗi lần agent chạy (một episode) đều được ghi lại đầy đủ vào Engram, bao gồm cả thành công và thất bại. Sau một thời gian, Engram sẽ phân tích các mẫu hành vi và đề xuất những “bản năng” (instinct) mới — ví dụ: “Email từ @substack.com luôn bị phân loại nhầm thành khẩn cấp, đề xuất bỏ qua”. Người dùng chỉ cần phê duyệt hoặc từ chối. Vòng lặp đóng này là lý do tồn tại của toàn bộ hệ thống.

3. Kiến trúc tổng thể: Ba lớp, hai thành phần

Synapse và Engram cùng nhau tạo thành một hệ thống 3 lớp:

┌─────────────────────────────────────────────────────┐
│  LỚP GIAO DIỆN: Telegram, CLI (Typer), Cron job     │
└────────────────────────┬────────────────────────────┘
                         │ (sự kiện, lệnh, yêu cầu phê duyệt)
┌────────────────────────▼────────────────────────────┐
│  SYNAPSE (Hệ thực thi)                              │
│  ┌──────────────┐  ┌──────────────┐                │
│  │ Harness      │  │ Agent Runtime│                │
│  │ (router,     │  │ (vòng lặp    │                │
│  │  spawner,    │  │  ReAct,      │                │
│  │  quality gate│  │  LLM Router, │                │
│  │  HITL,       │  │  công cụ)    │                │
│  │  budget)     │  │              │                │
│  └──────────────┘  └──────────────┘                │
└────────────────────────┬────────────────────────────┘
                         │ đọc/ghi qua Python SDK
┌────────────────────────▼────────────────────────────┐
│  ENGRAM (Bộ nhớ)                                   │
│  ┌─────────────────────────────────────────────┐   │
│  │ L1: Identity Core │ L2: Knowledge/Skills    │   │
│  │ L3: Episodic Memory│ L4: Active Context     │   │
│  │ Engine Tiến hóa   │ Context Builder         │   │
│  └─────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────┘

Engram: Lưu trữ danh tính người dùng (Identity), kiến thức và kỹ năng (Knowledge), ký ức tình huống (Episodic), và ngữ cảnh hiện tại (Active Context). Nó cũng chứa “Evolution Engine” để phân tích dữ liệu và đề xuất cải tiến.
Synapse: Hệ thực thi, gồm hai phần chính: Harness (điều phối agent, quản lý tiến trình) và Runtime (vòng lặp suy luận của từng agent, định tuyến LLM, công cụ).

Cả hai chia sẻ chung lớp giao diện (Telegram, CLI) và lớp lưu trữ. Synapse không có database riêng; mọi thứ đều được ghi vào Engram.

4. Đi sâu vào các thành phần cốt lõi

4.1 Lớp Harness: Bộ điều phối thông minh

Harness giống như “hệ thần kinh trung ương” quản lý toàn bộ agent. Nó có 5 thành phần:

a. Task Router

Nhận mọi input từ người dùng (tin nhắn Telegram, cron trigger, webhook) và phân loại ý định để dispatch đến agent phù hợp.

Với lệnh rõ ràng (/morning-brief), dùng rule-based để chọn agent.
Với ngôn ngữ tự nhiên (“Tóm tắt tuần này giúp tôi”), dùng LLM classifier. Kết quả là một đối tượng AgentInvocation gồm: tên agent, dữ liệu đầu vào, hạn mức ngân sách, mức phê duyệt.

b. Sub-agent Spawner

Khi một agent cần thực hiện tác vụ con (ví dụ: research 5 công ty cùng lúc), Harness sẽ tạo tiến trình riêng biệt (multiprocessing.Process) để đảm bảo cô lập thực sự. Sub-agent có context riêng, không dùng chung bộ nhớ với agent mẹ. Kết thúc, nó chỉ trả về kết quả cuối cùng qua Queue, không để lộ bước suy luận trung gian.

c. Quality Gate (Cổng kiểm soát chất lượng trí nhớ)

Mỗi khi một agent muốn ghi dữ liệu vào Engram (ví dụ: một fact mới, một bài học), dữ liệu đó phải đi qua Quality Gate. Gate hoạt động theo mô hình Producer-Reviewer:

Producer (agent tạo ra dữ liệu) gửi đề xuất.
Reviewer (một sub-agent riêng, dùng LLM khác hoặc cùng LLM với temperature khác) kiểm tra: có trùng lặp không? Có mâu thuẫn với kiến thức cũ không? Có đúng định dạng không? Chỉ khi Reviewer đồng ý, dữ liệu mới được commit. Điều này ngăn “echo chamber” (buồng vọng âm) khi dùng cùng một phiên chat để kiểm tra.

d. Human-in-Loop Gate (Cổng phê duyệt của con người)

Bất kỳ hành động nào có tác động ra thế giới thực (gửi email, xuất bản, thanh toán) đều phải qua bước phê duyệt của tôi. Agent tạo một PendingAction và gửi tin nhắn Telegram kèm các nút [Chấp nhận] [Sửa] [Từ chối] [Bỏ qua]. Nếu sau 4 giờ không phản hồi, hành động tự động bị từ chối. Quyết định này được ghi vào Engram, dần dần hình thành “instinct” (ví dụ: “Nhan luôn từ chối gửi email tự động vào cuối tuần”).

e. Budget Controller (Kiểm soát chi phí)

Mỗi lần agent chạy đều bị giới hạn cứng: số token tối đa, chi phí tối đa, thời gian thực thi tối đa. Hệ thống cũng có hạn mức chi tiêu hàng tháng; nếu vượt quá, các agent dùng mô hình đắt tiền sẽ bị vô hiệu hóa và gửi cảnh báo qua Telegram.

4.2 Lớp Runtime: Bên trong một agent

Mỗi agent chạy theo một vòng lặp ReAct cải tiến:

1. Nạp ngữ cảnh từ Engram (Danh tính, kỹ năng liên quan, tập ký ức gần đây, bản năng)
2. Lập kế hoạch: LLM tạo danh sách các bước và tiêu chí thành công
3. Thực thi từng bước:
   - Gọi công cụ (tool) → dispatch
   - Gọi sub-agent → spawn tiến trình cô lập
   - Ghi nhớ → qua Quality Gate
   - Hành động ra ngoài → qua HITL Gate
4. Phản ánh: bước đó thành công? Còn ngân sách không? Có cần lập lại kế hoạch?
5. Khi hoàn thành: ghi trajectory (nhật ký chi tiết) vào Engram Layer 3.

LLM Router là một Strategy Pattern: dựa vào loại tác vụ (routine, important, bulk), hệ thống sẽ chọn provider phù hợp:

routine → Gemini Flash (free)
important → Claude Haiku (độ chính xác cao)
bulk → DeepSeek (rẻ, xử lý hàng loạt) Nếu provider chính lỗi, router sẽ tự động fallback xuống provider dự phòng. Tất cả các lần gọi LLM đều được ghi vào JSONL để theo dõi chi phí.

Tool Registry cho phép agent gọi các công cụ bên ngoài như Gmail, Calendar, Hacker News, HTTP request… Mỗi công cụ được đăng ký qua decorator @tool(name="...") để dễ dàng thêm mới.

4.3 Lớp Memory (Engram): Ký ức tiến hóa

Engram không chỉ là nơi lưu file. Nó có 4 tầng:

L1 – Identity Core: Thông tin cốt lõi về người dùng (tên, mục tiêu, giá trị). Dùng JSON, luôn được nạp vào context.
L2 – Knowledge Base: Chứa kỹ năng (định dạng agentskills.io), kiến thức tích lũy, và các “instinct” đã kết tinh.
L3 – Episodic Memory: Nhật ký của từng lần agent chạy, gồm đầy đủ trajectory, token sử dụng, chi phí, thành công/thất bại, và tự đánh giá. Về sau, tầng này sẽ dùng SQLite FTS5 để tìm kiếm toàn văn bản.
L4 – Active Context: Ngữ cảnh hiện tại của hệ thống (session, task queue, …), giúp tối ưu việc nạp dữ liệu.

Context Builder là thành phần quyết định agent sẽ “nhìn thấy” gì khi khởi động. Thay vì nhồi nhét toàn bộ quá khứ, nó nạp bất đối xứng: chỉ lấy những tập ký ức liên quan nhất đến tác vụ hiện tại (qua tìm kiếm từ khóa và sau này là embedding similarity).

5. Vòng lặp tự cải thiện (Self-Improvement Loop) – Trái tim của hệ thống

Đây là thứ khiến Synapse khác biệt với mọi agent framework ngoài kia. Vòng lặp diễn ra tự động hàng tuần:

Agent chạy → kết thúc, ghi Episode vào Engram L3, kèm theo phản ánh (reflection) do chính agent viết.
Cuối tuần, Evolution Engine của Engram khởi động. Nó chạy DBSCAN clustering trên các embedding của các tập ký ức để tìm cụm các tình huống tương tự. Ví dụ: phát hiện 7 trong 30 lần, email từ newsletter bị phân loại nhầm là khẩn cấp.
Đề xuất Instinct: Evolution Engine soạn một đề xuất gửi lên Telegram: “Tôi nhận thấy bạn thường bỏ qua email từ @substack.com. Thêm instinct: ‘Các email từ tên miền newsletter luôn có độ ưu tiên thấp’?” Kèm theo ba ví dụ thực tế.
Người dùng phê duyệt (hoặc từ chối/sửa). Nếu đồng ý, instinct đó được ghi vào Engram L2 (Knowledge).
Agent đọc instinct mới: Lần chạy tiếp theo, Context Builder sẽ nạp instinct đó vào prompt. Nhờ vậy, agent sẽ tự động cư xử khác đi mà không cần ai sửa code.

Toàn bộ quy trình này không yêu cầu tôi phải dành hàng giờ để chỉnh sửa prompt. Mỗi tuần tôi chỉ cần 10 phút để duyệt các đề xuất. Đó là sự tự động hóa đúng nghĩa.

6. Lộ trình xây dựng: Từ số 0 đến hệ thống tự vận hành trong 16 tuần

Đây là bản kế hoạch chi tiết tôi đã theo đuổi. Nó được chia thành các phase, mỗi phase kết thúc bằng một sản phẩm chạy được.

Phase 0: Foundation (Tuần 1–2)

Mục tiêu: 1 agent chạy ổn định, có thể mở rộng.
Các bước chính:

Thiết lập repo synapse/, cấu trúc thư mục cơ bản.
Xây dựng Engram MVP: Identity JSON + Episodic (file markdown).
Agent Core tối thiểu: nạp SKILL.md → prompt → LLM call → ghi episode.
LLM Router với Gemini Flash + DeepSeek fallback.
Telegram Bot nhận lệnh và gửi output.
Agent đầu tiên: Morning Brief (tóm tắt email, lịch, tin tức sáng).
Kết quả: agent tự chạy lúc 7h sáng mỗi ngày, không cần can thiệp.

Bài học quan trọng: Cuối tuần 2, bạn phải có một thứ gì đó thực sự gửi tin nhắn cho bạn mỗi sáng. Đừng chờ tới khi hoàn hảo.

Phase 1: Harness + Multi-agent (Tuần 3–6)

Mục tiêu: 5 agent cùng tồn tại, có Human-in-the-Loop.
Các agent mới: Email Triage, Weekly Review, Feynman Prompt, Reading Queue.
Xây dựng Task Router, HITL Gate qua Telegram inline button, Quality Gate sơ khai, và Sub-agent Spawner. Budget Controller bắt đầu giới hạn cứng.
Sau phase này, tổng chi phí LLM dưới 3 USD/tháng.

Phase 2: Self-Improvement Loop (Tuần 7–10)

Mục tiêu: Vòng phản hồi đóng hoàn chỉnh.
Xây dựng Engram L2 (Knowledge), L4 (Active Context), Evolution Engine, FTS5 search, và Context Builder thông minh. Quality Gate nhận LLM Reviewer thực thụ.
Có ít nhất một lần: “Engram đề xuất cập nhật skill → tôi duyệt → agent dùng skill mới → episode sau cải thiện rõ rệt”.

Phase 3: Instinct Crystallization + Meta-agent (Tuần 11–14)

Mục tiêu: Hệ thống bắt đầu tự “kết tinh” bản năng.
DBSCAN clustering trên embedding để tìm pattern. Meta-agent quan sát toàn bộ hệ thống, đề xuất agent nào underperform, kỹ năng nào không dùng, và tự động thử nghiệm A/B testing prompt.
Khi có ít nhất 3 instinct đã kết tinh và được dùng thực tế, phase này hoàn thành.

Phase 4: Open up + Content (Tuần 15–16+)

Mục tiêu: Chia sẻ và lan tỏa.
Mã nguồn Synapse được mở (Engram có thể giữ riêng nếu có dữ liệu nhạy cảm). Viết blog series về quá trình xây dựng. Tạo cộng đồng nho nhỏ trên GitHub.

7. Các mẫu thiết kế và “bẫy” cần tránh

Trong quá trình code, tôi đã cố gắng áp dụng một số mẫu thiết kế (design pattern) để code sạch và dễ mở rộng. Ngược lại, cũng có những sai lầm khiến hệ thống sớm trở thành mớ hỗn độn. Dưới đây là những thứ tôi tâm đắc nhất.

8 mẫu thiết kế đã cứu tôi

Strategy: LLM Router cho phép thay đổi provider (Gemini, Claude, DeepSeek) mà không ảnh hưởng đến agent. Tôi dùng Python Protocol thay vì kế thừa cứng nhắc.
Repository: Tầng truy cập Engram ẩn đi chi tiết lưu trữ (JSON, SQLite). Agent không biết dữ liệu đến từ đâu.
Template Method: Lớp AgentBase định nghĩa khung vòng đời run(), các agent con chỉ cần override plan() và execute().
Decorator: Dùng để đăng ký công cụ (@tool), retry (@retry), đo thời gian (@log_timing) mà không làm bẩn logic chính.
Registry: Một dict toàn cục ánh xạ tên agent/công cụ tới class/function. Nhờ đó tôi có thể thêm agent mới chỉ bằng cách bỏ thư mục vào, hệ thống tự nhận diện.
Chain of Responsibility: Quality Gate với các bước kiểm tra nối tiếp nhau: trùng lặp → định dạng → mâu thuẫn → độ tin cậy.
Retry with Exponential Backoff: Mọi lời gọi API bên ngoài đều được bọc trong retry logic với tenacity, tránh crash vì mạng chập chờn.
Blackboard: Giao tiếp giữa các agent qua Engram thay vì gọi trực tiếp.

10 “bẫy chết người” tôi đã học được từ kinh nghiệm xương máu

Class everywhere: Đừng biến mọi thứ thành class. Python ưu tiên function; chỉ dùng class khi có state và behavior đi kèm.
Framework madness: Tôi đã cài thử LangChain, và rồi vứt bỏ. Học xây dựng từ requests và pydantic giúp tôi hiểu sâu hơn gấp trăm lần.
God agent: Một agent làm 5 việc. Sau này thành cơn ác mộng bảo trì. Mỗi agent chỉ nên có một trách nhiệm.
Sync HTTP in loop: 10 URL gọi tuần tự mất 20 giây. Dùng asyncio.gather giảm xuống 2 giây.
Bare except:: Nuốt mọi lỗi sẽ che giấu bug. Luôn bắt lỗi cụ thể.
Magic numbers: Thay vì if status == 2, hãy dùng if status == Status.APPROVED với Enum.
Không log, hoặc log quá nhiều: Log structured JSONL mọi thứ quan trọng (LLM call, agent run, tool call).
Copy-paste output LLM mà không đọc: Quy tắc thép: phải hiểu từng dòng trước khi đưa vào codebase.
Không test Quality Gate và Isolation: Hai chỗ dễ gây mất dữ liệu hoặc crash hệ thống nhất.
Build 6 milestone trước khi ship 1: Đây là sai lầm lớn nhất. Hãy ship Morning Brief vào cuối tuần 2, dù nó còn thô sơ.

8. Bài học cá nhân và lời khuyên cho người xây dựng

Hành trình này đã dạy tôi rằng việc xây dựng một hệ thống agent không phải là bài toán về AI, mà là bài toán về kỹ thuật phần mềm: làm sao để các thành phần giao tiếp với nhau, làm sao để kiểm soát được trạng thái, và làm sao để hệ thống có thể tự sửa sai.

Bắt đầu với thứ nhỏ nhất có thể chạy được. Một script gọi LLM gửi Telegram đã là một agent. Đừng chờ cơ sở dữ liệu hay kiến trúc hoàn hảo.
Tách biệt memory khỏi execution là quyết định đúng đắn nhất. Nó giúp tôi có thể thay toàn bộ Synapse bằng một hệ thống khác mà vẫn giữ nguyên “bộ não” Engram. Ngược lại, tôi có thể gắn Engram vào VS Code hay bất kỳ công cụ nào.
Hãy build in public. Mỗi khi hoàn thành một cột mốc, tôi viết blog và đăng lên dev.to, Twitter. Chính những bài viết đó là động lực để tôi không bỏ cuộc giữa chừng, và cũng là “hồ sơ năng lực” sống động khi phỏng vấn xin việc.
Đừng sợ thuật ngữ phức tạp. Tôi đã phải học cách sử dụng multiprocessing, SQLite FTS5, DBSCAN, protocol… Nhưng mọi thứ đều có thể học từng bước một.

Nếu bạn cũng muốn bắt đầu, hãy làm theo “Milestone 1” của tôi: chỉ cần 3 buổi tối, bạn đã có thể có một agent Hello World chạy cron trên GitHub Actions. Link repo sẽ được chia sẻ ở cuối bài.

9. Kết luận: Hành trình của một kỹ sư AI

Synapse + Engram không phải là sản phẩm thương mại, cũng không phải là một framework dành cho tất cả mọi người. Nó là câu trả lời của cá nhân tôi cho câu hỏi: “Làm thế nào để một kỹ sư phần mềm có thể tận dụng AI một cách bền vững, có kiểm soát, và không ngừng tiến bộ?”

Tôi đã đi đúng lộ trình: từ một người “dùng công cụ” (tầng 2) trở thành “người xây dựng hệ thống” (tầng 3). Giờ đây, mỗi sáng thức dậy, điện thoại tôi rung lên với bản tin từ Morning Brief. Mỗi email quan trọng đều có một bản nháp trả lời sẵn sàng chờ tôi bấm duyệt. Và cứ mỗi cuối tuần, “bộ não” Engram lại nhẹ nhàng hỏi tôi: “Này, tôi thấy có một pattern mới. Cậu muốn ghi nhớ nó không?”

Đó chính là tương lai tôi muốn sống cùng AI. Không phải là một siêu AI thay thế con người, mà là một đối tác kiên nhẫn, lặng lẽ giúp ta trở nên tốt hơn mỗi ngày.

Bạn cũng có thể tự xây dựng cho mình một hệ thống như vậy. Hãy bắt đầu từ tối nay, với một file Python nhỏ, và một chiếc Telegram bot. Phần còn lại, thời gian và những nguyên tắc thiết kế tốt sẽ lo.

Synapse: Hành trình xây dựng hệ thống Agent cá nhân có trí nhớ và tự tiến hóa