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

Why a Single Agent Fails at Long Tasks

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

Thoughts on Dynamic Intervention in AI Agent Runtimes

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

First, One All-Rounder Recommendation

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

dev-skills, at: https://github.com/ByronFinn/dev-skills

Attachment download: Agent Interview Questions.pdf — handy for printing or offline reading

Why Would You Need Multiple Agents

An opening question to separate people who have “read the articles” from people who have “actually built one”.

The bad answer: “Multi-agent enables parallel processing, which improves system throughput and robustness.”

Every word of that is correct, but if you follow up with “so after splitting into two agents, did throughput actually double?”, they stall. The reality: inter-agent communication has overhead, coordination has complexity, and after the split total throughput may well drop. Adding agents is not like adding CPU cores.

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

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

Why AI Agents Need a Memory System

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

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

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

Anyone who has used AI knows the feeling: with the same request, a well-written prompt and a badly written one produce wildly different results. The problem is that most people simply aren’t good at writing prompts — not for lack of talent, but for lack of a systematic optimization process.

I recently came across an open-source project, Prompt Optimizer — nearly 29k stars on GitHub — built to solve exactly this.

PDF2Markdown - An Intelligent Article Extraction Tool for Large PDF Documents

Project Overview

PDF2Markdown is an intelligent content extraction tool built specifically for large scanned PDF files. It combines traditional OCR technology with modern AI large language models to intelligently extract pure article content from documents, automatically filtering out non-article elements such as images and tables. Mixed Chinese-English documents are fully supported.

Building a Local RAG with LangChain + Ollama + pgvector: A Complete Hands-On Walkthrough from 0 to 1 (with uv Dependency Management and an Interview Guide)

This post is a directly actionable document. Follow it top to bottom and you will build a local RAG (retrieval-augmented generation) system from scratch and understand the key concepts and code. All core scripts come with comments to make learning and interview review easier.

]]> https://blog.baifan.site/en/gpu-accelerated-training-cuda-complete-guide/ Wed, 20 Aug 2025 14:00:00 +0800 ByF https://blog.baifan.site/en/gpu-accelerated-training-cuda-complete-guide/

AI Tutorial: CPU/GPU and Large Model Training

This is a highly condensed reference: clearly structured, right to the point — covering CPU/GPU fundamentals, tensors and numerical precision, CUDA and PyTorch in practice, hardware selection, common interview questions, and a debugging checklist.

---

0. Quick Overview (30 Seconds)

• CPU vs GPU: CPUs excel at general-purpose/sequential work; GPUs excel at massive parallelism (matrices/vectors).
• Large models need GPUs: training/inference is fundamentally matrix multiplication and parallelization — exactly what a GPU’s high concurrency + high-bandwidth memory deliver.
• Tensors and precision: all data becomes tensors; precision (FP16/FP8) and quantization (INT8/INT4) trade speed/VRAM against quality.
• The PyTorch GPU mantra: device = "cuda" if ...; model.to(device); data.to(device)
• Pick a GPU by VRAM first: VRAM first, then bandwidth/compute; for production, prefer full-strength high-quality models or cloud-hosted APIs.

---

1. CPU vs GPU: Differences, Workloads, and Analogies

1.1 The One-Line Comparison

Dimension	CPU	GPU
Architecture	Few cores, complex control flow	Massive small cores, SIMT parallelism
Excels at	Branching/system tasks/small-scale compute	Matrix multiplication, convolution, attention, graphics rendering
Task model	Time-sliced, low-latency switching	Batch- and throughput-oriented
Typical use	Business logic, scheduling, I/O	Main training/inference operators (GEMM, Conv, etc.)

1.2 An Intuitive Analogy

• CPU = a veteran expert: meticulous thinking, does one thing at a time with fast switching.
• GPU = a massive army: hordes of soldiers working simultaneously — built for parallel homogeneous small tasks.

1.3 Optional Mermaid Diagram (CPU Execution vs GPU Parallelism)

flowchart LR
    subgraph CPU["CPU (sequential/few cores)"]
      A1[Task1-SliceA] --> A2[Task2-SliceB] --> A3[Task3-SliceC]
    end
    subgraph GPU["GPU (parallel/many cores)"]
      B1[Element1 compute]:::p
      B2[Element2 compute]:::p
      B3[Element3 compute]:::p
      B4[Element4 compute]:::p
    end
    classDef p fill:#e9f5ff,stroke:#3b82f6,stroke-width:1px;

---

2. Tensors, Precision, and Quantization (with Examples)

2.1 Tensor Hierarchy

• 0D: scalar 3.14
• 1D: vector [1,2,3]
• 2D: matrix (e.g. a 3×3 table)
• 3D+: still called a tensor (e.g. batch×channel×height×width)

Image example: a batch of 32 224×224 RGB images → 32×3×224×224 (or N×H×W×C, depending on the framework).

]]>