King Chatterjee

Engineer/CTO/entrepreneur; ex- @BCG, @MDInsiderCorp; current AI@FirstAmerican; opinions strictly my own;

[Geoffrey Hinton @geoffreyhinton]

The idea of an intelligence explosion caused by recursive self improvement has been around for a long time but until very recently it did not seem imminent. Now many leading researchers think it may happen quite soon. You can read our paper about it here:
https://t.co/sgUpugjpRY

[Layton Gott @Layton_Gott]

Yesterday I said Jev would open a ton of doors...

24 hours later, this exists.

Cua built a 2.8MB model that scored 99.7% on their form-filling eval.

Hosted Jev scored 83.6%.

Not to mention it's FREE and only 706K parameters.

Small enough to run locally with not even 1gb or ram.

Fast enough to make decisions in one pass.

And specialized enough that your agent doesn't need to call a giant LLM for every tiny action.

Think about what this unlocks.

Every repetitive computer task could eventually get its own tiny specialist:

• forms
• CRM updates
• data entry
• browser actions
• document routing
• UI decisions

Then one powerful agent just routes work between them.

We are going to see some ridiculous stuff built from this as well.

[Matt Van Horn @mvanhorn]

https://t.co/qucRe9hvqg

[Matt Van Horn @mvanhorn]

TL;DR of my new article: WTF is Jev by @typesafeai, and the 9 things people are already building with it. The thesis: 𝗮 𝗰𝗼-𝗰𝗿𝗲𝗮𝘁𝗼𝗿 𝗼𝗳 𝗖𝗵𝗮𝘁𝗚𝗣𝗧 𝘀𝗽𝗲𝗻𝘁 𝘁𝘄𝗼 𝘆𝗲𝗮𝗿𝘀 𝗶𝗻 𝘀𝘁𝗲𝗮𝗹𝘁𝗵 𝗼𝗻 𝗮 𝗺𝗼𝗱𝗲𝗹 𝘁𝗵𝗮𝘁 𝗰𝗮𝗻𝗻𝗼𝘁 𝘄𝗿𝗶𝘁𝗲 𝗮 𝘀𝗲𝗻𝘁𝗲𝗻𝗰𝗲, 𝗮𝗻𝗱 𝗶𝗻𝘀𝗶𝗱𝗲 𝟳𝟮 𝗵𝗼𝘂𝗿𝘀 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀 𝘄𝗶𝗿𝗲𝗱 𝗶𝘁 𝗶𝗻𝘁𝗼 𝗲𝘃𝗲𝗿𝘆 𝗰𝗵𝗲𝗮𝗽 𝗷𝘂𝗱𝗴𝗺𝗲𝗻𝘁 𝗰𝗮𝗹𝗹 𝗮𝗻 𝗮𝗴𝗲𝗻𝘁 𝗺𝗮𝗸𝗲𝘀.

Think AI multiple choice, not AI essay writing. It doesn't chat. You hand it app state plus a typed question, it hands back a decision with a probability attached. 𝟯𝟭.𝟰𝗠 𝘃𝗶𝗲𝘄𝘀 on the launch post in two days (@CompleteSkeptic, who co-invented RLHF). I ran @slashlast30days on it 11 times, then checked every big post by hand.

🌐 𝗔 𝘁𝗶𝗻𝘆 𝗼𝗽𝗲𝗻 𝘀𝗼𝘂𝗿𝗰𝗲 𝗯𝗿𝗼𝘄𝘀𝗲𝗿 𝗮𝗴𝗲𝗻𝘁 𝗳𝗼𝘂𝗻𝗱 𝗳𝗹𝗶𝗴𝗵𝘁𝘀 𝗶𝗻 𝟳 𝘀𝗲𝗰𝗼𝗻𝗱𝘀 𝗳𝗼𝗿 $𝟬.𝟬𝟬𝟯𝟵. New action space every step, DOM as state, Jev picks the click, a small LLM only wakes up to type. The Browser Use founder built it (@gregpr07, 7.2K likes, 1.8M views) and had to note the video is 1x speed

🧹 The sleeper: instant compaction. Score every tool call, drop the junk, skip the summarization prompt entirely. "𝘪𝘯 2026, 𝘸𝘩𝘺 𝘪𝘴 𝘤𝘰𝘮𝘱𝘢𝘤𝘵𝘪𝘰𝘯 𝘴𝘵𝘪𝘭𝘭 𝘢 𝘴𝘶𝘮𝘮𝘢𝘳𝘪𝘻𝘢𝘵𝘪𝘰𝘯 𝘱𝘳𝘰𝘮𝘱𝘵?" asked @tamarajtran, 5K likes, then shipped the answer that afternoon. Run as a Claude plugin it took a session 𝗳𝗿𝗼𝗺 𝟭𝗠 𝘁𝗼𝗸𝗲𝗻𝘀 𝘁𝗼 𝟴𝟲𝗞 𝗶𝗻 𝗼𝗻𝗲 𝘀𝗲𝗰𝗼𝗻𝗱 (@altryne). Diogo's reply: "𝘧𝘳𝘦𝘦 𝘤𝘰𝘥𝘪𝘯𝘨 𝘢𝘨𝘦𝘯𝘵𝘴 𝘧𝘳𝘰𝘮 𝘥𝘦𝘴𝘪𝘨𝘯𝘪𝘯𝘨 𝘢𝘳𝘰𝘶𝘯𝘥 𝘵𝘩𝘦 𝘒𝘝 𝘤𝘢𝘤𝘩𝘦"

🛡️ Vercel put it in production as the safety reviewer in fx auto mode. 𝗨𝗽 𝘁𝗼 𝟭𝟴𝘅 𝗳𝗮𝘀𝘁𝗲𝗿 𝗮𝘁 𝗽𝟵𝟱 𝗮𝗻𝗱 𝗺𝗼𝗿𝗲 𝗮𝗰𝗰𝘂𝗿𝗮𝘁𝗲 than the model it replaced, per @rauchg, 3.7K likes. LangChain open-sourced the same idea the next day as AutoModeMiddleware. The closed danger classifier inside every coding harness is now a 100ms primitive

🚦 Model routing as middleware instead of a paragraph in a system prompt. About a dozen lines, probabilities left in agent state so you can audit the choice. The LangChain writeup by @sydneyrunkle is the cleanest how-to-wire-it piece anyone has published

🔎 RAG precision, solved the dumb way: retrieve as usual, run Jev on every chunk, delete the irrelevant ones. "𝘢𝘭𝘴𝘰 𝘥𝘪𝘥 𝘢𝘯𝘺𝘰𝘯𝘦 𝘳𝘦𝘢𝘭𝘪𝘻𝘦 𝘫𝘦𝘷 𝘴𝘰𝘭𝘷𝘦𝘥 𝘱𝘳𝘦𝘤𝘪𝘴𝘪𝘰𝘯 𝘪𝘯 𝘙𝘈𝘎?" (@kushbhuwalka, 416 likes)

🎮 Minecraft in real time: 𝗝𝗲𝘃 𝗿𝗲𝗮𝗰𝘁𝘀, 𝗚𝗣𝗧-𝟲 𝗔𝘀𝘁𝗿𝗮 𝗽𝗹𝗮𝗻𝘀, and they fight multiple zombies at once (@wuyang_zhou). A launcher that reads intent on every keystroke in about 100ms (@dabit3). TypeSafe's own demo is Doom at 10 decisions a second, roughly $7 an hour

📬 Email triage at scale: 1,500 emails in batches of 100 with 8 workers, 60,996 views on the demo. "𝘞𝘦 𝘰𝘯𝘭𝘺 𝘩𝘢𝘷𝘦 𝘢 𝘣𝘢𝘭𝘢𝘯𝘤𝘦 𝘰𝘧 $5 𝘥𝘰𝘸𝘯 𝘩𝘦𝘳𝘦, 𝘸𝘩𝘪𝘤𝘩 𝘫𝘶𝘴𝘵 𝘴𝘩𝘰𝘸𝘴 𝘩𝘰𝘸 𝘤𝘩𝘦𝘢𝘱 𝘵𝘩𝘪𝘴 𝘮𝘰𝘥𝘦𝘭 𝘪𝘴"

🗂️ 𝟳𝟳𝟳 𝗷𝘂𝗱𝗴𝗺𝗲𝗻𝘁𝘀 𝗶𝗻 𝘂𝗻𝗱𝗲𝗿 𝟬.𝟳 𝘀𝗲𝗰𝗼𝗻𝗱𝘀 𝗳𝗼𝗿 𝗮 𝗾𝘂𝗮𝗿𝘁𝗲𝗿 𝗼𝗳 𝗮 𝗰𝗲𝗻𝘁. Every's head of evals asked 21 questions of 37 documents in one request, and that is what came back

🧪 Jev in your browser: Reflex, a Qwen model doing structured decisions on WebGPU, built at Shopify by @kshetrajna and passed around by @tobi. Three independent clones inside 72 hours. 𝗧𝗵𝗲 𝗶𝗻𝘁𝗲𝗿𝗳𝗮𝗰𝗲 𝗶𝘀 𝘁𝗵𝗲 𝗶𝗻𝘃𝗲𝗻𝘁𝗶𝗼𝗻, 𝗻𝗼𝘁 𝘁𝗵𝗲 𝘄𝗲𝗶𝗴𝗵𝘁𝘀

🔌 Already behind the gateways you use: @vercel AI Gateway inside 48 hours (2,341 likes, the company's second-biggest post), Cloudflare, and @OpenRouter in beta

💸 𝟱,𝟬𝟬𝟬 𝗿𝗲𝗾𝘂𝗲𝘀𝘁𝘀 𝗳𝗼𝗿 𝗮𝗯𝗼𝘂𝘁 $𝟮. That was one developer counting his bill on day one (@MichaelLee04, 3,060 likes). Input is $0.042 per million tokens. Output is free

🧨 The honest part: Every's second test came out 𝟮𝟱𝘅 𝗳𝗮𝘀𝘁𝗲𝗿, 𝗻𝗼𝘁 𝟮𝟬𝟬𝘅, and Jev caught 6 of 7 planted defects to Fable 5.1's 7. The HN launch thread (1,863 points) spent most of its length on "can't hallucinate." Top critical comment: "𝘪𝘵 𝘤𝘢𝘯'𝘵 𝘦𝘮𝘪𝘵 𝘢𝘯 𝘪𝘯𝘷𝘢𝘭𝘪𝘥 𝘵𝘺𝘱𝘦, 𝘣𝘶𝘵 𝘪𝘵 𝘤𝘢𝘯 𝘴𝘵𝘪𝘭𝘭 𝘦𝘮𝘪𝘵 𝘢 𝘤𝘰𝘮𝘱𝘭𝘦𝘵𝘦𝘭𝘺 𝘸𝘳𝘰𝘯𝘨 𝘷𝘢𝘭𝘪𝘥 𝘷𝘢𝘭𝘶𝘦." Diogo called the "it's a zero-shot classifier" read "𝘷𝘦𝘳𝘺 𝘢𝘤𝘤𝘶𝘳𝘢𝘵𝘦!" And the biggest Reddit thread is someone who open-sourced the same architecture a year ago, 1,568 upvotes. Top reply: "𝘉𝘶𝘵 𝘥𝘪𝘥 𝘺𝘰𝘶 𝘱𝘰𝘴𝘵 𝘪𝘵 𝘴𝘢𝘺𝘪𝘯𝘨 𝘪𝘵'𝘴 𝘵𝘩𝘦 𝘯𝘦𝘹𝘵 𝘣𝘪𝘨 𝘵𝘩𝘪𝘯𝘨? 𝘙𝘰𝘰𝘬𝘪𝘦 𝘮𝘪𝘴𝘵𝘢𝘬𝘦"

Bonus: the name is not Kahneman. It's William Stanley Jevons, of Jevons paradox. Make a resource cheaper and people consume far more of it. Naming your decision model after that is a thesis statement.

𝗞𝗲𝗲𝗽 𝘁𝗵𝗲 𝗯𝗶𝗴 𝗺𝗼𝗱𝗲𝗹 𝗳𝗼𝗿 𝘁𝗵𝗲 𝗵𝗮𝗿𝗱 𝘁𝗵𝗶𝗻𝗸𝗶𝗻𝗴 𝗮𝗻𝗱 𝘄𝗿𝗶𝘁𝗶𝗻𝗴. 𝗨𝘀𝗲 𝗝𝗲𝘃 𝗳𝗼𝗿 𝘁𝗵𝗲 𝗿𝗮𝗽𝗶𝗱-𝗳𝗶𝗿𝗲 𝗱𝗲𝗰𝗶𝘀𝗶𝗼𝗻𝘀 𝗶𝗻 𝗯𝗲𝘁𝘄𝗲𝗲𝗻. That's the whole article.

[vas @vasuman]

https://t.co/oxa2EB0xtY

[Hyperagent @hyperagentapp]

Ditch the maintenance of OpenClaw. Get Hyperagent running in minutes. Get $100 at signup + $500 credits when you migrate.

[Andrew Ng @AndrewYNg]

The most important skills for using AI coding agents effectively. Presenting the AI Engineering Skills Map for using coding agents. https://t.co/GrEw7wG5Wz

[François Chollet @fchollet]

It is inevitable that all AI will converge towards symbolic learning (i.e. modeling data by finding the shortest symbolic program that explains it), since that is the optimally efficient form of AI. But there can be more than one evolutionary path to this destination.

[François Chollet @fchollet]

GPT-6 Astra represents a step-function change in model capability for interactive reasoning problems. It scores 66% on ARC-AGI-3 using our standard harness, and nearly 100% with a continuous conversation harness and custom compaction, at a cost of roughly $360 per game.

In fact, the continuous harness version significantly outperforms our human baseline in action efficiency across almost all levels. When we examined the reasoning chains to understand how the model operates, we found it performing highly efficient, on-the-fly symbolic world modeling for each game and level. It goes as far as developing its own shorthand DSL to represent in-game situations -- essentially a game-specific algebraic notation.

Overall, Astra exhibits symbolic modeling behaviors we had previously only seen with sophisticated harnesses -- so harness capabilities are increasingly shifting into the model itself.

We see Astra as a major breakthrough in model intelligence.

Read our post on Astra and what these results mean: https://t.co/wJnYxEqYNI

[Sebastian Raschka @rasbt]

The YT version of this:
https://t.co/VRL5dPMTk5

[Sebastian Raschka @rasbt]

A lot of hype around OpenAI's Astra model here on my timeline today. Apparently, this goes back to a new article from The Information, which said Astra is a "recurrent depth or looped transformer".

It's always interesting to read about new or different approaches (including rumors about what the closed labs may be up to), but let's debunk this a bit.

About 2 months ago, I shared the architecture details of Nanbeige, for example, where "Nanbeige4.2-3B is pretrained from scratch on 28T tokens with a Looped Transformer that reuses the layer stack to increase capacity without adding parameters."

Yes, that's it. The looped transformer idea is just reusing layers in the transformer block.

In the case of Nanbeige, the main idea is to reuse the same 22-layer stack (=transformer block) twice instead of once. So, effectively it extends the 22-layer architecture to 44 layers, but without duplicating the weights.

In simple terms, this roughly doubles the size of the model (if we ignore the embedding and output layers for a second). But instead of requiring 2x the storage and RAM to host this model, it stays at the same size since we reuse the components. However, it's almost 2x as expensive in terms of compute, because we run the embedded text through almost 2x as many layers.

Why? In the Nanbeige 4.2 technical report, the researchers found that two passes gave the best trade-off and retained about 75% of the token efficiency of a standard architecture. (More passes gave barely any gains but made the training much slower and much more expensive.)

While, as far as I know, Nanbeige 4.2 is the first notable open-weight model that adopted this approach, the idea goes back to the NeurIPS paper "Mixture-of-recursions: Learning dynamic recursive depths for adaptive token-level computation". Actually, this paper proposes a mechanism that is a bit more sophisticated by adding a learned router that determines whether each token receives one, two, or more passes. So, easy tokens can exit early while harder tokens receive additional computation.

In sum, Astra may be a really good model, but this shouldn't be about this "looped transformer aspect," which is just a tiny architectural tweak.

Also, the statement "the new technique works in a way that obscures some or all of the AI's reasoning, otherwise known as 'chain-of-thought'" is not necessarily true with respect to the looped transformer method. It's possible that The Information journalist refers to some other technique or misunderstood the looped transformer method.

Reusing layers does not by itself suppress visible chain of thought. It adds computation in hidden states before the next token is emitted, just as ordinary transformer layers do.

But based on the information we have, the only plausible interpretation here is that if a model uses more of these recurrent passes, it may need to generate fewer intermediate reasoning tokens. So then more of its computation happens in latent activations that cannot be read as text. But we would get the same effect if we were scaling up the model size, like GPT 5.6 Luna -> GPT 5.6 Sol.

[Superman @thesupermannx]

Chinese researchers published a paper with a devastating title: "The End of Software Engineering”

it argues software engineering is finished.

In traditional software, code is the carrier of pre-written human logic.

In agentic software, the AI agent is the software.

Code is no longer a permanent monument built by human hands. It is completely ephemeral, dynamically generated, executed, and discarded on the fly by an LLM-driven reasoning loop.

Think about how software delivery has evolved:

• Era 1: On-premise licensed software (you installed it locally)
• Era 2: SaaS (hosted in the cloud, managed by vendors)
• Era 3: Agent-as-a-Service (AaaS)

Each historical shift transferred complexity away from the user. But this latest shift transfers something entirely different.

It transfers decision-making complexity itself.

The paper argues that traditional engineering is hitting a hard complexity wall. Human brains can only hold so much state, manage so many dependencies, and debug so many lines at once.

LLM-based agents scale non-linearly.

They don't just write functions faster. They navigate architectural complexity by outsourcing reasoning to models that improve every single month.

Which means the role of the developer is permanently changing.

You are no longer a code author typing syntax line by line.

You are an intent architect.

Your job is no longer writing the implementation. It is specifying goals, designing multi-agent coordination loops, and auditing outcomes.

[siddontang @siddontang]

Really enjoyed Uber’s write-up on its internal AI Software Factory.

I’ve never been a big believer in:

AI productivity = buying everyone a Claude/OpenAI seat.

That may help individuals, but at company scale you still need to manage models, context, tools, permissions, evaluation, and cost.

Uber is going much further with a unified harness, model routing, MCP gateway, benchmarks, cost controls, and managed agents.

That’s also why we’ve been building our own Agent Stack.

The more I think about it, the more I believe:

Don’t manage AI seats. Manage AI work.

[Brian Roemmele @BrianRoemmele]

Research paper finds:

“Everyone gains with AI use in the short run. The long run depends on how you engage”

The 8 Modes of AI Engagement: How You Work With AI Determines Whether It Makes You Sharper or Duller

Most people treat AI as a smarter search engine or a tireless junior employee. They ask a question, receive a fluent answer, and move on. That pattern feels efficient. Research grounded in cognitive science, learning theory, and human-computer interaction suggests it is also quietly costly.

The AI Engagement Modes framework at Brigham Young University) and detailed in the research foundations at https://t.co/8OJzOrCzox, classifies human-AI interaction into eight observable modes. These modes sit on a clear gradient of cognitive agency—from near-total passivity to full human control over problem framing. The framework draws on Bloom’s revised taxonomy, Chi’s ICAP framework (Interactive, Constructive, Active, Passive), Zimmerman’s model of self-regulated learning, Vygotsky’s Zone of Proximal Development, distributed cognition, epistemic vigilance, and Schön’s reflective practice.

The central claim is straightforward: the way you engage AI shapes whether the technology amplifies your thinking or gradually erodes it.

The eight modes are grouped into three tiers of increasing human agency:

Passivity (Modes 1–2): The human largely cedes cognitive work to the AI.
Partnership (Modes 3–4): Human and AI form a joint cognitive system with shared effort.
Agency (Modes 5–8): The human retains or reasserts primary cognitive authority—verifying, challenging, expanding, or defining the problem itself.

Higher tiers map to deeper learning and better long-term skill retention. Lower tiers map to short-term performance gains that often reverse when AI is removed.

The 8 Ways of Engagement

Here are the eight modes, ordered from lowest to highest cognitive agency:

1. Oracle
You treat the AI as an authoritative source of answers. You ask broad or factual questions and largely accept the output. This corresponds to Bloom’s “remembering” level. It is efficient for quick facts but trains the habit of not checking or synthesizing.

2. Production (or Production Assistant)
You use the AI primarily as a generator of finished or near-finished output—text, code, summaries, plans—with minimal editing, verification, or reframing. The cognitive work of creation is mostly offloaded. This is still passive in the sense that the human does little constructive or critical processing.

3. Tutor
You use the AI as a scaffolded teacher. You ask for explanations, step-by-step guidance, or clarification within your Zone of Proximal Development. You remain engaged enough to learn rather than merely receive. This is the first genuine partnership mode.

4. Collaborative Problem-Solver
You and the AI work together as a distributed cognitive system. You break problems into steps, iterate, supply context, and build on the AI’s contributions while directing the overall direction. Cognition is shared rather than handed over.

5. Verification Agent
You actively evaluate the reliability of the AI’s claims before accepting them. You check assumptions, cross-reference, test edge cases, or demand evidence. This reactivates epistemic vigilance—the evolved capacity to scrutinize communicated information that fluent AI output can otherwise bypass.

6. Critical Challenger
You treat the AI as a sparring partner. You argue against its reasoning, force it to defend positions, surface weaknesses, or explore counter-arguments. This leverages the argumentative nature of human reasoning and produces stronger evaluation skills.

7. Creative Expander
You use the AI to push beyond the given frame—generating novel variations, analogies, alternative framings, or divergent possibilities. The human remains the director of creative direction while the AI multiplies options.

1 of 2

[Avi Chawla @_avichawla]

8 ways to improve LLM reasoning at inference time:

(used by Google, OpenAI, and Anthropic)

When accuracy on a task falls short, the cheapest place to intervene is inference.

There's no retaining, so the techniques either go in the prompt or the orchestration around the call.

Inference compute scales in two ways:

- You sample the same prompt several times and select among the results
- or you extend one trajectory further before the model answers.

Parallel samples batch and run concurrently, so more samples cost tokens and GPU time while it barely affects latency.

Sequential tokens each condition on the one before, so more thinking costs latency directly.

Tree methods compose both, and inherit both failure modes.

1) Chain of thought

The model is prompted to think step by step, so intermediate results land in the context where later tokens can condition on them.

2) Majority voting

Sample several traces and return whichever final answer appears most often. Agreement replaces a reward model.

It reduces variance and does nothing about bias.

When the model misreads a problem the same way every time, the traces agree, and the vote returns that answer with higher confidence.

3) Best-of-N

Score N complete answers with a reward model, keep the top one.

True reward rises, peaks, then declines as optimization pressure on the proxy increases. Past that peak, the search starts finding answers the reward model likes instead of the answers that are actually correct.

4) Extended thinking

The model spends a token budget on internal reasoning first.

Longer is not uniformly better. Anthropic built tasks where accuracy falls as traces lengthen, including counting problems where irrelevant numbers pull the model off track.

5) Self-refinement

The model critiques and rewrites its own answer.

On GSM8K, GPT-3.5 fixed 7.6% of its wrong answers and broke 8.8% of its correct ones. This is net negative, and it works when the critique comes from a compiler or a test suite instead.

6) Tree of thought

Propose several next steps, score them, keep the best few, backtrack from dead ends.

7) Beam search

Keep K partial solutions and score every step with a process reward model.

The technique works better than best-of-N at small budgets and worse at large ones, because the search starts satisfying the scorer instead of solving the problem.

8) MCTS

Extend a promising path, roll out to a full answer, push the score back up, repeat.

The action space forces a cap on node expansion, and applying that limit leaves the search in local optima.

Every technique here generates candidates and picks among them, so the selector sets the ceiling.

As a takeaway, build the verification signal first. Scale the search second.

To dive deeper, I covered all 8 techniques with the research behind them, the tradeoffs, and pseudo code you can adapt.

Read it below.

[Kirill @kirillk_web3]

https://t.co/Xp9CAdJL2R

[Superman @thesupermannx]

Google DeepMind researchers argue we need to stop building LLMs..

They published a paper that proposes an alternative solution that changes everything.

LLMs are incredible at predicting the next token.

But they are fundamentally missing the core architecture of true intelligence. They lack persistent memory, an active world model, dynamic goal management, and continuous self-evolution.

They are a supercharged engine without a car.

The paper lays out the definitive shift we must make: Foundation Agents.

Instead of treating the LLM as the entire product, we have to move toward modular, brain-inspired architectures.

The new blueprint breaks AI down into distinct biological and cognitive systems:

• The World Model: An internal simulation to test consequences before taking action, rather than just guessing text sequences.

• Dynamic Memory & Perception: Persistent systems that learn, adapt, and evolve from real-world feedback rather than static pre-training data.

• Reward & Goal Processing: Systems capable of long-horizon autonomous planning instead of waiting for a human prompt.

• Collaborative Societies: Multi-agent ecosystems where intelligence emerges from negotiation, competition, and interaction rather than a monolithic chatbot.

The takeaway is brutally clear:

Scaling laws are flattening. Simply throwing more text at a transformer won't get us to AGI.

Paper: Advances and Challenges in Foundation Agents.. by researchers at Google DeepMind and leading AI labs.

[Andrew Ng @AndrewYNg]

New: A map of the most important skills in AI Engineering. https://t.co/VVkn1Dqp1N

[Hades @0xHvdes]

https://t.co/26ibXrwogg

[Machina @EXM7777]

i just open sourced the workflow behind $2M AI video productions...

i built 7 skills that run the pipeline end to end, built for Seedance 2.5 and they work in Claude Code, Codex, Hermes or any harness (works best with 1080p using Higgsfield CLI)

here's how to use them, in order:

/setup writes which image and video models you run into your project, once, so every skill reads the same stack

/studio-init scaffolds the whole studio as a file tree from one question, the project name

/film-breakdown walks your script scene by scene and writes a 22-field card for every shot

/reference-board locks your references into a visual bible, a caption on every image and a ban list for the rest

/asset-passport writes the exhaustive descriptor every later prompt will quote word for word

/stress-test combat-tests each asset and flips it to locked only at 10 out of 10 repeatability

/shot-prompt refuses to run until everything in frame is locked, then writes the 15-block prompt and logs every attempt

get access to the skills and full breakdown of the pipeline in the article below: