Shivanand

AI @ EY | Building agents. Breaking agents. Fixing agents. | [email protected]

[Patrick OShaughnessy @patrick_oshag]

Neil Movva (@neilmovva) started his career at Nvidia, working on GPUs and kernels, and has an unusually deep understanding of inference, from software to chips to power.

We spend a lot of time on each of those layers, how they connect, and where the important tradeoffs are.

What makes this conversation special is how detailed it is (like a 401-level class), yet Neil makes it remarkably clear and easy to follow.

Today he runs Sail Research, a company building infrastructure for agents to make tokens as cheap as possible.

We discuss:
- Latency versus throughput
- Why there are no bad chips, only bad pricing
- The end of kernel engineering
- Buying chips and power no one else wants
- New chip architectures
- Nvidia lore + his contrarian view of the company
- Open source and the frontier labs

I learned a ton. Enjoy!

TIMESTAMPS
0:00 Intro
0:38 Building a “Token Factory”
4:21 The Future of Background Agents
13:09 Nvidia and the GPU Stack
23:27 Chips, Memory, and Transformers
36:14 The Future of AI Training Data
44:32 Chip Scarcity and Compute Arbitrage
52:44 Reinventing the AI Data Center
59:01 Power and the “Scavenger Strategy”
1:10:10 Open vs. Closed AI

[Will Stone @CoachWillStone]

Cardio is a scam for fat loss.

It's boring, leads to overeating, and barely burns any calories.

Summer 2026 is almost over.

Here are 9 cheat codes that actually burns fat:

1. Don't eat breakfast

[OpenAI Developers @OpenAIDevs]

We’re going live in 1 hour with @AlexFinn.

See how he gets things done with his voice agent in Codex—on desktop and mobile.

Keyboard optional.

https://t.co/TZVBy3EBDD

[naïve @usenaive]

Introducing Vetta, the most efficient harness for long-horizon agent tasks.

Same model, same tasks. Only the harness changed:
🥇 Vetta: $0.298 per finished task
🥈 claude-code: $0.872
🥉 hermes: $1.095

Highest finish rate, a third of the price. Autonomous companies only happen when the cost makes sense.

Here's how we get there:

[Sarim Malik @sarimrmalik]

On good API design

https://t.co/jMZpaa4Jkq

[Tim Messerschmidt @SeraAndroid]

I use @pidotdev as my daily driver because it stays lean. Pi gives me an efficient, understandable core and lets me add capabilities only where my workflow needs them.

These are my current favorite extensions:

• Ponytail -- nudges the agent to reuse what already exists before writing more code. I use it to keep implementations focused and avoid unnecessary complexity.

https://t.co/IviojsLPt0

• pi-web-access -- gives Pi web search and access to pages, GitHub repositories, PDFs and videos. I connect it to my own SearXNG instance so Pi can research a topic and bring the relevant context into the session.

https://t.co/1M9FztKMmJ

• pi-subagents -- lets me delegate focused work to different models. I use it to run research or reviews in parallel and return concise results to the parent session.

https://t.co/mYlvUJBUPE

• pi-fff -- adds pre-indexed fuzzy file and content search with frecency ranking. It makes larger repositories noticeably faster to navigate.

https://t.co/wtZ9ZOGtTh

• pi-context-view -- estimates how the context window is being used, including the base prompt, tool definitions and extension injections. I use it to check the context cost of every capability I add.

https://t.co/p3JAdwoIB0

What extensions have earned a permanent place in your Pi setup?

[Shivanand @snrspeaks]

@thsottiaux One example was testing an enterprise control against heterogeneous evidence files - where validating the control required reviewing and reasoning across different types of supporting evidence.

[Jeremy @node_jz]

@stolinski https://t.co/PCEpDLlGpa
https://t.co/TseP77qluS

[am.will @LLMJunky]

🥧 Introducing GooeyPi - A GUI for the Pi Family of Agents.

Supports: Pi, Oh-My-Pi (OMP), and Prime Agent

Very excited to share this with you all. Being into local models, I wanted to have a separate harness for my local models so I don't have to constantly switch configs. And I didn't want to go back to the TUI (nerds).

But, I didn't want to miss out on all the features that I know and love. Turns out, I didn't have to. I just needed to build it myself.

So I did.

Features include:
> Fully featured GUI experience
> Agentic Browser
> Realtime Voice Agent
> Voice transcription (local or API)
> Computer Use
> Automation Desk
> Agent to Agent messaging
> Ask Question Tool
> Git Control
> Terminal
> Pets
> and more

I tried to capture all of the most popular features I could in this first pass, but we're only just getting started.

Available in BETA on MacOS, Linux, and Windows.

I need testers! I have only tested on Mac and Linux.

If you want to help me with this project, please reach out.

Available: https://t.co/2uKJD0GetD

[Nicolas Bustamante @nicbstme]

Ok friends, sharing the recipe to build basically any agent product:

• Memory: learn everything useful about the user, their work, people, preferences, projects, decisions, etc. from their emails, drive, computer files etc

• Context engineering: figure out which tiny subset of all that memory + current state actually belongs in the context window for the task.

• Skills: teach the agent how to do the work. Build a complex DCF. Prepare a board meeting. Triage an inbox. Run customer research. Write an investment memo.

• Tools / MCPs: give it access to the world. Email, calendar, Slack, GitHub, CRM, browser, databases, internal APIs, computer use, etc.

• Agent runtime: the loop that plans, acts, observes, retries, delegates, checkpoints state and can keep working for hours or days.

• Triggers: cron jobs + events. New email arrives. Meeting ends. Customer churns. Metric changes. Deadline approaches. The agent wakes up without being prompted.

• Trust / permissions: know what it can do autonomously, what requires approval, and whose identity / permissions it is acting with.

• Evals: trace everything and continuously measure whether the agent is actually getting better.

Then optimize the hell out of memory quality, context selection, action quality, latency and token cost. That’s basically the agent stack. If you need more verticalization (aka finance, logistics etc. just add more MCPs and skills).

[Derrick Choi @derrickcchoi]

Our finance team shared 16 workflows with ChatGPT Work and Codex, from monthly close to forecasting and treasury.

Really good read especially if you’re in finance.

https://t.co/w1zsDqSnxy

[Aniket Pawar @alaymanguy]

found a gold mine for design engineers building ai interfaces

https://t.co/IxJOkAKf5A

[Shivanand @snrspeaks]

@ybhrdwj this isn’t just a website. it’s a time machine to the days of ₹20 haircuts and pure, unfiltered nostalgia. 🫡🫡

[Vaibhav (VB) Srivastav @reach_vb]

You should totally be updating your agents md regularly!

Here's mine:
- When explaining something to the user, use the Visualize skill
- Be concise, direct, and candid. Challenge weak assumptions and distinguish verified facts from uncertainty
- Ground research in authoritative, current sources and link important evidence
- Preserve the original goal and constraints; finish authorized work end to end and verify the actual result before claiming completion
- Ask questions only when a decision is materially ambiguous, risky, or requires approval
- Use relevant skills; spawn subagents only for genuinely independent work and synthesize their findings
- Keep changes focused and simple. Avoid unrelated edits, unnecessary abstractions, and low-signal tests
- Test observable behavior, review substantial changes, and validate user-facing work in the real interface when applicable
- Preserve unrelated work and never take destructive, production, or external actions beyond what the user authorized
- Report meaningful blockers, outcomes, and evidence without noisy progress

[Bill The Investor @billtheinvestor]

开发系统最极致高效的Agents.md，没有之一：

# AGENTS.md

## Core Principles

- Choose the simplest implementation that fully satisfies the current requirements. Avoid unnecessary abstraction, configuration, indirection, or speculative extensibility.

- Make the smallest necessary change that fixes the root cause. Do not refactor unrelated modules or change strategy semantics unless explicitly requested.

- Grow the system in layers. Start from the smallest working end-to-end version and add new capabilities incrementally. Never replace a working system with unfinished complexity.

- Reuse existing project components before creating new ones. Prefer extending proven modules over introducing parallel implementations.

- Prefer well-maintained libraries when they reduce overall complexity or improve reliability. Do not reimplement common functionality without a clear benefit.

- Keep components modular with clearly defined responsibilities. Avoid unnecessary coupling between strategy logic, execution, accounting, replay, and infrastructure.

- Design for long-term maintainability once a feature or strategy has been validated. Do not over-engineer speculative ideas before evidence exists.

---

## Strategy Development

- Validate hypotheses with historical replay before introducing forward-only logic whenever historical validation is possible.

- Every trading strategy must progress through Replay → Shadow → Canary → Live. Do not skip validation stages.

- Base design decisions on measurable evidence rather than intuition. Optimize only after demonstrating that an edge exists.

- Treat every strategy as an independent contract. Do not silently alter frozen behavior without explicit authorization.

---

## Existing Systems

- Do not break running Shadow or Live systems for unrelated work.

- Preserve compatibility only when required by active production or validation workflows. Otherwise, remove obsolete code instead of accumulating compatibility layers.

- Reuse existing infrastructure whenever possible, including replay engines, accounting, execution, wallet management, order book handling, logging, monitoring, and daemon frameworks.

---

## Engineering Standards

- Prefer deterministic behavior over hidden automation.

- Fail loudly when assumptions are violated. Do not silently ignore errors or fall back to unexpected behavior.

- Keep configuration minimal. Introduce new configuration only when behavior genuinely needs to vary.

- Remove dead code instead of leaving unused paths behind.

- Write code that is easy to inspect, replay, test, and reason about.

- Keep implementation consistent with existing project architecture unless an architectural change is explicitly requested.

---

## Scope Discipline

- Implement only the requested scope.

- Do not introduce unrelated optimizations, redesigns, migrations, or feature expansions.

- Non-blocking findings outside the requested scope may be noted separately but must not be merged into the current task.

- Consider a task complete once its agreed acceptance criteria are satisfied. Treat subsequent improvements as separate work items.

[OpenAI @OpenAI]

Audio moves through a dedicated fast path, while deeper reasoning and tool use happen asynchronously.

We also reduced voice-session startup from six network round trips to one.

[Sac @Saccc_c]

Vercel工程师总结出的AGENTS.md，能帮你在项目开发中省下80%的token

核心是通过工程化的决策和方案设计，降低AI的无效迭代和token消耗

完整版如下，建议配置在你的项目文件夹下：

# AGENTS.md

- 不以维护向后兼容性为目标。对于已经废弃的代码路径，应直接移除，不再通过兼容层、回退机制或迁移方案予以保留。
- 在充分满足当前需求的前提下，采用尽可能简单的实现方案。避免引入缺乏实际需求依据的抽象、配置项和间接层。
- 采用渐进式、分层的方式构建系统。首先完成能够端到端运行的最小版本，再基于稳定可用的产品逐步增加功能。不要以尚未成熟的复杂性取代已经可用的产品。
- 保持组件的模块化，并明确划分不同职责与关注点。
- 当成熟且维护良好的库能够降低整体复杂度或提高可靠性时，应优先采用。除非有明确理由，不要重复实现通用功能。
- 在自行实现功能或新增依赖之前，应优先评估项目现有依赖的能力。应先查阅相关文档和类型定义，不应未经确认就认定某个库不具备所需能力。
- 架构决策应着眼于长期演进。不要采用仅能解决当前问题、且预期需要在后续替换的权宜方案。
- 在设计解决方案之前，先研究成熟产品如何解决同类问题。优先采用经过验证的模式和约定，避免从零开始另行设计一套方案。

[OpenAI @OpenAI]

GPT-Live can listen while it speaks.

To make that feel natural at ChatGPT scale, we rebuilt the voice stack from client to model.

This new architecture keeps audio flowing continuously, so deeper reasoning and tool use don't interrupt the conversation.

[爱丽丝呀！ @BTCqzy1]

Codex 5.6 这个 GitHub 插件一定要装，能让你省下90%的token！

90% 的人都把 Codex 用反了。
一上来就让它：
帮我写一个 App。

分享一条我在用的绝佳省token技巧，先给 Codex 连接 GitHub 插件，然后输入提示词：

我要开发一个 XXX。暂时不要创建文件，也不要输出代码。先在 GitHub 调研同类开源项目，筛选出最有参考价值的方案。分析它们解决了什么问题、采用什么架构、依赖哪些技术、目前是否活跃，以及有哪些设计值得复用或避开。最后结合我的需求，给出技术选型、系统架构、MVP 范围和开发顺序。得到我的确认后，再进入实现阶段。

这样 Codex 会先做三件事：

1️⃣ 找到经过真实项目验证的方案
2️⃣ 研究别人已经踩过的坑
3️⃣ 根据你的需求做出技术取舍

等方向确定后，再让它开始写代码。

[Brady Long @thisguyknowsai]

I've shipped 340+ features with Claude Code across 12 client projects in 18 months.

These 7 workflows are the ONLY ones I actually use anymore because they cut my dev time by 70% and turned Claude Code into a senior engineer that never sleeps: 👇