euanformoney

[euanformoney @euanformoney]

@bot @bot 总结下更新了什么 分点概括给我

[NVIDIA Newsroom @nvidianewsroom]

NVIDIA announces CEO transition. Read the release: https://t.co/MTTUvFHCJA

[euanformoney @euanformoney]

Magpie还是相当好用的～ 几个账号一下子反代出来了～

[euanformoney @euanformoney]

@yxl44 首先这篇paper去年十二月就出来了 其次我们还微调实践过 是理想主义的完美实验 最后真的讨厌营销号在鼓吹价值

[言川 @yanchuanlab]

https://t.co/AkbyDPI4z9

[chuplung @choopyplug1]

https://t.co/G6YAizJFRJ

[Avi Chawla @_avichawla]

NVIDIA released a new RL framework:

Your entire setup is one Python file:

- write a class with a step() function
- return a reward from it
- the framework handles the rest, up to 1T-class MoE training

In a typical RL framework, the environment and reward logic are added inside the trainer's codebase.

Adding a new task requires writing framework code, registering it, and wiring up config for it.

The reward usually comes from a separately trained reward model, which needs its own GPUs and placement next to the actor and critic.

NVIDIA's Molt framework drops both these requirements.

Every run takes an agent_path flag pointing to one Python module, and the trainer code never changes.

The module gives you two ways to plug in an agent.

> The first is an Env class where you write a step() function that receives the model's output and returns a reward, and the framework handles everything else, i.e., calling the model, tokenizing, and looping turn after turn until the episode ends.

> The second is a ChatAgent class, for agents that already exist as their own loop. Here, you write the loop yourself, calling the model through a standard OpenAI or Anthropic client, and the framework spins up a local server so those calls hit its vLLM engines instead of an external API.

Either way, the trainer sees the same thing, i.e., a trajectory of tokens and a reward at the end.

That reward can come from a string-match grader, code executed in a sandboxed subprocess, or an LLM-as-judge call.

So there is no reward model to train or place, and no environment code living inside the framework.

Under the hood, Molt runs a single trainable actor (plus an optional critic for PPO) on FSDP2, vLLM engines for rollout, and Ray queues between them, so generation, training, and weight sync overlap instead of running in lockstep.

Scaling just requires setting some flags on the same command.

The framework also splits the model across GPUs for you, so the script that trains an 8B model on one node can also train DeepSeek-V3-scale MoE models on a cluster by raising the parallelism flags.

Here's the repo: https://t.co/TafSfatER5

Since the framework is new, I am still experimenting with it and will share more about my learnings soon.

To dive deeper into how top AI labs are building RL Agents in 2026, I wrote a full article about it.

It covers the evolution from RLHF to GRPO with verifiable rewards and using an LLM-as-judge reward function. This idea extends RL training to non-verifiable agentic tasks without writing custom reward functions.

Read it below.

[euanformoney @euanformoney]

@openmys 用了这个，小红书刚被封🤣

[euanformoney @euanformoney]

@ilovek8s 重点不是如何实现。实现不难 重点是反风控机制是如何设计的，实用性远大于噱头

[euanformoney @euanformoney]

重点还是要验收下大厂风控机制的有效通过率，很多phone agent只表达了协同上的炫酷，真到生产可用还有很长的路子要走！能不能侧重机制研发而非自媒体营销！

[paulwei @coolish]

AI 控制手机 iPhone Use 赛道竞争逐渐白热化，
其中 Poki 的迭代热情速度很强，开源社区活跃。

我用 Poki 语音操控 3 台 iPhone 同时自动画
@elonmusk 、@realDonaldTrump 、 @sama
三人的肖像画 ⬇️

[Aleksey Smolenchuk @lxe]

Since phoneuse blew up, people mentioned a lot of other similar tools for agentic phone use. Here's the short list:

https://t.co/493WqqdNYA - mine. Linux PC, AirPlay for the screen, Bluetooth HID for input. Phone: no app, no dev mode, just AssistiveTouch and a Bluetooth pairing

https://t.co/YrddOyp0GT - YC. Drives your iPhone through iPhone Mirroring on a Mac, plus rented cloud phones. Phone: nothing installed, iOS 18+

https://t.co/FwwBZl1tqo - a rack of real phones in SF with a robot stylus and an overhead camera, $149/mo per iPhone. Phone: theirs

https://t.co/BhBeiulJGB - runs fleets of physical iPhones on a schedule. Phone: theirs

https://t.co/KOPzcVXZ26 - PhoneAgent, runs on the iPhone itself. Phone: Developer Mode and a signed app

https://t.co/3SUm1RGqRO - same idea as mine (AirPlay + Bluetooth mouse), Linux or Windows. Phone: no app, just AssistiveTouch

https://t.co/IPb2rmVVIG - ESP32 plugged in as a USB mouse and keyboard, AirPlay for the screen. Phone: their app (TestFlight) and AssistiveTouch

https://t.co/woxbZqqSDD - ESP32 Bluetooth mouse and keyboard plus an iOS app that reads the screen. Phone: Developer Mode, the app built in Xcode, AssistiveTouch

https://t.co/Que2gDQ2zn - Mac with Xcode's developer services, with an MCP server. Phone: Developer Mode, iOS 27, paired to the Mac by cable once

https://t.co/f3YZ349xio - Mac, WebDriverAgent + iPhone Mirroring. Phone: Developer Mode, WebDriverAgent re-signed every 7 days on a free Apple ID

Android has adb, so it's a lot easier there.

[euanformoney @euanformoney]

@akshay_pachaar I mean it’s too difficult and heavy to landing. We just build a semantic view for the data agent.

[Roan @RohOnChain]

this is the most DANGEROUS thing on internet today

4,843 backtested trading strategies for FREE, with the MOST profitable ones ranked by their Sharpe ratios (top one hits 3.39)

i handed these strategies to Opus 5.5 & it turned them into live AI trading bot working 24/7 (INCREDIBLE RESULTS)

here’s what you get:

> 4,843 strategies, each tested over decades of real data
> Sharpe ratio, t-stat & years tested for every strategy
> full Python code & data for each one
> 136 libraries for backtesting, bots, data & broker APIs
> 55 trading books, from beginner to pro

here are the EXACT steps to turn any strategy into live trading bot:

1. open the Strategies list & pick from the 61 strongest, sorted by market, so you can choose stocks, bonds, forex or crypto depending on what you trade

2. click any strategy & create a free account, it unlocks the full Python code & data so you can see exactly how the strategy works

3. paste that code into Claude Code & ask Opus 5.5 to explain every rule in simple English, so you know exactly when it buys, when it sells & why

4. before going live, ask Opus to rerun the backtest with REAL trading fees on the last 3 years of data, if the strategy still makes money after costs, it’s worth converting

5. now ask Opus to convert the research code into live trading code, so instead of testing on old data, it reads live prices & creates real buy & sell signals as they happen

6. pick a broker connection from the 136 libraries, like Alpaca for stocks or Binance for crypto and let Opus connect the bot to it

7. ask Opus to add a risk layer on top: a fixed position size, a stop loss on every trade, a daily loss limit & a kill switch

8. run the bot in paper trading mode for 2 weeks with fake money & compare its live results with the backtest, if they match, the conversion worked

9. connect Telegram so your phone pings you on every trade, switch it to live & let it run 24/7, then repeat the same steps to add a second & third strategy to your bot

if you want to build an AI trading system from scratch, start with this article below:

[euanformoney @euanformoney]

@yangleiocx3 仓库的架构图一看就很烧钱🤣

[euanformoney @euanformoney]

@AISuperDomain 超哥出一期视频啊

[Daily Dose of Data Science @DailyDoseOfDS_]

A good technical LLM interview question:

We replace a dense feed-forward layer with a top-2 MoE.

The profiler confirms that the MoE executes fewer FLOPs per token.

However, end-to-end inference latency has increased instead of decreasing.

Why did this happen?

A standard Transformer applies the same feed-forward network to every token in a layer.

An MoE layer replaces that network with multiple experts. Each expert is a feed-forward network with its own weights.

A router reads each token’s hidden-state vector, scores the available experts, and selects the top two. It also produces a routing weight for each selection.

Only those selected experts process the token. The model therefore contains many expert weights while executing only a small subset for each token.

The serving system must move activations when the selected experts are stored on different GPUs.

The visual follows a batch that begins on GPU 0.

The router returns two expert IDs and two routing weights per token. One selected path is shown for each example token to keep the diagram readable.

Token T1 selects E1 on GPU 0. Its activation remains in local GPU memory, where E1 processes it.

T2 selects E4 on GPU 1 in the same server. GPU 0 transfers the activation through NVLink, a high-bandwidth GPU-to-GPU connection. NVSwitch connects several GPUs through this fabric.

T3 selects E7 on GPU 2 in another server. Its activation crosses the cluster network through InfiniBand or Ethernet.

To be clear, the system transfers activation vectors, which are the numerical representations produced for a token by the preceding Transformer operations.

Each destination GPU runs its expert and returns the output to GPU 0.

GPU 0 multiplies both selected expert outputs by their routing weights, adds them together, and restores the original token order.

Different tokens can select different expert pairs. Across a batch, those assignments may involve every GPU storing experts.

Each GPU may therefore send activations to several GPUs while receiving activations for its own experts. This exchange is called all-to-all communication.

And there are several ways to optimize this.

For instance, keeping frequently selected experts within the same server reduces remote traffic.

Balanced routing prevents one GPU from delaying the layer.

Communication overlap allows local expert computation to continue while remote activations move.

In this setup, sparse routing reduces expert FLOPs, but token dispatch and network communication erase part of that saving.

If you want to dive deeper, we recently covered MoE inference engineering, including routing, expert placement, token dispatch, load balancing, communication overlap, memory, quantization, and offloading.

Read the article below.

[sarpstar @sarpstar]

YouTube kanalı açmayı hep isteyip bir türlü başlayamadıysanız, bu post derdinize derman olacak.

Bu hafta paylaştığım skill cinecode ücretsiz ve açık kaynak. Sadece Claude üyeliğinizle, sağda solda satılan kurslara para vermeden, aynı işi yapan araçları parayla satan platformlara gerek kalmadan kanalınızı açabileceksiniz.

Aşağıdaki Bermuda belgeseli için bir gece cinecode'a "kararları sen ver" deyip yattım. Sabah teslim raporuyla uyandım: sekiz dakikalık nerdeyse final bir video. Son haliyse, değişmesini istediğim yerleri detaylıca anlattığım tek bir revizeyle çıktı. Bunu yazarken harbici gururluyum, birkaç hafta önce bu cümleleri kuramazdım.

Ne yapıyor derseniz: fikrinizden senaryoyu yazıyor, sahneleri kodla üretiyor, gerektiğinde stok görsel tarayıp arşivden buluyor, motion design ile görsel kancalar kuruyor, açık kaynak ses efektlerini ve müziği de ekleyip son kurguya kadar götürüyor.

Valla bu skill gerçekten oldu, dümen değil. Kurcalayın, iyice aşina olun, benden iyilerini de yapacaksınızdır. Kamera almadan, yüzünüzü göstermeden, kurgucu tutmadan kanal zaten açılıyordu; ama artık başka hiçbir araca ihtiyaç duymadan, sadece Claude'la ya da kullandığınız yapay zekâ aracıyla yapabileceksiniz. Kafayı koyup emek verirseniz elinizde kanal açacak kalitede iş üretebileceğiniz bir araç var.

Ben de izninizle kendi kanallarımı açıyorum artık; hepinizi kendime rakip etmesem içime sinmezdi. Sıra trend bir konu ve doğru nişte. Tutan formatı bulup seri üretime geçeceğim. Belki de Bermuda gibi paranormal olaylar anlatan bir kanaldan devam ederim.

cinecode'u geliştirmekten de bir süre uzaklaşacağım, şu haliyle fazlasıyla yeterli. Aklıma gelen fikirleri not ediyorum, özleyince döneceğim.

Repo ve kurulum ilk yorumda. Bu akşam konunuzu seçin, YouTube'da görüşürüz.

[euanformoney @euanformoney]

cool☺️

[Yi-Yi @yiyibuilds]

I tried LearnHarness, an open-source AI learning tool, because I was curious to see how a harness would be implemented in education.

LearnHarness: https://t.co/tPKRrUi0wn

TLDR: I liked its live learning graph, but at times I felt tested rather than taught.

Before testing it, I used Teachable Code (https://t.co/ZsraXLE0e8) to explore the GitHub repo, then read its teaching methodology. I was curious how ideas about learning became concrete workflows, tools, and state.

The learning task I gave was to learn/build backprop from scratch. LearnHarness starts with probing questions, then generates a learning route on the fly using Mermaid. The route combines the learning content, my goal, and its assessment of my starting point. As I work through questions, the corresponding nodes are highlighted. I could see which part of the plan we were working on and why rates of change came before backpropagation.

Where I struggled was the teaching itself. I kept answering questions and receiving corrections, including on things I didn’t yet understand. At that point, I wanted explanations, illustrations, and worked examples to help me build the understanding I was being asked to demonstrate.

I’d like to reuse that working graph in an AI tutor whiteboard. When I get stuck at a node, we could work through an example together, keeping the calculations visible and tracing what changes when we change an input.

I’m building one.

[Smartpig @Smartpigai]

AI Agent 的记忆系统，可能从一开始就被很多人做复杂了。

现在不少 Agent Memory 项目，基本都是一个思路：聊天记录存进数据库，做 Embedding，需要的时候再用向量检索捞出来。

但 Anthropic 最新发布的《The components of agent memory》，给出了一套更完整的记忆架构。

核心观点很有意思：记忆不是存得越多越好，而是让 Agent 知道什么值得记、什么时候回忆，以及什么时候应该忘掉。

文章把 Agent Memory 分成了四层：

1. Transcripts：原始记录层

保存历史对话、工具调用和任务执行过程，相当于 Agent 的事件日志。

这层不需要提前判断哪些信息重要，重点是保留原始证据，方便以后搜索、验证和纠错。

2. Memory Notes：经验记忆层

Agent 在执行任务时，把有价值的信息提炼成笔记。

比如之前踩过的坑、验证过的规则、用户偏好，以及下次需要继续执行的计划。

这里有个关键区别：记录事实不等于形成经验。

好的 Memory 应该包含结论，以及这个结论为什么可信。

3. Memory Representations：知识组织层

这部分我觉得最有意思。

Anthropic 不只是把记忆做成向量索引，而是让 Claude 在后台整理 Wiki，把分散的笔记、事实和文档关联起来。

它可以合并重复内容、补充缺失链接、修正过期信息，逐渐形成一张可以导航的知识网络。

4. Injected Context：主动加载层

并不是所有记忆都应该塞进 Context Window。

真正重要的信息可以提前加载，其余内容按需检索。

比如 Claude Code 的 Auto Memory，只会自动加载 MEMORY.md 前 200 行或 25KB，更多细节通过索引查找。

这样既能保留长期记忆，又不会让上下文被历史信息撑爆。

真正有技术含量的部分，是 Anthropic 提出的 Dreaming 机制。

它借鉴了人类睡眠期间整理记忆的思路。

Agent 执行任务时留下记录，之后再利用空闲计算资源：

回顾历史任务，提炼可以复用的规则
根据原始记录，修正之前记错的事实
把零散经验整理成结构化 Wiki
清理重复、失效或互相矛盾的记忆
决定哪些信息应该进入下一次会话

相当于把记忆维护从实时任务中部分拆出来，交给一个独立的后台整理过程。

而且文章里有几个实验数据挺有说服力。

在 CL-Bench 的数据库任务中，Claude Opus 5.5 的平均得分从无记忆时的 0.655 提升到 0.838。

另一个实验更有意思：

让不同版本的 Claude 玩宝可梦。

Sonnet 3.7 记了 413 个文件，最后只拿到 1 枚徽章；Fable 5 只保留约 10 个文件，却拿到了 4 枚。

虽然只是不同模型的单次运行，不能简单归因于记忆数量，但很能说明问题：

Agent 不是缺记忆，而是容易把没必要的信息也当成记忆。

还有一个企业知识库实验。

Anthropic 用约 35 万份文档、4.2 亿 Token 构建知识体系。

单纯搜索的得分是 53%，结合持续构建的 Wiki 和搜索后，得分达到 61%，每个问题还节省了约 2 万 Token。

不过 Wiki 也不是万能的。

对于只需要从单份文档中查找答案的任务，额外构建知识网络可能没有明显收益，维护成本反而会上升。

看完我最大的感受是，下一代 Agent Memory 的重点可能不再是 RAG 检索能力，而是 Memory Lifecycle Management。

什么时候写入、如何验证、怎么更新、如何遗忘、什么时候主动注入上下文，这些问题会越来越重要。

尤其对长时间运行的 Coding Agent、多 Agent 系统来说，如果记忆不能持续纠错，运行时间越长，反而越容易积累错误。

从工程角度看，我觉得比较合理的组合是：

Event Log + Structured Memory + Knowledge Wiki + Retrieval + Background Consolidation。

这里的 Background Consolidation，就是文章所说的 Dreaming。

模型本身不需要重新训练权重，却可以通过不断积累、验证和修正经验，让后续任务做得更好。

这可能也是 Agent 和普通聊天机器人真正拉开差距的地方。

以后判断一个 Agent 是否足够成熟，不能只看它会调用多少工具，还要看它能不能从过去的工作里持续学到东西。

原文：https://t.co/GqCCxtIN8z

[浙大曾哥聊 AI商业 @zengge1984]

今天下午拿下了第一个GEO客户，29,800元！拆解一下，我是怎么成交的，以及GEO真正值钱的是什么。

今天下午，跟杭州一个做线下茶饮品牌陆羽不绝的老板聊了一个多小时，最终谈成了我第一个GEO项目，金额29,800元。

这个老板其实挺有实力的，已经开到了第四家茶馆，莫干山也有一个黄茶品牌，有十几家店。门店位于杭州一个大客流区域的核心位置，有自己的茶园、停车场，甚至还有游泳池，在当地细分市场已经有一定影响力了。

他的目标也很明确，就是想把自己的茶馆做成杭州第一梯队的茶饮品牌。

但他有两个问题一直没解决。

第一个是品牌传播。店开得不错，产品也有特色，但真正知道这个品牌的人还不够多。

第二个是商业模式。他说了一句话，我印象很深：如果我做了这么多营销，最后只是为了卖一杯茶，那利润太低了，这个生意到底怎么赚钱？

其实这才是老板真正关心的问题。

一、这单我是怎么成交的？

这个老板之前已经接触过六家家GEO公司，包括有赞的团队，有些给他的方案就是发5000篇甚至是10000篇文章，铺各种媒体渠道，承诺大量曝光，一年收一万，价格还挺便宜。

但聊完以后，他始终没有搞清楚：这些文章跟自己的生意有什么关系？最后到底能带来什么？底层逻辑是什么？

所以今天我们聊的重点，不是AI能写多少篇文章，也不是有多少媒体资源，而是回到了营销本身。

你到底要服务哪一类客户？客户为什么要来你的茶馆？跟杭州其他茶馆相比，你有什么真正的差异化？客户来了以后怎么消费，怎么让一杯茶变成一笔更有价值的生意？

包括他自己提出的后端变现问题，怎么样共创，我们也专门讨论了。

我觉得，这才是一个真正懂营销的人应该跟老板讨论的事情。

GEO只是一个新的获客渠道。如果你的品牌定位、客户画像、产品体系都没搞清楚，哪怕AI真的给你带来了流量，也未必能赚到钱。

今天老板聊完以后，明确表达了一个感受：之前跟其他GEO公司交流，很多困惑始终没搞明白，今天终于把底层逻辑讲清楚了。

最后我们没有让他直接签一个几十万元的年度合同，而是先从第一个项目启动，约定先付29800元，看看实际交付，再考虑下一步的深度合作。

二、GEO最大的骗局之一，就是把文章数量当成价值。

今天我也想分享一个反常识的观点：做GEO，内容质量比媒体权威更重要，比文章数量更重要。

为什么？

我们合作团队之前做过一个7000亿规模房产品牌的项目。

项目刚开始的时候，品牌在目标消费者问题中的提及率只有20%左右，相关竞争表现并不理想。

但经过消费者问题分析、品牌定位和内容策略优化，项目方展示的复盘数据显示，29天后，相关竞争位置从第8名做到了第1名，提及率提升了30多个百分点。

靠的不是发1万篇文章，而是把内容方向做对，只发了40篇文章。

还有一个更有意思的例子。

我们现场看了一份某央企年度预算800万元的GEO项目招标文件。

你猜这么大的项目，要求发多少文章？

内容要求是不少于150篇，而不是5000篇、10000篇。

真正考核的是什么？是品牌在AI回答中的提及率提升、内容实际收录以及相关营销效果。其中一项核心KPI就是提及率提升10个百分点。

GEO真正的壁垒不是生产内容的能力，而是判断应该生产什么内容的能力。

今天用AI批量生成几千篇甚至上万篇文章，技术上已经不是什么特别困难的事情。

但如果方向错了，1万篇文章只是在放大你的错误。

三、到底什么才是好的GEO？我认为核心是三个结果。

第一，提升品牌美誉度。

比如客户在豆包、DeepSeek里面问：杭州某某茶馆怎么样？值不值得去？

AI会怎么介绍你？

它知道你的品牌定位吗？知道你的特色吗？能不能基于真实信息，把你的优势讲清楚？

这就是品牌在AI时代的心智建设。

第二，帮企业获取精准客户。

GEO不是简单地让AI知道你，而是当客户产生相关需求的时候，能够在合适的问题下面推荐你。

比如客户问：西湖附近有什么适合带家人喝茶的地方？有没有停车方便、环境又好的茶馆？

这些问题背后都有真实的消费需求。

所以，我们要先研究客户画像，再梳理客户真实会问的几十类问题，找到哪些问题跟你的产品和优势最匹配。

这里有一个重要指标，叫提及率。

同一个消费问题，测试100次，AI有多少次提到了你的品牌？

优化之前是多少，之后是多少，跟竞争对手比又是多少？

这才是值得持续追踪的数据，而不是发了多少篇文章。

第三，帮助客户完成购买决策。

这个其实特别容易被忽略。

即使AI推荐了你的茶馆，客户可能还会问：这里贵不贵？适不适合商务接待？停车方便吗？怎么预约？

如果AI没有足够可靠的信息回答这些问题，客户就有可能去选其他品牌。

所以你还得围绕真实的客户疑虑，准备产品介绍、案例、评价、服务说明，并且尽可能把预约、团购、私域承接这些链路打通。

一个好的GEO，应该同时解决品牌美誉度、精准获客和购买决策三个问题。

当然，这三个指标最后还要跟真实的咨询量、到店量、成交量结合起来看。