ram

all things tech

[DAIR.AI @dair_ai]

https://t.co/EU2rcF5M1f

[DAIR.AI @dair_ai]

https://t.co/sthbQNatuk

[Basra!!!! @basrasahab]

Hilarious af😂😂😂

What garbage are we being fed in terms of commentary.

[Lionel Mora @lionel_mora]

In July we open-sourced a dynamic graph of everything a child learns in primary school. 1,590 concepts, 3,221 dependencies.

Now we’re turning every concept into interactive experiments kids can play and learn from.

First one, age 7: heat and water.

Everything that used to be a boring textbook can now be an engaging experience, potentially tailored to every child.

Kids education just got a massive upgrade.

[Sam Altman @sama]

We are entering a new era of discovery now:

https://t.co/Ng8GquwN3r

[AI_Explorer @ai_explorer25]

list of 15 best 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
13. @geoffreyhinton — Geoffrey Hinton
14. @JeffDean — Jeff Dean,
15. @fchollet — François Chollet

[Charly Wargnier ♨️ @DataChaz]

anyone wanting to fine-tune an LLM on their own data after reading this:

[Anatoli Kopadze @AnatoliKopadze]

Chinese researchers just published a paper with a brutal title: "The End of Software Engineering."

The core point is that writing code is completely finished as a skill.

Your brain can only hold so much state and so many dependencies before it hits a wall.

An agent doesn't have that ceiling, and its capacity only grows with compute.

So the human stops being the one who writes the code.

You become the intent architect, the one who directs the agents and audits the result.

Code becomes the throwaway, and judgment becomes the job.

That's exactly why i wrote the guide below on how to build your own agent system from scratch.

You can also find the full paper this is based on below.

[Avi Chawla @_avichawla]

Stanford researchers did it again.

They just built the agent-native version of Git.

When an agent works on a longer task, the run builds up a lot of state.

This includes files edited/created, a dev server, a database, installed packages, KV cache, etc.

Say the agent is at step 10 and makes a mistake, maybe it misreads a traceback and rewrites a file that was actually fine.

The tests start failing, and the run goes off track, although everything through step eight was correct.

By default, the agent just tries to fix it, which creates more edits and tool calls. This burns more tokens and grows the context.

The other options are a person stepping in to redirect it or restarting the whole run from step one.

That's wasteful, because it pays for every model/tool call again and re-prefills the context. Moreover, since an agent's run is non-deterministic, it doesn't reproduce the same early steps anyway.

The reason it's hard to just jump back exactly to a previous correct step and resume from there is that the trajectory is only a message log.

It records what the agent said and which tools it called, but not the live state underneath.

That state includes things like memory, open file handles, child processes, installed packages, /tmp, and KV cache. None of that is in the log.

Git can version the files, but it doesn't snapshot the running process or the KV cache. Checking out step eight moves the files back, but the process is still sitting in step-ten memory with a cold cache.

Shepherd is a runtime layer by Stanford that records the run as a trace of typed events rather than a flat log.

Each agent-environment interaction becomes a commit, similar to Git, but it tracks the live run.

Its commit includes the agent process and the filesystem together, copy-on-write, so a branch carries the actual state and not just the files.

Going back to a previous step is then a single call that forks from that commit and continues from the exact state.

The copy-on-write fork is roughly five times faster than docker commit, and because the prompt prefix through step eight is unchanged, the KV cache is reused over 95% on replay, so early steps aren't reprocessed again.

Once the run can be forked, a meta-agent can sit on top and operate it. It watches the trace and reverts as soon as it looks wrong, before the bad write is committed.

In practice, it's just Python calling fork, replay, and revert on the trace, rather than a separate control plane wired into the harness.

Not everything is reversible though.

Files and sandbox changes undo themselves, but a database write has no automatic undo, so it needs a matching undo step set up in advance.

Something external, like a sent email or a real charge, can't be undone, so the supervisor's job there is to catch it before it fires.

They tested this on a few public benchmarks. On CooperBench, where two agents work on the same codebase, adding a live supervisor took the pair-coding pass rate from 28.8% to 54.7%.

It's still early and labeled alpha. The benefit mostly shows up when a run gets branched a lot over a heavy sandbox state, which is exactly where restarting wastes the most tokens and time.

If Git was made to make file changes reversible, Shepherd is trying to do the same thing for a live agent run.

Shepherd Repo: https://t.co/5e8W5oxY6F

(don't forget to star it ⭐ )

That said, Shepherd reverts a bad step inside a run. The harness around it, the prompts, tools, and checks the supervisor relies on, still drifts across runs as models and dependencies change.

Akshay wrote about making that harness repair itself, where a failing trace gets diagnosed, the fix is verified against the exact input that failed, and the failure is locked as a regression test so it can't recur.

Read it below.

[Andrej Karpathy @karpathy]

- Drafted a blog post
- Used an LLM to meticulously improve the argument over 4 hours.
- Wow, feeling great, it’s so convincing!
- Fun idea let’s ask it to argue the opposite.
- LLM demolishes the entire argument and convinces me that the opposite is in fact true.
- lol

The LLMs may elicit an opinion when asked but are extremely competent in arguing almost any direction. This is actually super useful as a tool for forming your own opinions, just make sure to ask different directions and be careful with the sycophancy.

[Andrej Karpathy @karpathy]

Software horror: litellm PyPI supply chain attack.

Simple `pip install litellm` was enough to exfiltrate SSH keys, AWS/GCP/Azure creds, Kubernetes configs, git credentials, env vars (all your API keys), shell history, crypto wallets, SSL private keys, CI/CD secrets, database passwords.

LiteLLM itself has 97 million downloads per month which is already terrible, but much worse, the contagion spreads to any project that depends on litellm. For example, if you did `pip install dspy` (which depended on litellm>=1.64.0), you'd also be pwnd. Same for any other large project that depended on litellm.

Afaict the poisoned version was up for only less than ~1 hour. The attack had a bug which led to its discovery - Callum McMahon was using an MCP plugin inside Cursor that pulled in litellm as a transitive dependency. When litellm 1.82.8 installed, their machine ran out of RAM and crashed. So if the attacker didn't vibe code this attack it could have been undetected for many days or weeks.

Supply chain attacks like this are basically the scariest thing imaginable in modern software. Every time you install any depedency you could be pulling in a poisoned package anywhere deep inside its entire depedency tree. This is especially risky with large projects that might have lots and lots of dependencies. The credentials that do get stolen in each attack can then be used to take over more accounts and compromise more packages.

Classical software engineering would have you believe that dependencies are good (we're building pyramids from bricks), but imo this has to be re-evaluated, and it's why I've been so growingly averse to them, preferring to use LLMs to "yoink" functionality when it's simple enough and possible.

[Aakash Gupta @aakashgupta]

This is the AlphaGo moment for software agents.

Every AI coding agent today, from Cursor to Devin to Claude Code, learns from human traces. GitHub issues. Pull requests. Test suites written by developers. Someone had to write all of it first.

This creates a hard ceiling. SWE-bench Verified required 93 professional developers to manually screen 1,699 samples just to produce 500 usable problems. The original SWE-bench needed human-curated issue descriptions, pass-to-pass tests, fail-to-pass tests. The data scales linearly with human effort, and human effort doesn’t scale.

SSR breaks that constraint entirely. One model plays two roles: bug injector and bug solver. It explores real codebases, discovers how tests work on its own, creates progressively harder bugs by removing code or manipulating repository history, then learns to fix what it broke. The injector must produce bugs that fail tests through semantic errors, not syntax mistakes. The solver gets no natural language description, just the raw codebase and a test patch.

No human labeling. No curated issues. No pre-existing test suites. Just Docker images with source code.

The results: +10.4 points over human-data baselines on SWE-bench Verified. +7.8 on SWE-Bench Pro, which contains 731 enterprise-level tasks averaging 107 lines of code across 4+ files. The model trained entirely on self-generated bugs still generalizes to solving natural language issues written by humans that it never saw during training.

They also introduced higher-order bugs constructed from the solver’s own failed repair attempts. When the solver fails, those failure patterns become new training problems. The curriculum gets harder automatically.

This is the same loop that took Go from “decades away” to superhuman in 18 months. AlphaGo didn’t need human games to learn. It generated its own curriculum by playing against itself, discovered strategies no human had conceived, and scaled past every grandmaster on the planet.

We’re watching the same pattern emerge in code. The bottleneck was always data, and the assumption was that useful coding data required human developers to create it. SSR suggests that assumption is wrong. Raw repositories plus self-play can generate unlimited training signal.

Meta trained this on 16 million token batches across 150 steps using H100 clusters. The infrastructure exists to scale this dramatically further. More repositories, more self-play iterations, harder bugs.

GitHub has 200 million repositories. The training data ceiling just disappeared.

[ram @ramiyer]

@nahidulislam404 Agent

[Deep Psychology @DeepPsycho_HQ]

8 Greatest Laws I know at 40, I wish I knew at 20:

1.

[ram @ramiyer]

@elonmusk Love the message on “built on Rust”

[Andy Pavlo (@andypavlo.bsky.social) @andy_pavlo]

I'm back again with my annual retrospective of the last year in the world of databases. Major highlights include vector databases, @MariaDB problems, SQL:2023, the FAA database crash, and the most expensive password change ever: https://t.co/BoHTfX5QOW

[Felipe O. Carvalho @_Felipe]

Leslie Lamport just published a draft of his new book. 🔥

[Nucific @Nucific]

America vs. France... whose bread is healthier? 🍞
Here's the answer & why it could be making a MASSIVE difference to American waistlines.
Get Bio-X4 now 👉 https://t.co/NoIM1PaCal

[Shreyas Doshi @shreyas]

As a leader, how can you
- Make a major, singular impact
- Truly empower team members
- Grow them with “stretch tasks”
- Create flow for self & others
- Avoid burnout

Answer: Radical Delegation

(note: not for everyone, but game-changing for leaders & teams who are ready for it)

[Tom Goldstein @tomgoldsteincs]

I estimate the cost of running ChatGPT is $100K per day, or $3M per month. This is a back-of-the-envelope calculation. I assume nodes are always in use with a batch size of 1. In reality they probably batch during high volume, but have GPUs sitting fallow during low volume.