大飞

[诺鸭船长3 @noahduck283]

看完感觉codex白用了

这种文章越早看越好，无痛培养高效习惯，越到后面越懒得学😂

[Hanako @hanakoxbt]

Agents vs. Graphs, clearly explained!

spawning more agents is great, but it has a ceiling nobody says out loud:

five agents is a count. a graph is a shape. only one of them changes the answer.

point five agents at the same pile with the same window and they converge.

the first one writes a finding, the rest read it, and all five reports centre on the same thing. you paid five times for one opinion with four echoes.

Graph engineering fixes this by moving the decision up a layer: not how many agents, but who is allowed to look at what.

you need both. here's how it works:

↳ the count buys you throughput. five things happening instead of one
↳ the shape buys you coverage. five different things happening instead of the same one five times

Prompts → Context → Harness → Agents → Graphs

the node that does this is the splitter, and it decides more than any other node in the system.

cut a repository by folder and four workers audit the same three files. cut it by blast radius and each one sees something the others cannot.

the trick is being selective about what each lane is allowed to see.

separate contexts are not a nice-to-have, they are the mechanism.

if two agents are meant to produce different things, they must not share a window. if they are meant to produce the same thing, you did not need two agents.

one thing to know before you scale it.

a branch that throws does not reject the batch. it resolves to null, and that is the containment. which means your merge quietly receives a short list.

↳ filter the nulls before the merge, or one dead lane poisons the whole result
↳ never index a merge by position. eight good branches and one failure will shift everything by one, silently

skip that and the run looks like it worked. the output is just missing a lane, and nothing errored.

and the one that eats whole nights: multi-agent setups can use up to fifteen times the total tokens of a single chat, because every lane reloads its own core.

you are trading total tokens for a clean main window. usually the right trade, always a choice.

below i have quoted my full guide on graph engineering. it covers the three topologies, the verifier patterns, and where the gate should actually open.

save this and read it below ↓

[Shubham Saboo @Saboo_Shubham_]

Andrew NG just dropped the full roadmap to become an AI Engineer in 2026.

[Anatoli Kopadze @AnatoliKopadze]

NVIDIA CEO, Jensen Huang:

"Nobody writes prompts anymore, the new job is building Loops and Graphs."

In 50 minutes he breaks down what replaced prompting and why most people haven't caught on yet.

It's the difference between using AI and having AI work for you.

Watch it, then read the guide below on how to build a system that improves itself.

[Rohit @rohit4verse]

I have five coding harnesses installed. Cursor, Claude Code, Codex, OpenCode, Prime Agent.

I still can't tell you which one deserves which task.

Claude Code will spin up a swarm of sub-agents to rename a variable. pi will bring four tools to do a job that needed the swarm.

So I stopped choosing. One setup, and every prompt lands on whichever one is actually best at it

[virgilxbt @virgilxbt]

Google just dropped a free 120 minutes workshop on complete Graph Engineering.

How to go from a single prompt all the way to agent teams, loops, and self-building graphs:

• 10:16 - Build your first AI agent.
• 41:05 - Master prompt engineering.
• 54:45 - Turn agents into graphs.
• 1:20:10 - Run loops inside graphs.
• 1:43:33 - Build a graph that improves itself.

Prompts -> Agents -> Loops -> Graphs -> Self-Improving Systems

Most people ship one agent and call it done and Google is already teaching everything that comes after.

This free course beats most $500 agent engineering programs.

Watch it today, bookmark it, and then read how to run 300 agents from one prompt below ↓

[Jobescape @jobescape_ai]

Full Claude Course

Master Claude to automate repetitive tasks, build apps without coding, create real portfolio projects, and become more valuable at work.

[Jhonny Coder @Coder_Jhonny]

One Architecture Diagram That Explains Every AI Agent 🧠

After building and scaling real AI agent systems, one pattern keeps showing up — regardless of the model, framework, or use case.

So I mapped it out.

This diagram breaks down the core architecture behind modern AI agents:

→ Perception Layer — receives and interprets inputs
→ Reasoning Engine — thinks, reasons, and makes decisions
→ Planning Module — turns goals into actionable steps
→ Tool Execution / Action Layer — uses APIs, code, databases, files, and external services
→ Memory System — manages short-term context and long-term knowledge
→ Guardrails & Safety — permissions, approvals, filtering, rate limits, and human oversight
→ Observability Layer — tracks traces, logs, metrics, cost, and latency

Most people focus heavily on RAG.

But in production, the real complexity comes from how these layers work together — and how they are controlled.

This architecture applies to:

• ChatGPT & Claude
• Coding agents
• Enterprise AI agents
• Multi-agent systems
• Autonomous workflows

If you’re building or scaling AI agents, this mental model can save you a lot of time.

Save this diagram. You’ll want it later.

[cvxv666 @antpalkin]

Grok Bot by Elon Musk just replaced a $294,000 Wall Street research desk. Six AI agents, $200 a month, doing the work BlackRock pays people six figures for.

The guy who built it published every prompt.

What that desk cost before the bots:

> $27,000 a year for the Bloomberg terminal
> $22,000 for Refinitiv
> $50,000 for sell-side research
> $15,000 for AlphaSense
> $180,000 for the junior analyst who reads all of it until 2am so somebody senior can trade on it before the open

$294,000 a year. The agents cost $2,400. Same brief, 122 times cheaper, and it is there before the open.

Six agents split that desk. Each one gets its own computer in the cloud, and they all write into the same vault.

> FILINGS reads every 10-K, 10-Q and 8-K on a 100-ticker watchlist overnight and flags the ugly parts: going concern language, auditor changes, restatements
> EARNINGS reads the call transcript within 24 hours and tells you if the CFO got quieter than he was last quarter
> SECTOR does one pass per sector and picks up the rule change nobody read
> INSIDER catches Form 4 buys over $1 million and new positions from Two Sigma, Third Point and D.E. Shaw the day the 13Fs land
> CHATTER counts mentions on X and flags any ticker three standard deviations louder than its own 30-day normal
> CHIEF OF STAFF reads the other five at 5:30am, bins anything only one of them flagged, and emails you the ranked brief at 6

One analyst covers 30 names. Six agents cover 3,000 and finish before the open.

You show them the job once. They repeat it every night with your laptop shut.

Every research floor on Wall Street was priced on reading being slow and people being expensive. Both of those stopped being true this month.

So you wake up, read for five minutes, and know what moved on every name you hold. That used to be somebody's entire job, and he got a bonus for it.

The article below is the step by step guide to building the whole AI trading machine. Save & read it, you will want it open while you build.

[Jacob @jacobpeake]

sharing a new long-form blog post: ai chip architectures

it covers the leading chip architectures (nvidia, amd, tpus, trainium, cerebras, groq) across architecture, scaling (scale-up and scale-out), and software stacks.

it helps build an intuition for the architectures and their trade-offs.

https://t.co/7eZMh3ddZS

[Miles Ma @miles_mazy]

https://t.co/0cr9iBGG2Q

[大飞 @MarkYan97276065]

@Huanusa @grok 帮助总结一下重点

[Huan @Huanusa]

26年新起点，全程高能。
斯坦福教授AI讲座，本质上就是把未来3年谁赚钱，谁被淘汰，提前剧透了一遍。 看懂的人已经在布局了

[Ruben Hassid @rubenhassid]

I made a 16-page PDF to get you Claude-certified.

The certificates are official by Anthropic & free...

And the playbook is free too, at https://t.co/psB7XxAv8w. Here's what's inside:

The Claude Certification Playbook.

→ 3 official certificates & the order to take them in.
→ Step from creating an account to downloading.
→ The fake detector (yes, people sell fake ones).
→ The LinkedIn format to showcase the certificates.
→ The copy-paste announcement post on LinkedIn.
→ What you can honestly say about it in interviews.

The certificates take 6 hours.
Getting the playbook takes 2 minutes:

1. Go to https://t.co/psB7XxAv8w. Subscribe for free.
2. Open the welcome email in your inbox.
3. Tap the Notion library link inside.
4. Download "The Claude Certification Playbook."
5. Start with page 4 (the fake detector).

Know someone job hunting? Send them this post. It's the favor.

[郭宇 guoyu.eth @turingou]

我有一种预感，原语（Primitives）会替代 skill 成为 agents 协同工作中最重要的资产

[Ren @Ryrenz]

🧠 浙大开源了一本《大模型基础》，六章全本 PDF 免费下

GitHub 上 1.65 万 stars

想系统补大模型的底子，中文材料一直不太够。要么是博客拼凑的碎片，读完不成体系；要么直接啃英文论文，术语和数学一起上，第一章就劝退。

这本《大模型基础》是浙大团队做的，六章顺着能力递进铺：语言模型基础、大语言模型架构、Prompt 工程、参数高效微调、模型编辑、检索增强生成。完整版 PDF 和分章节 PDF 都给了，每章还配一份相关论文列表，想往深了挖有现成的路。

有个挺有意思的设计：每章各用一种动物作为讲技术的示例背景，抽象概念套在具体形象上，读起来不那么硬。内容按月更新，作者团队还计划补上大模型推理加速和大模型智能体两块。同一个仓库里另外开源了一个多智能体开发框架 Agent-Kernel。

母语材料的价值不在于省翻译时间，在于你能把注意力全放在内容上。

GitHub：https://t.co/n6ZdJlyhg1

[Avi Chawla @_avichawla]

I have been fine-tuning LLMs for over 2 years now!

Here are the top 12 techniques I'd learn if I were to fine-tune them:

Bookmark this.

1. LoRA
> Freezes the base weights and trains two low-rank matrices as the update, resulting in ~95-99% fewer params to fine-tune.

2. QLoRA
> LoRA on top of a 4-bit quantized base model.

3. Prefix tuning
> Prepends trainable vectors to keys and values at every layer, weights frozen.

4. Adapter tuning
> Inserts small trainable modules between transformer layers.

5. Instruction tuning
> Supervised tuning on (instruction, response) pairs so the model follows directions instead of just continuing text.

6. P-tuning
> Optimizes continuous prompt embeddings through a small encoder, mainly for NLU tasks where discrete prompts are unstable.

7. BitFit
> Trains only the bias terms, ~0.08% of params, and still rivals full fine-tuning on small-to-medium datasets.

8. RLHF/RLAIF
> RLHF trains a reward model on human preference rankings, then PPO against it. The pipeline behind the first ChatGPT.
> RLAIF swaps the human labeler for an LLM judging. RLHF-level quality at a fraction of the cost.

9. DPO (Direct Preference Optimization)
> Skips the reward model and optimizes preference pairs directly with a classification-style loss. Simpler than PPO.

10. GRPO (Group Relative Policy Optimization)
> Samples a group of responses per prompt and normalizes their rewards within the group. DeepSeek R1 ran on it.

11. RLVR (Reinforcement Learning with Verifiable Rewards)
> Replaces the learned reward model with a checker or compiler returning verifiable scores. The free signal behind R1's math and code.

12. Federated fine-tuning
> Tunes across decentralized clients that share only weight updates, never raw data. For when data can't leave the device.

GRPO needs exactly one scalar reward per response. RLVR (13) produces that for free on math and code by running the answer through a checker or compiler.

But tasks like a RAG answer, a support reply, or a summary have no gold label to match against.

The usual fallback is a hand-written reward function scoring faithfulness, hallucination, and completeness.

It takes days to calibrate, rewards the wrong behavior when the weights are off, and breaks every time you add a tool or edit the system prompt.

RULER, implemented in OpenPipe's ART (open-source), solves this.

During training, it passes the N sampled trajectories to a judge LLM, which ranks them relative to each other against the agent's system prompt and returns the scores.

Relative ranking is more stable than absolute scoring, and GRPO normalizes within the group anyway, so the rankings feed straight into the pipeline like with RLVR.

Here's the GitHub Repo: https://t.co/srt6poinAz

(don't forget to star it ⭐ )

I wrote a full breakdown recently on how exactly this works, with the training loop and code.

Read it below.

[Bober_smart @Bober_smart]

I still don't understand why everyone is not using this yet. Thanks to it, a year ago I increased my income to 17,000 dollars a month

Andrey Karpathy, co-founder of OpenAI, published a simple idea that got 16 million views: stop using AI to write code, use it to build a second brain

You point Claude Code to a folder, drop any source in there (an article, transcript, PDF) and Claude reads it, links it, and saves it into a living wiki of everything you know. It compounds like interest: the more you feed it, the smarter it gets

Here is the gist:

Install Obsidian, create a vault, open it in Claude Code

Paste the file with Karpathy's wiki idea and tell Claude to build it

Claude creates three folders: raw for sources, wiki for its pages, CLAUDE
which runs everything

Drop any source into raw and say "ingest this"

Ask questions across everything, forever

Five minutes to set up, and you never start with an empty chat again

The full step-by-step guide is in the article. Save to bookmarks

[Andrew Ng @AndrewYNg]

The most important skills in Building and Deploying AI Applications. https://t.co/IyWIKLIzeM

[Yuu💖 @QuantumTransf]

deepseek harness 文章已更新（https://t.co/Xzlf496akP）
dsh 内部的心智模型其实没那么简单，我在写这篇文章的时候也挣扎了很久；不过，对于写一个插件的人来说，却没有那么复杂。 文章有对此阐述，「复杂度不是消失了，而是转移进了系统内部」，相信读完这篇文章，你能够对 dsh 内部的架构有一个比较好的认知
repo: https://t.co/3USVmzG15Q
此页面仍在持续更新（