aditya om

Engineer, a curious kid who loves litti-chokha. Tweets are personal views!

[aditya om @adity_omg]

Career update - Thrilled to share that I have joined @JvNixon 's mission at @infinity_ai_ to make any chip inference-ready within days, cutting short the bring-up time and cost required to do so as SOTA fans out.

#inference
#AIInfrastructure
#infinityAI

[Jeremy Nixon - Automating AI Research @JvNixon]

When I think of technical depth, I think back to my interviews with Aditya @adity_omg and an candidate NVIDIA chip architect. Aditya and this chip architect were going blow for blow into the depths of collectives engineering and chip representations. Aditya's Meta Superintelligence Labs collectives experience was on full display or at full bore.

He's an incredibly deep and thoughtful engineer who has a sense of spiritual inspiration about his inventions.

Hand in hand we expect to deliver truly phenomenal & generational engineering breakthroughs at @infinity_ai_, in a way that will have indelible impact on the chip industry and beyond!

[Jeremy Nixon - Automating AI Research @JvNixon]

Who builds the fastest AI? Whoever wins at automated research.

That’s why top F100 companies like @Nvidia and @HP are coming to @infinity_ai_ .

Infinity Autoresearch hit 2x token throughput for Nemotron 3 Super on the HP ZGX Fury (GB300).

Here’s how we generate ∞ speed:

[Akshay 🚀 @akshay_pachaar]

HuggingFace just closed a major gap in harness engineering!

(the ultimate guide to multi-harness RL)

the same open-weight model can perform well inside one harness, then lose accuracy or produce invalid tool calls when moved to another.

this happens because training inside one interface can teach the model its specific tool names, output formats, context structure, and control flow. the model learns how to operate the harness, not just how to solve the task.

Hugging Face researchers tested a more portable approach called multi-harness reinforcement learning. instead of training a model through one agent interface, they trained it through Claude Code, Codex, OpenCode, and Mini-SWE-Agent.

to make that possible, they connected three open systems.

→ 𝗢𝗽𝗲𝗻𝗘𝗻𝘃 provides a standard interface between agent harnesses, reinforcement learning environments, and trainers. its capture proxy sits between the harness and model server, recording the exact tokens and generation probabilities needed for training.

→ 𝗛𝗮𝗿𝗯𝗼𝗿 runs agents against containerized tasks. it keeps the task, harness, and sandbox independent, allowing the same task to be attempted through different harnesses without rebuilding the environment.

→ 𝗧𝗥𝗟 is Hugging Face’s open-source library for post-training language models. it uses the trajectories captured by 𝗢𝗽𝗲𝗻𝗘𝗻𝘃 to update the model through reinforcement learning.

the real breakthrough is where the training data gets captured.

each harness keeps its native tools, prompts, context management, retries, and execution loop. the researchers do not recreate those behaviors inside the trainer. 𝗢𝗽𝗲𝗻𝗘𝗻𝘃 observes the model calls passing through each real harness and converts them into usable training sequences.

the team trained 𝗟𝗙𝗠𝟮.𝟱-𝟮.𝟲𝗕 across all four harnesses. the share of held-out tasks solved on the first attempt increased from 42.2% to 54.2%, with gains under every harness.

the trained model also used 31% fewer tool calls on tasks that both it and the base model solved.

training only in OpenCode improved the model too, but most of that gain stayed concentrated in OpenCode. multi-harness training spread the improvement across interfaces.

the experiment used one task family, one training seed, and unequal data exposure, so the results are not a universal ranking. even with those limitations, the mechanism matters.

open-source models cannot assume one deployment interface. if they need to work across harnesses, that portability must become part of training.

Read the full guide here: https://t.co/BFJfbFmI3J

if you want to understand harness engineering and what an agent harness actually includes, i wrote a full breakdown to help you get started. the article is quoted below.

[Yarchi @undefinedKi]

This might be the most useful paper on AI agents this year.

A team at Wavestone AI Lab took apart Claude Code, Codex and 9 more and found the 7-part blueprint every good agent is built on.

Their definition: an agent is a model plus a harness. All 11 agents build the harness from the same 7 parts. Only the size changes.

> Loop: Mini-SWE-Agent is a plain while loop. OpenHands logs every event so a run can be replayed

> LLM layer: one prompt template on one side, 29 provider profiles on the other

> Tools: some agents only have bash, the biggest has 43 typed tools loaded on demand

> Memory: from keep-the-whole-history to notes the agent maintains across sessions

> Safety: from a simple step limit to policy rules plus a reviewer model plus an OS sandbox

> Orchestration: Aider skips sub-agents on purpose, others fork them with their own context

> Extensions: hooks, skills and MCP. SKILL.md is in 9 of 11, MCP in 8

The paper ends with a 90-line harness covering all 7 parts, a solid starting point for your own.

Key pages:

> p.4: the 7-part map
> p.12: the 3 loop types, with Claude Code and Codex as examples
> p.53: why none of them use frameworks or embeddings
> p.67: 18 design recommendations
> p.71: the 90-line harness you can copy

[codila @0xCodila]

NVIDIA and MIT researchers just used Karpathy’s method to cut Agent harness costs by 2x - dropped 15-page PDF

The shift: one formula replaced prompt engineering: same LLM, same benchmark - change just the harness

here’s how they built it:

step 1 → inspect the agent’s execution logs - repeated actions, growing context, oversized outputs - find where tokens stop moving the task forward

step 2 → run Karpathy’s loop on the harness: propose → implement → review → test → keep or discard. Fix the quality and efficiency gates before the search starts

four fixes survived:

step 3 → fuse actions: edit the file and run its planned test in one tool call - remove the model round trip between them

step 4 → compact at completed steps - but only when expected savings outweigh the cost of rewriting the cached context

step 5 → stop replaying huge outputs: archive them, send them twice, then keep a handle and short excerpt. Retrieve exact pages when needed

step 6 → delegate log reading to a cheaper model - verify its evidence against the original. If verification fails, return the full log

how to steal this for your agents:

step 7 → start with one mechanism in Pi, where their code runs. Measure it against your current setup before combining all four

step 8 → freeze the changes, then test on unseen tasks. Track completion, API cost and tokens together - a cheaper failure is still a failure

the result:

50-54% lower API costs than native Codex and Claude Code on EdgeBench - using the same main LLMs

Against Pi: about one-third cheaper, 45-49% fewer tokens, retaining roughly 94% of its average score

bookmark this 15-page PDF - then build the full workflow from the article below ↓

[santi @santtiagom_]

Uber publicó cómo armó su infraestructura de MCP y hay varias ideas muy buenas acá.

imaginate una empresa con miles de servicios internos y muchos equipos conectando agentes a esos sistemas por su cuenta.

cuando eso empieza a crecer, terminás con tooling fragmentado, infra duplicada, distintas formas de exponer tools y poca consistencia en seguridad, discovery y operación.

por eso Uber hizo un MCP Gateway: una capa central entre los agentes y sus servicios internos.

el agente habla MCP y el gateway se encarga de routing, permisos, ejecución y de traducir las llamadas a HTTP, gRPC o TChannel según corresponda.

como Uber ya tenía miles de APIs internas, también hicieron AutoCrawler: recorre sus definiciones, detecta métodos y schemas y genera MCP tools automáticamente. incluso usan un LLM para mejorar las descripciones.

hoy tienen +800 MCP servers y +5000 tools. y ahí aparece otro problema: no podés cargar todas esas definiciones en el contexto del modelo.

para eso crearon Omni MCP. en vez de pasarle miles de tools al agente, este va descubriendo qué server necesita, qué tools tiene disponibles, carga el schema de la correcta y recién ahí ejecuta.

me parece un muy buen ejemplo de cómo cambia la arquitectura cuando los agentes pasan de usar unas pocas tools a trabajar con miles.

terminás necesitando algo muy parecido a un API Gateway para agentes.

[Bober_smart @Bober_smart]

I don't understand why everyone isn't doing this yet. Anthropic released a guide for Claude that makes work much more efficient while burning a fraction of the tokens

Main Idea: Agent Teams in Claude Code

Instead of burning the expensive Opus 5.5 context on every line of code, tasks are delegated across an autonomous swarm: 

Architect (Opus 5.5, high effort): Plans the structure and handles final PR merges

Developers (Sonnet 5.5, medium effort): Write code inside isolated ⁠git worktree⁠ environments (UI/UX, backend)

Adversary / Critic (Fable 5.1): Steps in at contract boundaries, recurring test failures, and pre-PR audits to catch vulnerabilities

Script Layer (Jev): Handles mechanical tasks (opening files, CLI invocations) in 16ms without involving LLMs

Launch the team via terminal:

claude --teammates ux,backend,adversary

Configure my Claude Code workspace for autonomous agent teams:

In ⁠~/.claude/teams⁠, generate missing roles: set workers to ⁠Sonnet⁠ (⁠medium effort⁠) in separate ⁠git worktree⁠ branches, and the adversary to ⁠Fable⁠

In ⁠~/.claude/settings.json⁠, set ⁠CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1⁠ and lock the main session to ⁠effortLevel: high⁠

Initialize ⁠tasks.json⁠ with file-level locking for direct peer coordination

In ⁠CLAUDE.md⁠, add a rule requiring an adversary review before opening a PR.
Show configuration diffs before applying edits

> https://t.co/78IXvJlq7o

[Avi Chawla @_avichawla]

Another insane Jev use case!

Traditional database filters need precise, predefined conditions. But many questions are semantic:

- Is this article mainly about software engineering?
- Which topic best describes it?
- How technically deep does it appear?

These usually require moving rows into application code, invoking a model, parsing its output, and writing the result back.

pg-jev is an open-source Postgres extension that exposes Jev through SQL functions.

- jev() works inside WHERE
- jev_prob() returns a probability
- jev_choice() selects a label
- jev_score() ranks rows across ordered levels.

It needs no vector column or embedding index.

Under the hood, pg-jev batches rows, sends them to Jev, and returns typed answers that SQL can filter, sort, group, and combine with exact predicates.

The recording below runs it against real Hacker News stories stored in Postgres.

It first shows the rows, then asks Jev to find software-engineering stories, classify them by topic, and rank them by technical depth. The final query reports requests, tokens, cost, and cache hits from the database session.

GitHub repo: https://t.co/6OD0nRMgfH

(don't forget to star it ⭐)

Postgres keeps the data and controls the query, while Jev handles the part SQL cannot express as a deterministic condition.

If you want to understand what Jev is doing under the hood, I also wrote a hands-on guide to building a Jev-style model with open models, entirely locally.

Read it below.

[Uber Engineering @UberEng]

https://t.co/p4OzJicyw8

[Avid @Av1dlive]

i use this prompt

https://t.co/Po4b2DLnxq

[Avid @Av1dlive]

jev + opus 5.5... i simply can't comprehend why everyone isn't building this yet.

in my workflow, this cut costs and time by ~80%. i think it's one of the best ways to use it.

→ pick relevant project notes before loading the context
→ route suitable tasks to a faster worker
→ choose a recovery path when a tool fails
→ run focused checks before the full test suite

opus handles the hard reasoning. jev picks from options the harness prepares and validates.

i explain how to build the decision layer in the article below:

[Yarchi @undefinedKi]

This paper might change your life

Researchers from MIT, UCLA and Princeton built an entire trading firm out of AI agents. It beat every classic strategy they put it against.

It copies how a real trading desk works:

> Four analysts read fundamentals, news, sentiment and charts
> A bull and a bear researcher debate the case
> A trader weighs both sides and makes the call
> A risk team and a portfolio manager can still veto it

The paper explains how the firm is built: what each role does, how the agents hand work to each other, and how it held up against buy-and-hold and the usual indicator strategies.

The repo is the working framework, 98k stars. You pick a ticker, a date and a model, and the agents write their reports and land on buy, sell or hold.

Repo and paper in the first reply

DYOR

[Elon Musk @elonmusk]

🔥🔥

[Akshay 🚀 @akshay_pachaar]

NVIDIA and Stanford just challenged Jev.

(their new System 1 architecture runs up to 9x faster.)

It is called a Contrastive Language Model, or CLM.

Like Jev, CLM is not designed to generate text. It handles the small, repeated decisions inside AI systems, such as choosing a tool, ranking a patch, routing a request, or selecting the next action.

But CLM reaches those decisions differently.

Instead of generating an answer token by token, it treats decision-making as a retrieval problem.

Here is how it works.

1) Encode the state

CLM takes the current situation, such as an agent’s context or the state of a game, and converts it into a vector.

It uses a frozen Qwen3-8B model with a small trainable state projection head.

2) Encode every possible action

A separate action head converts each candidate into the same vector space.

In the Mario example, the candidates are left, jump, and right run. CLM does not invent a fourth option. It only evaluates the actions supplied by the application.

3) Learn which states and actions belong together

During training, the correct state-action pair is pulled closer while incorrect pairs are pushed apart.

A batch of B examples produces a B × B similarity matrix. The matching pairs sit on the diagonal. Every other pairing becomes a negative example.

This contrastive training uses InfoNCE, the same general mechanism behind systems such as CLIP and dense retrieval.

4) Turn similarity into a decision

At inference, CLM measures the cosine similarity between the state and every candidate action.

A softmax converts those scores into a probability distribution. The application can choose the winner, apply a confidence threshold, or escalate an uncertain result.

The real speed advantage comes from separating states and actions.

Actions can be embedded once and cached. If an agent repeatedly chooses between the same tools, CLM only needs to encode the changing state and compare it with stored action vectors.

That replaces repeated generation with one embedding pass and a set of cheap dot products.

The researchers report that CLM-8B matches Jev across computer-use, gaming, and tool-calling evaluations while reaching up to 9x lower latency. The improvement is largest when actions repeat or the candidate set grows.

CLM still has limits. It cannot generate new actions, its probabilities are relative to the supplied candidates, and its strongest verifier results require task-specific fine-tuning.

But its central idea is powerful.

The entire research is open-source, including the code.

Read more here: https://t.co/I9kPwMPI7B

When software already knows the possible answers, an AI model should score them instead of generating more words.

I also wrote a full breakdown on how system one models like Jev work.

The article is quoted below.

[Suraj Sharma @suraj_sharma14]

If you learn inference infra, you will never be unemployed again.

Stage 1: Systems Foundations
C/C++ or Rust basics, Python performance, Linux, memory hierarchy, CPU vs GPU execution.

Stage 2: GPU Architecture Fundamentals
CUDA cores, tensor cores, VRAM, memory bandwidth, SM occupancy, nvidia-smi profiling.

Stage 3: Transformer Inference Anatomy
Prefill vs decode phases, KV cache growth, attention memory math, arithmetic intensity.

Stage 4: Serving Engines
vLLM, SGLang, TGI: continuous batching, PagedAttention, scheduling, throughput vs latency.

Stage 5: KV Cache Optimization
Prefix caching, chunked prefill, KV quantization, cache offloading, multi-turn reuse.

Stage 6: Quantization and Compression
FP8, INT8, AWQ, GPTQ, sparsity; measuring quality drop against speed gains.

Stage 7: Speculative Decoding and Parallelism
Draft-target models, Medusa heads, tensor vs pipeline parallelism tradeoffs.

Stage 8: Kernel-Level Optimization
Triton kernels, FlashAttention, CUDA graphs, operator fusion, Nsight profiling.

Stage 9: Distributed Inference
Multi-node serving, NVLink and InfiniBand, disaggregated prefill/decode, MoE expert parallelism.

Stage 10: Autoscaling and Economics
Queue-based scaling with KEDA, cold starts, spot GPUs, cost per token, MFU utilization.

Stage 11: Gateway, Routing, and Reliability
AI gateways, fallback chains, rate limits, TTFT and ITL SLOs, observability, chaos testing.

Stage 12: Portfolio and Benchmarks
Self-hosted cluster, published latency/throughput/cost benchmarks, kernel optimization writeups.

Most people stay stuck watching tutorials.

Builders get hired.

(Bookmark it)

[Dario Amodei @DarioAmodei]

We Must Pace the Frontier: I’ve written a new essay on why the AI industry should slow down, with a three-part plan for doing so.

Anthropic is unilaterally committing to the first of these steps. We’ll provide third-party evaluators with permanent, employee-level access to our systems, so that they can verify adherence to our safety measures, report on incidents, and assess models’ alignment during training.

You can read the full post here: https://t.co/OGyPb7yaYt

[OpenAI @OpenAI]

We’re sharing a solution to the Navier-Stokes Millennium Prize Problem, one of the deepest problems at the frontier of mathematics.

The proof was produced by a group of agents, using an OpenAI next-generation model significantly more capable than GPT-6 Astra.

The problem concerns whether the description of smooth three-dimensional fluid motion modeled by the Navier-Stokes equations can break down. It has remained unresolved for roughly 90 years.

[AI_Explorer @ai_explorer25]

list of 12 active AI researchers on X:

1. @karpathy — Andrej Karpathy
2. @rasbt— Sebastian Raschka
3. @AndrewYNg— Andrew Ng
4. @drfeifei— Fei-Fei Li
5. @demishassabis— Demis Hassabis
6. @GaryMarcus— Gary Marcus
7. @ai_explorer25 — AI Explorer
8. @maximelabonne- Maxime Labonne
9. @chipro — Chip Huyen
10. @ilyasut — Ilya Sutskever
11. @thsottiaux — Thibault "Tibo" Sottiaux
12. @bcherny — Boris Cherny

[Rahul @sairahul1]

Karpathy didn't make a course.

He made THE course.

3 hours. Free.

Tokenization. Attention. Hallucinations. Tool use. RLHF. DeepSeek. AlphaGo.

Every behavior you've ever wondered about in an LLM - where it comes from, why it exists, how it was engineered.

The gap between engineers who understand this and engineers who don't isn't technical depth.

It's the ability to conceive of entirely different things.

I converted some of the learnings from it, to below article.

Bookmark. Watch. Read.