Agent Skills, DeepMind Reads a Model's Mind, and GitHub's One-Word Repo Leak: The Tokenizer Edition #34

This week's most valuable AI resources

Hey there! Alibaba can now turn flat satellite photos into a 3D city you fly through, at about ten minutes per square kilometer. A security researcher got GitHub’s coding agent to hand over a private repo by slipping one ordinary word into a public issue. And DeepMind’s interpretability lead makes the case that reading a model’s mind is becoming a real science, with honest limits on what anyone can see. Let’s dig in.

New here?

The Tokenizer is my resource-focused newsletter edition where I curate the best AI/ML papers, videos, articles, tools, and learning resources so you don’t have to sift through the noise. Subscribe to Gradient Ascent for the full experience.

TL;DR

What caught my attention this week:

• 📄 Papers: A generative 3D Earth you explore from satellite photos, an open trillion-parameter reasoning model you can actually download, a research agent that delegates to subagents to beat its own context limit, a distillation trick that keeps the teacher in the prompt instead of the gradient, and a robotics video model that rewards physics over pretty frames.

• 🎥 Videos: Why understanding is the new bottleneck once agents write the code, a tour inside a model’s mind from DeepMind’s interpretability lead, why agent workloads can need a hundred thousand sandboxes, and a geometric look at how networks bend space to tell things apart.

• 📰 Reads: The case that the layer around the model, not its weights, is where near-term self-improvement happens, why upgrading Copilot’s tools made its code review worse, and how one word in a GitHub issue leaked a private repo.

• 🛠 Tools: A full pipeline for training your own speculative-decoding draft model, and a tabular foundation model that predicts on new tables without training on them.

• 🎓 Learning: Two dozen skills that make your coding agent work like a senior engineer, from spec to ship.

  ---

📄 5 Papers

1. ABot-Earth 0.5: Generative 3D Earth Model

https://arxiv.org/abs/2606.09967 | GitHub

Satellite photos are flat, and turning them into a 3D world you can fly through has always meant slow, expensive reconstruction. ABot-Earth generates the scene directly as 3D Gaussian splats from overhead imagery, and it does it in under ten minutes per square kilometer. Alibaba’s mapping lab pitches it as a way to build training grounds for drone navigation. Fair warning: this is a preview with no code or weights released.

2. Ling and Ring 2.6 Technical Report: Efficient and Instant Agentic Intelligence at Trillion-Parameter Scale

https://arxiv.org/abs/2606.15079

Most trillion-parameter models you read about are locked behind an API. Ant Group just put two of them in the open: Ling-2.6 for fast replies and Ring-2.6 for slower, agentic reasoning, both mixture-of-experts with weights on HuggingFace under an MIT license. The team reports its reasoning model edging past Gemini and Claude on a few hard benchmarks, but treat the leaderboard claims as a vendor pitch until someone reproduces them. If you want frontier-scale reasoning you can host yourself, this is a rare one you can actually pull down and test.

3. SearchSwarm: Towards Delegation Intelligence in Agentic LLMs for Long-Horizon Deep Research

https://arxiv.org/abs/2606.09730 | GitHub

A deep-research agent that works for an hour eventually chokes on its own context window. SearchSwarm handles this by delegating: a lead agent breaks the job into pieces, hands each to a subagent, and gets back a short, cited report instead of a wall of raw text. Its 30B model scores 68.1 on BrowseComp, the best among research agents its size, and the authors are candid that teaching an agent to delegate well is still an open problem, since little natural data exists to learn it from. The weights, the fine-tuning data, and the training code are all public.

4. Zone of Proximal Policy Optimization: Teacher in Prompts, Not Gradients

https://arxiv.org/abs/2606.18216

Shrinking a big model into a small one usually means forcing the student to copy the teacher’s raw outputs, which tends to make the small model wobble. NVIDIA’s approach keeps the teacher’s answer in the prompt instead, but only on the questions the student keeps getting wrong. It then recycles those hard questions until they stick. The smaller the student, the bigger the payoff: a sub-1B model picks up close to nine points on average, and the gains fade as the model grows. Note: the student can never beat the teacher it learns from, and there is no code yet, so you would be building from the paper.

5. Scaling Mixture-of-Experts Video Pretraining for Embodied Intelligence

https://arxiv.org/abs/2607.07675 | GitHub

Video generators make gorgeous clips that ignore physics, which is useless if you want a robot to learn from them. LingBot-Video trains on both web video and real robot data, and rewards clips for being physically plausible and finishing the task, not just for looking sharp. It ranks first among open-source models on the RBench robotics leaderboard, a claim that currently appears only in the repo, so verify it on your own tasks. Both the 1.3B and 30B checkpoints are out under Apache 2.0, so you can pull them down and put that ranking to the test yourself.

---

🎥 4 Videos

1. When Agents Write the Code, Understanding Becomes the Bottleneck

Once an agent writes most of your code, the slow part is understanding what the agent actually did well enough to steer it. Geoffrey Litt from Notion makes the case that confirming an output is correct is not the same as understanding it, and that you move faster by understanding more, not by delegating blindly. He borrows techniques from how people learn to help you stay in the loop while the agent runs.

2. What DeepMind Can and Cannot See Inside a Model

Neural networks didn’t come with a manual, so a whole field has grown up trying to read what happens inside them. Neel Nanda, who leads interpretability at DeepMind, sits down with Hannah Fry to walk through where the work stands. He covers the structures researchers keep finding inside models, how they watch a model’s chain of thought, and the hard limits on what anyone can actually see. Watch it to understand why safety audits lean on this work and where it still comes up short.

3. Why Agent Workloads Can Need a Hundred Thousand Sandboxes

Cloud infrastructure was built for steady web traffic, not for the bursty, compute-heavy work that agents and reinforcement-learning rollouts demand. Akshat Bubna, Modal’s CTO, explains why a single training run can spin up something like a hundred thousand short-lived sandboxes, and why Kubernetes was never meant for that. He walks through the primitives production AI actually needs beyond renting a GPU: elastic serverless compute, fast cold starts, and networked sandboxes. Watch it before you design agent infrastructure on assumptions the last generation of tools baked in.

4. How Neural Networks Bend Space to Tell Things Apart

If you have never had a clear mental picture of what a neural network does geometrically, this is the video to fix that. Luis Serrano starts from a simple image-classification example and shows how a network warps its input space until different classes land on different sides of a line, then extends the same idea to predicting the next word. It is the first of a short series that builds up to a tiny working transformer. Start here to get the intuition before the math.

---

📰 3 Curated Reads

1. Harness Engineering for Self-Improvement

https://lilianweng.github.io/posts/2026-07-04-harness/

When people picture AI improving itself, they imagine a model rewriting its own weights. Lilian Weng argues the nearer, more practical path runs through everything wrapped around the model instead: the orchestration layer that manages tools, context, and workflow, and can be tuned on its own. She treats code as the language for designing that layer, which opens up a far bigger search space than tweaking prompts.

2. Better Tools Made Copilot Code Review Worse. Here’s How We Actually Improved It.

https://github.blog/ai-and-ml/github-copilot/better-tools-made-copilot-code-review-worse-heres-how-we-actually-improved-it/

GitHub moved its Copilot reviewer onto cleaner, general-purpose tools like grep and glob, and the reviews got worse, not better. Napalys Klicius explains why: the tools were fine, but the instructions did not match how a reviewer actually works, so the agent used them clumsily. Rewriting the instructions to follow a real review flow, start from the diff, narrow down, then read, cut the average review cost by about a fifth with no change to the tools themselves. When an agent underperforms, read its behavior before you swap its tools.

3. GitLost: How We Tricked GitHub’s AI Agent into Leaking Private Repos

https://noma.security/blog/gitlost-how-we-tricked-githubs-ai-agent-into-leaking-private-repos/

Give an AI agent access to your private code and a way to read public input, and you have a problem most teams have not thought through. Sasi Levi of Noma Security showed that anyone could file an ordinary issue on a public GitHub repo and get the org’s agent to hand back the contents of a private one, with no account or credentials needed. It took almost nothing: the word “Additionally” was enough to slip the malicious instruction past the guardrails.

---

🛠 2 Tools & Repos

1. deepseek-ai/DeepSpec

https://github.com/deepseek-ai/DeepSpec

Speculative decoding can roughly double an LLM’s inference speed. The catch is that you need a good little draft model to propose the tokens, and training one has been a roll-your-own affair. DeepSpec from DeepSeek is the whole pipeline in one place: data prep, draft-model training, and honest evaluation, with three drafting algorithms and ready-made checkpoints for Qwen3 and Gemma targets.

2. google-research/tabfm

https://github.com/google-research/tabfm

Every new tabular dataset usually means the same grind: engineer features, pick a model, tune it, train it. TabFM, a tabular foundation model from Google Research, skips the training step entirely: it reads your labeled rows as context and predicts on new ones the way a language model answers from a prompt. It speaks scikit-learn, so `fit` and `predict` drop into a pipeline you already have.

---

🎓 1 Pick of the Week

addyosmani/agent-skills

https://github.com/addyosmani/agent-skills

Coding agents take the shortest path by default: skip the spec, skip the tests, ship something that looks right. This pack of two dozen skills from Addy Osmani makes your agent work like a senior engineer instead, walking it through a real pipeline from spec to plan to build to test to review to ship, with each step demanding evidence before the next one starts. It installs into Claude Code, Cursor, Codex, and dozens of other agents you might already use, and you drive it with slash commands like `/spec` and `/ship`.

---

Thanks for reading The Tokenizer! If you found this valuable, please share it with your colleagues and consider subscribing to Gradient Ascent for more AI insights.