Luneth90

数学 = 理解自然
历史 = 理解社会
艺术 = 理解生命

[Luneth90 @luneth90]

@NoraX2026 成大事者，有所得也必有所失。
我们只看到了其光鲜亮丽的羽毛。

[铁柱AGI @cgnot996]

🎉 Grok App v0.2.5 版本来啦～

🔗DS V4 Flash + Grok 多模态组合使用，从此告别睁眼瞎！
⚙️预设 DeepSeek，OpenCode Go 等配置，填写 Key 即可使用。
🗃️右侧资源面板重做，再次摸着 Codex 过河，逻辑更清晰。
🛠️全面兼容 Codex 插件，也支持了爆火的 ChatCut。

现在可以在 Grok App 里面套娃使用 Grok Build 啦。

欢迎大家下载体验，多提意见和 PR～
https://t.co/YrXbLhxNts

@elonmusk @SpaceXAI @milichab @belce_dogru
也希望官方可以注意到我们的项目

[谢小总 @xie_Dl]

DeepSeek这家公司真的太神奇了！

除了产品以外，他们低调得就像价格一样，毫无存在感。

期待DeepSeek能有超越Anthropic的模型。

希望那一天会到来。

[lifcc @mylifcc]

哇哦！又发现了一个宝藏教程！

很多人学 LLM 内部原理还在东拼西凑：看一篇 attention，跳一段 tokenization，再去搜 KV Cache。 结果就是碎片化，始终建不起完整心智模型。
这个库把从 tokenization 到推理优化的路径，用带数值例子的方式串起来了。

[Tianyi Cui @tianyi]

如果您在做 Agent Harness 相关的开源项目，希望在 DeepSeek Harness 发布的第一时间进行接入支持，请回复您的 GitHub id 以及 GitHub 项目地址，包括但不限于 plugin, skill, MCP, orchestrator, aggregator, UI 等等。

我们会选择一些开源项目的作者邀请参与DSH内测，并赠送部分API额度，让您可以做到在DSH发布时第一时间接入支持。

请同时私信我您的邮箱，我们会使用 email 联系您。

[Luneth90 @luneth90]

@tianyi GitHub ID： luneth90
GitHub 项目地址：https://t.co/EpJtreN9wc

LifeOS 是一套学习系统，帮助你将碎片灵感发展为结构化知识，把学习工作流、技能、模板、提示词和记忆系统整合成一套可以直接落地的完整方案，支持多Agent间自由迁移，并延续已有的知识、偏好与工作进度。

[Luneth90 @luneth90]

@MatrixCoreX 确实很适合搞学术研究，灵感需要大自然的滋养

[Luneth90 @luneth90]

@star_flow_ai 赞同这个版图划分，评论区说为什么没有智谱(GLM)，却有MiniMax，原因在于国内开源生态里，GLM有多个上位替代，MiniMax却没有。

[Luneth90 @luneth90]

Agent能力划分：
L1 - 有限辅助工具，不具备自主行动能力
L2 - 自动辅助工具，在严格约束范围内可以自主行动
L3 - 智能工具，设定目标后可自主判断约束并自主行动

现在处于 L1 -> L2 阶段，预计2年内实现。
L2 - > L3 预计2030 达成。

[Luneth90 @luneth90]

那不挺好的，当前我们的需求就是能干活的AI工具

[Alan Daitch @AlanDaitch]

La inteligencia artificial, como la conocemos hoy, NO puede inventar cosas nuevas.

Uno de los mejores investigadores de Google publicó una investigación en la que llegó a esa conclusión.

Él es uno de los que construyó AlphaProof, el sistema de DeepMind que demuestra teoremas al nivel de un medallista olímpico. Su argumento arranca de una idea clásica que dice que razonamos de tres formas:

- Deducción: es decir, sacar la conclusión a partir de las reglas, demostrar.
- Inducción: mirar un montón de casos y encontrar el patrón que se repite.
- Abducción: el salto que no se deduce de nada, para inventar la explicación que todavía no existe.

La IA de hoy domina las dos primeras, pero de ese salto de fe mágico, de esa gota de inspiración, está muy pero muy lejos.

Si agarrás una IA, le cortás todo el conocimiento posterior a 1905, pero dándole acceso a cada paper y cada ecuación de esa época, jamás llegaría a la teoría de la relatividad, porque la física de Newton, en ese momento, no estaba en crisis. Andaba casi perfecta: lo que se podía medir daba exacto hasta el noveno decimal.

Y eso es clave, porque toda la IA generativa aprende buscando el error para corregirlo. Si no hay problema, no tiene hacia dónde empezar a moverse.

Un modelo de lenguaje está entrenado para una sola cosa, adivinar la palabra más probable que sigue. Es una máquina de dar la respuesta más esperable. Inventar es lo contrario: es divergir, irte para donde los datos no apuntan, apostar a algo improbable y ridículo. Einstein empezó preguntándose algo tan trivial como "¿por qué cuando una persona está cayendo no siente su propio peso?" y se puso a tirar de la cuerda de su imaginación.

Los modelos de lenguaje saben decir "gravedad" sin haberse caído nunca. Es la diferencia entre memorizarte recetas de cocina y haber probado realmente la comida. Por eso Yann LeCun, uno de los padres de la IA moderna, viene diciendo que la máquina necesita un modelo del mundo adentro, ser capaz de meterse en una simulación, de sentir la vida real.

Porque pensar y hablar nunca fueron lo mismo.

[Luneth90 @luneth90]

这个观点很有前瞻性

[山景城小路 @Zen_with_AI]

最近越来越觉得：

AI 真正的竞争，很可能已经不是模型，而是 Harness。

如果把 Harness 看成 AI 的操作系统（OS），很多东西一下就想通了。

模型（LLM）越来越像 CPU。

真正决定 Agent 上限的，不再只是模型，而是 Harness。

未来 Harness 至少要解决六件事：

1. Process Management（进程管理）
不是 Multi-Agent，而是真正的进程调度。
Sub-agent = Process，有创建、调度、暂停、恢复、Checkpoint、资源配额、失败重试。

2. File System（文件系统）
Context 是内存，File System 才是磁盘。
长期知识、实验记录、代码、日志都应该落盘，而不是永远塞进 Context。

3. Memory Management（内存管理）
Context Engineering，本质就是内存管理。
什么时候摘要？什么时候换页（Paging）？什么时候重新加载？
未来比拼的可能不是谁 Context 更长，而是谁的 Memory Manager 更聪明。

4. Device Drivers（设备驱动）
MCP、Tool、Skill，就是 AI 世界的驱动程序。
模型无需关心底层是 Browser、Shell 还是 Database，只面对统一接口。

5. Networking（网络）
Agent 与 Agent、Agent 与 Tool、Agent 与 Human，都需要标准通信协议，而不是 Prompt 互相喊话。

6. Security（安全）
Capability、Sandbox、Audit Log、Permission……
未来最重要的问题不是 Agent 能做什么，而是不能做什么。

过去十几年，软件工程围绕的是 Cloud Runtime。
未来十年，软件工程可能会围绕 Agent Runtime（Harness） 展开。
真正的竞争，不只是哪个模型更强，而是谁能做出 AI 世界的 Linux。
LLM 提供 Intelligence。

Harness 提供 Runtime。

[Luneth90 @luneth90]

每一代主力模型都比上一代跑分高一截。

但是实际使用过程中，仔仔细细回想一下。

这一代真的就比上一代有惊艳的感觉吗？

如果没有惊艳，这是感觉好像聪明了点。

不用怀疑，就是在挤牙膏。

甚至牙膏都不用挤一点。

只需调配一下算力。

[Luneth90 @luneth90]

就目前的迭代速度，还会有人按年订阅AI套餐吗？

[Luneth90 @luneth90]

数学是描述时空关系的逻辑系统。

[Luneth90 @luneth90]

oh my pi 确实不错，满足了我大部分需求。

Agent工具：主力 codex，辅助 omp，其他全部卸载了。

[Luneth90 @luneth90]

有趣的观点

[Phoenix Yin @Phoenixyin13]

今天聊聊经济物理学，也是我的兴趣之一。

现实中，金融市场的暴跌、通胀的非线性飙升与黏性，暴露出极强的涌现、非线性响应和非平衡态特征。
统计物理的核心逻辑是，大量微观粒子的简单相互作用，如何在宏观上涌现出全新的集体行为。
我认为，这与金融市场中千万交易者互动导致大盘走势的逻辑完全一致。

在常规状态下，市场处于无序高熵状态，买卖双方意见分歧，价格微幅波动，类似于顺磁态。而当某种羊群效应或强烈的信信号出现时，交易者之间的关联长度急剧拉长，市场瞬间自组织成有序态，类似于铁磁态的自发磁化。
这对应着金融市场的疯狂牛市或恐慌性抛售。

就像沙堆模型一样，一粒沙子落下来，可能什么都不发生，也可能引发整座沙堆的塌方。金融市场和通胀系统往往处于这种临界状态，极小的外部扰动，一次不大的利空消息都可能引发幂律分布级别的尾部风险，这就是我们常说的黑天鹅事件。

其实，价格和通胀并非在平衡点附近做简单的布朗运动。物理学家利用描述非平衡态涨落的朗之万方程和福克-普朗克方程，来建模资产价格的厚尾分布和波动率聚现象。

非线性系统的核心在于反馈机制。系统的输出会重新成为系统的输入，导致微小改变引发剧烈后果，也就是蝴蝶效应。
我的观点是，通胀就是一个典型的非线性动力学系统。物价上涨，预期通胀升高，劳动力要求涨薪，企业成本上升，再次提价⁠。
这种正反馈回路可以用时滞微分方程建模。

当系统参数穿越某个临界分叉点时，通胀可能从平稳吸引子突变为极限环，甚至混沌吸引子，表现为难以控制的超速通胀或滞胀。

之前两年前在复旦管院的时候，还记得系主任给我讲过一件事。
分形之父曼德博最早发现，金融资产的价格日变动率与月变动率在几何上具有自相似性。
所以，使用相空间重构和李雅普诺夫指数可以证明金融市场短期内具有确定的动力学规律，但长期完全不可预测。
这就是内生混沌。

在某种程度上，复杂系统研究打破了传统经济学代表性个体的假设，引入了异质性与网络拓扑结构。

将金融机构视为网络节点，同业拆借和债务关系视为边。我们可以通过复杂网络理论可以发现，现代金融系统具有小世界和无标度特征。
系统对随机个体的破产极具韧性，但一旦核心节点倒闭，级联失效会导致整个系统流动性干涸，这其实某种程度上解释了 systemic risk的传导机制。
怎么样，想到雷曼兄弟的故事了么？

如今在高频量化交易的战场，以及对抗极端通胀的演化策略中，这些物理学与复杂系统方法早已成为最硬核的底层工具。
我说的这些，也仅仅案例的冰山一角。其实，这个世界大部分经济现象是可建模的。

[Luneth90 @luneth90]

理解 Transformer 和注意力机制 的有趣论文

[Antonio Lupetti @antoniolupetti]

"Understanding Transformers and Attention Mechanisms" is a very interesting paper that presents the Transformer architecture from the perspective of applied mathematics.

It starts by representing text as vectors and explains mathematically how the attention mechanism processes these vectors to encode contextual information. It then develops Multi-Head Attention and shows how the main components of the Transformer architecture are constructed.

The paper also discusses more recent methods designed to reduce the computational and memory costs of attention, including KV caching, Grouped Query Attention, and Latent Attention. I think it is a useful reference for anyone interested in understanding Transformers beyond their high-level architecture and in seeing the linear algebra behind modern language models.

https://t.co/Rlun9QT7zx

[Akshay 🚀 @akshay_pachaar]

As an AI engineer, please learn:

- Learn the roofline model and why decode is memory-bound
- Deploy vLLM and SGLang, then read their schedulers
- Understand paged attention from the code, not the blog post
- Build observability before you optimize anything
- Track TTFT, inter-token latency, throughput, queue depth
- Use Grafana + Prometheus for inference dashboards
- Turn on prefix caching and find which workloads it helps
- Learn continuous batching and chunked prefill
- Run load tests with 1000+ concurrent requests
- Report p50, p95, p99, never just the mean
- Master quantization tradeoffs (FP8, INT4, AWQ, GPTQ)
- Learn speculative decoding and where it stops helping
- Set up KV cache eviction for long contexts
- Try disaggregated prefill and decode serving
- Learn Kubernetes for AI workloads and autoscale on queue depth
- Learn how inference costs break unit economics
- Build your own model router by cost, latency, quality
- Create a token budgeting system per request
- Build one inference service and benchmark it publicly
- Read inference research instead of model release news
- Start sharing your optimization benchmarks

I put together a 10-week plan that covers every one of these at 30 minutes a day. It is 50 sessions, split between reading the theory and building on your own service, and all of them feed one artifact: an inference service you deploy, instrument, load test past 1000 concurrent requests, tune, and publish as a reproducible benchmark.

It is open on GitHub and contributions are welcome, especially newer sources worth adding. I am working through it myself and will share more content on this going forward, so stay tuned.

GitHub repo: https://t.co/UTxKAzhzJQ

(don't forget to star 🌟)

[Luneth90 @luneth90]

这个上下文工程解释的非常清晰

[Avi Chawla @_avichawla]

You are in an AI engineer interview at Google.

The interviewer asks:

"Our data is spread across many sources (Salesforce, Gmail, etc.)

How would you build a unified query engine over it?"

You: "Embed them in a vector DB and do RAG."

Interview over!

Here's what you missed:

Many devs still think context retrieval is a linear pipeline:

Chunk → Embed → Retrieve → Generate

This works great for simple demos, but production systems need something fundamentally different.

To understand better, consider this query:

"Compare our Q4 sales performance in the Chicago region against last year's projections formulated in a meeting with stakeholders."

This single query requires:

- Sales data from your SQL database
- Graph relationships (organizational hierarchy)
- Vector search over projection reports
- Time-based filtering (Q4 this year vs last year)
- Permission checks (for user authorization)

No single embedding lookup can handle this complexity!

To actually solve this problem, you'd need to build an Agentic context retrieval system with five critical layers (as described in the graphic below):

> Indexing layer:

Different content needs different indexing:
- Semantic chunking for docs
- Hierarchical indexing for nested content
- Special indexing for sources like Calendar, Slack, etc.

> Routing layer:

Before retrieval, you need intelligent routing that decides:
- Should the query hit a graph DB?
- Does it need a structured SQL query?
- Or semantic search for conceptual matching?

> Query construction layer:

The original query might need to be:
- Decomposed into sub-queries
- Translated into different query languages (SQL, Cypher, vector similarity)

> Retrieval layer:
- Apply permissions and access checks
- Run multiple retrievals in parallel
- Rerank based on relevance/recency

> Generation layer:
- Synthesize a citation-backed response

The diagram below depicts this whole process.

That said, four of these five layers run after a query arrives. Indexing runs before, which caps what the other four can do.

Even with perfect routing, query decomposition, and reranking, the system returns only what the chunks preserved.

My co-founder wrote about a better unit for that indexing step. The technique:

- cuts corpus size by 40x.
- reduces tokens per query by 3x.
- improves vector search relevance by 2.3x.

And it doesn't change the retrieval algorithm, the reranker, or the embedding model.

Read it below.

[deep Manifold @BetaTomorrow]

https://t.co/CUU2SL9Szj