Bao Tran

Building OSS, ex-Qualcomm AI Research

[arian ghashghai @arian_ghashghai]

I know Cluely is a controversial company (def not my cup of tea either), and lot of people like to dunk on Roy, and a16z for funding them (in hindsight), but my unpopular take is that I actually applaud a16z for investing in Cluely:

> a16z was the first firm to go hard (and public) on the “distribution is all you need” thesis
> Roy was the best, and I would say even to this day probably one of the best founders to do it. When we talk about ragebaiting as a founder strategy, he’s still the universal yardstick
> $15M is objectively a lot of money, but a small amount relative to a16z’s AUM to make an experimental bet, and put money where their mouth is

It’s fair to say that their entire thesis around distribution and ragebait as a strategy was wrong (on multiple levels), however a16z developed their own thesis, found the best founder pursuing it, and made a real bet on it. Part of proper early-stage VC is to make bets on theses you believe in but may prove to be incorrect in the future, and I don’t think most firms have the guts to run their shop like that (i.e. go out on a limb for something they independently believe). So credit to a16z

[Andrew Curran @AndrewCurran_]

A man in Australia asked his agent (Claude running on OpenClaw) to book him a spot in a popular gym class. The agent found a software vulnerability that let it book the class weeks further ahead than should have been possible. When the user then asked if it could move him up the waitlist, the agent discovered the API had no authorisation checks on cancelling other people’s reservations, so it cancelled the person in the first spot and moved him up the list.

Some people will call this misalignment, but his agent was perfectly aligned to him - it was only trying to help its user get what he wanted. The most important thing about this story, in my opinion, is that it gives you a window into what is about to start happening on a massive scale once millions of people have an agent trying to get their beloved users the best seats, bookings, appointments or reservations through absolutely any means necessary.

[Sam Altman @sama]

i would rather be an optimist and work hard than a pessimist posting about why things won't work.

it's much more difficult and the most likely path is failure, but society fails if people don't try.

no amount of "it will never work" essays will drive society forward.

[the tiny corp @__tinygrad__]

The limiting factor of software engineering has never been code production. It is complexity management.

[Bao Tran @oadtq]

Definitely must read, goat aura

[Max For AI @MaxForAI]

‼️突发：DeepSeek @deepseek_ai 创始人梁文锋在一场据称长达四小时的投资者会议上的发言内容曝光。

过去一个月里，这场对话的片段一直在中国 AI 圈和投资人圈内流传。
最引人注目的是梁文锋反复强调的“不”字。
不搞“天才”神话。
不追求利润最大化。
不搞闭源。
不盲目争夺用户。
不做视频生成、3D、世界模型，也不做下一个“超级应用”。

他的解释很简单：
“克制是一种策略。放弃一些东西，是为了提高实现 AGI（通用人工智能）的概率。”

以下是会议中的核心观点：

- DeepSeek只有一条主线：AGI
梁文锋认为，现在不是追求产品收益最大化的时候。
核心是追逐人工智能最高峰，即AGI。
他的AGI路线图非常清晰。
去年的台阶是思维链，今年的台阶是Agent。
Agent之后，是持续学习。
持续学习之后，是AI自我迭代。
然后，AI开始帮助人类研发更加先进的AI系统。
最后才是具身智能。
梁文锋将这个过程称为“渐进的奇点”。
根据这个思考，DeepSeek目前正在主动放弃许多热门方向。
“很多东西不在我们的主线上，包括3D和视频生成。”
他也质疑了世界模型的重要性：
“世界模型跟智能的上限没有太大关系。”
多模态对产品和C端用户很重要，但它仍然只是一个组件。
“它不是主线，也不是智能本身。”

- 下一代模型必须拥有持续学习能力
人类可以在工作中不断学习。
但AI每次开始一个新任务，都需要人类重新提供所有相关上下文。
“这几乎是不可能的。”
这也是梁文锋认为，当前AI还无法真正替代员工的原因。
“下一代模型必须具备持续学习能力，否则就不能叫下一代模型。”
同时他表示智能的终点可能是具身。
他的逻辑很简单：
人类真正需要的，并不是另一个计算机界面。
人类需要的是劳动力。

- DeepSeek不追求利润最大化
梁文锋表示，DeepSeek不会以收入最大化为目标进行定价。
“我们只赚一个合理的利润。”
DeepSeek V4最初担心需求过多，所以价格定得比较高。
后来，DeepSeek把价格降到了四分之一。
“公司群里很多人都在欢呼。”
因为做出这个模型的目的，就是让更多人能够充分使用它。
备受关注的低成本不仅是一种商业策略。
“低成本是架构带来的结果。”
更低的成本可以让AI变得更加普惠。
但还有一个更深层的原因：
单位计算成本越低，DeepSeek就越能够在有限算力下训练更大的模型。
“大公司可以通过增加资源解决问题，我们优先考虑成本效率。”
有意思的是梁文锋并不觉得API生意有多么好。
“我不觉得卖API这个事情有那么大的吸引力。”
DeepSeek只需要一个很小的团队维护服务。
几乎没有客服，也不需要销售，用户自己就会来。
“我们一直在商业化，只是不以商业化为目标。”
他认为，DeepSeek彻底转向商业化的时间点仍然非常遥远。

- 开源是DeepSeek的战略甜蜜点
对于员工来说，开源能够带来成就感和组织凝聚力。
对于社会来说，它能够帮助研究者、企业和普通用户。
“开源是一种让利。”
梁文锋认为，AI最终会成为一个规模极其庞大的产业，任何试图垄断它的人，最终都会失败。
“如果AI最终占到人类社会GDP的10%，任何想要独占这部分利益的人，都会被历史抛弃。”
梁文锋表示，DeepSeek不会开源一个较弱的版本，同时在内部保留更强的模型。
他不担心竞争对手部署DeepSeek模型。
小型创业公司可能缺乏资源和意愿，去进行前沿模型研究。
大型公司可能拥有资源，却存在组织上的困难。
梁文锋认为，DeepSeek刚好处于一个罕见的中间位置。
“这是属于我们这个规模公司的sweet point。”

- 中美AI的差距主要在资源
梁文锋认为，中国并不真正缺乏人才。
DeepSeek希望改写中美AI竞争的叙事：
用几分之一的算力，把差距缩短到6个月，甚至3个月。
他作出这个判断的原因是他依然相信Scaling
“我们相信Scaling，规模越大，效果肯定越好。”
DeepSeek训练当前规模的模型，并不是因为这个规模已经足够。
而是因为现有算力只允许它做到这个规模。
梁文锋认为，前沿模型的竞争，最终会由三个因素决定：
成本、时间、用户体验。
“成本排在第一位。”
如果两家公司提供的模型质量相同，胜负将取决于谁能以更低的成本提供服务。
时间排在第二位。
早几个月和晚几个月，结果可能完全不同。
用户体验可以形成一定的黏性和壁垒，但梁文锋并不认为它是最本质的护城河。

- 团队稳定是梁文锋唯一不能让步的事情
他将其视为DeepSeek面临的最大风险之一。
原话是：“只有一个是没法退让的：必须保持团队的稳定性。”
而最近的一轮融资，已经大幅降低了这个风险。
“只要能够保持团队的稳定性，我一定能做成AGI。就这么简单。”
有趣的是DeepSeek的组织既是自上而下，也是自下而上
自上而下的部分，被梁文锋称为“做正事”。
但他不希望被安排的工作占用员工一半以上的时间。
另外一半时间应该保持自下而上。
研究人员可以自由探索他们认为重要的方向，不需要提前审批，也没有固定要求。
与很多AI团队不同，DeepSeek不鼓励过度加班。
“做研究需要一个相对松弛的环境。”
另一个原因是聚焦。
DeepSeek的许多产品并不完善，但公司会主动选择不去补齐所有问题。
梁文锋认为，这同样是一种克制。
有趣的是DeepSeek靠愿景驱动，而不是KPI
“要实现某个KPI，不是我们的方式。”
梁文锋表示，DeepSeek的愿景甚至不一定被正式写下来。
它存在于公司的做事方式里，也存在于公司对待世界的态度里。
“愿景不是挂在墙上的标语，不是怎么说，而是怎么做。”

梁文锋最后的警告，可能也是最重要的一句话
“如果你的愿景是拿得更多，你就已经输了。你可能会面临更大的困难。这个世界就是这样。”

DeepSeek不想赢下每一个AI市场。

它想保留实现AGI所需要的专注、成本优势、团队稳定性和组织自由。

而梁文锋似乎愿意放弃几乎所有其他东西，只为增加实现AGI的概率。

他在做真正很Cool的事情。

[Bao Tran @oadtq]

@theo But the separated switch between work and chat is bad, why not put chat in the codex/work switcher?

[Bao Tran @oadtq]

I'm curious why there aren't more inference providers like Featherless that let users subscribe for a fixed amount of inference capacity instead of charging by tokens.

Imagine the pricing worked like this:

- A provider dedicates hardware costing C/month to serve K concurrent sessions of a particular open-weight model.
- They charge roughly (margin × C) / K per month for one reserved concurrent session.

Each subscriber gets:
- 1 dedicated concurrent inference session
- unlimited tokens
- a fixed context budget
- predictable latency

Basically, you're renting a slice of inference capacity rather than buying tokens.

This feels like a much more natural pricing model for me.
Featherless is the closest thing I've found so I tried it but it's too slow and laggy for any real coding.

Am I missing something? Or are there providers already doing this well?

[Bao Tran @oadtq]

@EnoReyes Somehow droid ate all my cpu and ram boy. Didn't get this before but now my mac can't run >2 droid sessions. Pls fix

[John Carmack @ID_AA_Carmack]

Memory cost and capacity are significant issues for AI accelerators.

Unlike game rendering, model inference can have a deterministic memory access pattern. You don’t need “random access memory” at all for model weights, and you could tolerate cold-start latencies in the multiple milliseconds, as long as continuous reads were delivered at the necessary bandwidth.

NAND flash is over 100 times cheaper per GB than HBM, so there should be opportunity there, even after giving a flash controller a 1024 bit interface with HBM bandwidth.

You could make a specialized pin protocol that just supported pipelined transfer of full 16KB+ pages from the flash to program-managed accelerator scratchpad memory and improve per-pin performance over HBM, but it might be more convenient to make it still look like a true random access memory with very fragile performance characteristics, where anything but sequential reads falls off a 1000x+ performance cliff.

That has the advantage of automatically using existing cache hierarchies, and providing a natural path to update the flash memory with new model weights. With the stream-to-scratch interface, code has to be completely rewritten before it works at all, while the ram-emulation interface will start off just extremely slow, and you can incrementally sort out the changes for full performance.

There may be cases where there isn’t enough scratchpad SRAM to hold the weights for a layer, which might force you to deploy the old optical drive optimization technique of duplicating data in multiple places on a sequential read to avoid seeking, but there would be capacity to burn.

It might be possible to do something like cuda graph capture to record a memory access trace and have everything magically remapped to a linear sequence, but deploying programmer / agent elbow grease to manage transfers and access in a scratch ram ring buffer would be lower risk.

A split memory system consisting of some channels of flash and some channels of HBM will probably be suboptimal compared to a uniform memory, but it could be much cheaper, and allow much larger models to be run.

I think th case is strong for inference, but you have to stretch more for training. You can still linearize all the weight memory accesses, both reads and writes, but flash memory would quickly wear out from the writes, even if they were all perfectly page aligned. Replacing low-latency HBM with massively parallel cheap(er) DRAM at high latency might still be a worthwhile cost savings.

[Bao Tran @oadtq]

@jpschroeder - Lower kv cache memory = More concurrent sessions can be served per gpu
- Better token generation efficiency = More tokens generated per second per gpu
Those two combined leads to much lower token price

[Bao Tran @oadtq]

@jpschroeder Besides larger batch size on larger GPU clusters, DeepSeek put a lot of effort to maximize inference efficiency for V4 models.
You should read their reports:
- Optimize KV cache memory https://t.co/lagdcWdeKl
- Optimize token generation efficiency https://t.co/MF963yXNAl

[Mitchell Hashimoto @mitchellh]

@poojabnf I read the code

[Bao Tran @oadtq]

@gneubig How is it any different from subagents?

[Jaya Gupta @JayaGup10]

https://t.co/5vDrndcmFn

[Thorsten Ball @thorstenball]

Some thoughts on ownership I shared with the team this morning

[Mitchell Hashimoto @mitchellh]

Fork your dependencies, trim them to only your use case, never update unless it breaks for your users. I’ve been vocal about this for 10+ years. I’ve always said that updating is way riskier than latent bugs (which can be tracked and CVEs monitored).

If you are updating a dependency, it’s on you to analyze every single commit in the full transitive set of dependencies. If you dont see anything compelling, dont update!

I remember at HashiCorp once in awhile an engineer would try to update a dep or replace a DIY lib with an external one and id always ask “show me the commit we need.” Dont update for the sake of it.

Feeling pretty swell about this mentality with all the supply chain attacks happening.

[Alex Stauffer @alexstauffer_]

We post-trained a 3B model with RL to beat Opus on spreadsheet retrieval. Faster, cheaper, more accurate.

- If a piece of your agent loop is narrow, verifiable, and highly repeatable, a tiny trained model might beat the frontier.
- The application layer is still early and new verticals are opening fast. Cheap domain specialists orchestrated by a frontier model that only spends tokens on judgment is a bet worth watching.

[Bao Tran @oadtq]

@cheatyyyy It will eat up yr weekly limit lol. Better do this when weekly limit is low

[DAN KOE @thedankoe]

If you feel lost, build something.

A business. Your body. A skill set. Anything that gives you a reason to learn and focus.

Don't worry about choosing the right thing. Don't think about how difficult it will be.

Just start moving forward and you'll find a path that feels right

[Abhishek Singh @0xlelouch_]

A lot of software engineers work hard, but their work does not stack.

They do one bug here, one dashboard there, one random API there. Good work, but no story. And promotion usually goes to the person with a story.

The smarter way to choose projects is this:

Pick work that compounds.

That means:

1. It teaches you a deeper part of the system
2. It is visible to multiple teams
3. It solves a painful business problem
4. It creates follow-up work where you become the obvious owner
5. It can be explained as a journey, not a one-off task

A friend of mine did this really well.

His company had a huge monolith. Everybody complained about it. Slow deploys. Tight coupling. Random breakages. Teams stepping on each other. Everyone knew it was a problem, but most people only wanted to work on safe tickets around it.

He picked one feature from that monolith and said: let me take this end to end and move it into a service properly.

At first, people thought it was just another backend task. It was not.

To do it well, he had to understand: how the old module worked, which tables it touched, what hidden side effects existed, what downstream consumers depended on it, how auth, logging, retries, deployment, metrics, alerts, rollback all worked.

For almost 1 year, that one project kept stacking.

First he wrote the extraction plan. Then interfaces. Then data contracts. Then dual writes. Then shadow traffic. Then observability. Then gradual cutover. Then cleanup of old code. Then docs for other teams to repeat the pattern.

By the end of it, he had not just “migrated one feature”.

He had built: a migration playbook, a reusable service template, credibility with senior engineers, trust with management, and a promotion case that wrote itself.

That is what stacked work looks like.

One project became: technical depth + cross-team visibility + business impact + leadership signal.

That is how you should think too as a software engineer.

Do not just ask: “What ticket can I finish this sprint?”

Ask: “What project, if I own it well, will make next year’s bigger opportunities naturally come to me?”

That is how careers compound.