It's pretty nuts that the initial pretraining phase for Inkling 2 was done in 68 hours.
For comparison, DeepSeek V3's pretraining took almost 2 months back in late 2024 (though looks like TML did other additional pretraining phases as well, so not totally accurate comparison).
Also interesting to note that @ProximalHQ got a shoutout in the announcement. I don't think I've seen an eval partner get a callout like that before.
Introducing Inkling 2 Small. Scoring 31 on the AA Intelligence Index, it's a big jump over its predecessor.
Inkling 2 Small is available for fine-tuning and inference on Tinker today, with full weight release planned soon.
thinkingmachines.ai/news/ink…
I've been building Jenga towers with my daughter recently, and it got me thinking about how to build the tallest possible structure.
So I made a physics simulator and had Claude Code + Codex iterate on the best possible architectures. Some fun findings:
- Building a good base is important, 40% of blocks are in the bottom quarter of the tower. But you can't overdo it, because spending too many blocks on your base means you don't have enough for gaining height
- The last few blocks make a huge difference, especially if you make them vertical. Many of the winning simulations made small iterations to get vertical blocks at the top of the tower
- The winners were combinations of previous winners + small adjustments. They were found by iterating on the good parts of old towers and combining them with small perturbations.
Full write up here: johnjwang.com/post/2026/10/2…
And here's a gif of all winners at different degrees of tilt (to simulate how stable you want your tower to be)
This is probably any personal agent right now.
You have a slider between is it capable enough and are people willing to pay for it.
The more compute / intelligence you throw at it, the better it becomes. But also, the harder it is to get people to pay.
115
I wonder if some models are RL’ed to favor using their own company’s models in production.
I’ve had this happen twice now where Claude Code suggested using Haiku, and also when Codex suggested GPT-5.6-Luna for a task.
I wouldn’t be surprised if they did do this, but maybe another reason to use multiple sources of intelligence and multiple providers.
5
5
470
John Wang retweeted
If you run a service on the internet and you aren't running a tool that mines your codebase for vulns right now you are committing malpractice.
Make sure you are using something built post-AI. Anything pattern-based / rule-based is not good enough. A quarterly pentest is not good enough.
You have a responsibility to your users. Don't be tomorrow's story.
I frequently switch between Codex and Claude Code, depending on the task and the usage limits I have left.
It's very frustrating because you need to remember where you put a session, and it's a pain if you run out of usage in the middle of a task.
So I built a tool to hand off and archive sessions between coding agents:
github.com/wangjohn/agent-ar…
14
12
783
4. Claude Code currently deletes your local sessions after 30 days.
But my prediction is that your own coding agent data will be really important in the future. Agent archive puts it in the cheapest, reasonable storage (S3) automatically for you.
1
24
Have had @lilianweng’s post on LLM scaling laws bookmarked for a while, and I’m kind of sad I didn’t read it sooner: lilianweng.github.io/posts/2…
Two papers dominated thinking around scaling laws early on:
- Kaplan 2020 (hehe, know those names in the paper?) which said that training loss scales as a power law of parameter count, dataset size, and compute. It also found that given a fixed compute budget, it is more efficient to train a very large model and stop before convergence than to train a smaller model all the way to convergence
- Hoffmann 2022 (the Chinchilla paper) showed that there’s actually a specific way to find optimal breakdown given a fixed compute budget. It found that most models were undertrained (eg too many parameters and not enough input tokens of training data)
- Weng then helps reconcile these findings by noting how Kaplan didn’t account for embedding parameters and was focused on relatively small models
It’s really instructive, because you can see the industry progression of training huge models, then having smaller/denser models get the same level of performance, like when Llama13B beat GPT3 (175B).
Interestingly, seems like most labs now overtrain small models because inference is the dominant cost now.
4
139
Anthropic models are pretty token hungry. I run very similar workflows across Codex and Claude Code (I usually switch between them when I run out of limits), but I've got huge differences in tokens used and estimated spend.
Here's my last few days: number of sessions is basically the same, but cost is 5x higher on Claude Code.
Luckily, I think Anthropic adjusts their subscription plans accordingly, but if you're using their API billing, that's 💸💸.
2
10
471
When you're running lots of coding agents, deterministic checks become really important. Every agent needs feedback it can act on, and you need a reliable (and fast) way to check its work.
I've been creating a lot of Go repos recently, and each ended up with a slightly different collection of lint rules and CI checks. Keeping them synced was a pain.
So I built and open sourced Levenshtein (github.com/wangjohn/levensht…). It's a curated set of Go lint rules and automated checks that hooks up to your CI/CD.
As it improves, you can easily bump your version and get more lint rules, or opt into experimental rules.
It's focused on Go for now (since that's what I use the most) and I've used it quite successfully -- it's caught dropped context, ignored errors in test setup, and missing SQL error checks across a number of my projects.
Check it out, and would love feedback!
3
3
193
This makes a lot of sense, and will probably see way more of this happen.
Basically more of the world will be machine readable. Humans right now act as a weirdly bad interface into the world for agents, but that will likely change over the next few years
Happy to share that our paper "Mecha-nudges for Machines" has been accepted as a spotlight at NeurIPS 2026!
5
305
X just published the latest version of its ranking algorithm.
A few things that surprised me:
• A like is worth 0.5× but a copy-link share is worth 20×.
• Replies are 5× and go to 20× between mutual follows
• There's no link penalty anymore (so feel free to link whatever you want in your post)
• There's no Premium multiplier anywhere in the scoring code
• Posts drop out after 48 hours
How it works:
• Grok/Gemma read every post once and compress it into a 6-number "address" (basically an embedding)
• ~10M posts get filtered to ~2,800 near your history + people you follow
• A transformer predicts ~25 actions per post and scores Σ weight × P(action)
Full breakdown with links to the code: johnjwang.com/post/2026/09/2…
1
9
189
LLMs are doing to tech companies what humans did to mammoths.
57 species of giant herbivores were alive 50,000 years ago, but only 11 survive today.
Humans changed the rules of the game, and being huge went from an advantage to a liability. We didn't literally hunt every megafauna species to extinction, but we changed their trajectories enough to shrink total biomass by 90%.
LLMs will probably do the same, killing off some companies and shrinking a lot of others.
But there were winners, and each one has an AI equivalent:
- Generalists (🐀 rats): TSMC, Cloudflare, Stripe. They're everywhere and they don't care which lab wins as long as more tokens are flowing. Downside is they shrink when the market does
- Adapters (🐕 coyotes): Intercom, Handshake, Baseten. Keep your core asset but change what you eat. Handshake went from a college recruiting network to a $1B AI data business
- Partners (🐶 dogs, cows): Scale, Surge, Mercor. Stop competing with the labs and make yourself useful to them. Livestock are now 60% of all mammal biomass, but they only grow as fast as humans want them to, similar to how the data companies are tied to labs’ data budgets
- Start fresh (🦇 bats, horses): Cursor, Harvey, ElevenLabs. New companies filling niches that didn't exist a few years ago. Many of them won't make it though (e.g. Jasper, Tome)
The future cares much less about size, and much more about “fitness." Most AI-native winners are smaller and more efficient than before, just as the winning generation of animals after megafauna extinction were much smaller.
Read the full writeup here: johnjwang.com/post/2026/09/2…
2
185
The US strategic petroleum reserve is built on fascinating engineering:
- It’s carved from salt domes near the Gulf of Mexico. Nice thing about salt is that you can shoot water at it to carve out massive cylinders, meaning construction costs are much lower
- Rock salt has very low permeability, meaning oil can stay contained in these caverns without extra material
- Oil floats on water, so to get the oil out you just push water to the bottom of the cavern and collect the oil at the top
- These caverns are deep underground, making attacks on the infrastructure much harder
It’s an inexpensive and highly secure way of storing absolutely massive amounts of petroleum (700M barrels). The same amount in external floating roof tanks would cover a space the size of Washington DC.
Talked a bit more about the engineering here: johnjwang.com/post/2026/09/1…
Really liked this article on looped transformers (purportedly what Astra is using) magazine.sebastianraschka.co…
Basically:
- Send the inputs through the transformer block twice (or multiple times depending on some probability function)
- This decreases the memory / parameter footprint while multiplying your transformer blocks
- Not a new idea, and is implemented in other models
- It’s one change in Astra but may not really be that load bearing either way (Sebastian says the training environment and training data probably play a bigger role in the models outcomes)
3
186
Codex went from 98 Rust commits/month (91% by one author) to 900+ commits/month across 69 authors.
Because it's open source, Codex can teach us a lot about how OpenAI builds software:
- Codebase is geared around agents: 38 lint rules, a highly iterated-on AGENTS.md, very specific rules for how to write code
- Investment in tests: 40% of the codebase is tests, and they've invested in an integration test harness that mocks out LLM calls and runs the entire Codex harness.
- Well thought through migrations with feature flags, clean boundaries and abstractions
- Good hiring, especially for what looks like experienced engineers.
More details here:
johnjwang.com/post/2026/08/2…









