Like @davidbessis and others, I think that Hinton is wrong. To explain why, let me tell you a brief story. About a decade ago, in 2017, I developed an automated theorem-proving framework that was ultimately integrated into Mathematica (see: https://t.co/nGCIUk44TP) (1/15)

Do LLMs understand or are they just imitating? The debate about whether LLMs truly understand has long been stuck in a dead end. Some argue that it’s «just statistics», while others claim there are already seeds of a mind inside. The preprint discussed here suggests stepping out of this stalemate and reframing the question: what kind of understanding can exist inside a model, and through which mechanisms does it arise? The key idea is: understanding is the ability to see connections - between objects, properties, states, and rules. Mechanistic interpretability finally provides tools to examine whether such connections exist inside a model itself, rather than only in its outward answers. The authors propose viewing understanding as a multi-level structure. At the most basic level, a model forms internal concepts. These are not words or definitions, but stable «directions» in its internal space that activate across different manifestations of the same thing. Different phrasings, hints, or contexts pointing to the same object or idea can trigger the same internal feature. This goes beyond token matching: the model is able to unify variation into something shared. The next level is understanding the state of the world. Here it’s no longer just about concepts, but about relationships between them and how those relationships change over time. The clearest example is models trained to play Othello that never «see» the board, receiving only a sequence of moves. Analysis shows that they internally construct a representation of the current game state - where pieces are, which squares are occupied, which are free. Moreover, if you intervene directly in this internal representation, the model’s behavior changes in a predictable way. This no longer looks like memorizing patterns. It looks like maintaining an internal world model. But an important caveat follows: having such a model does not mean it is always used. The authors emphasize an uncomfortable but crucial point - models tend to switch to cheaper heuristics when those are sufficient. Even when «real» understanding is available, it does not have to be activated. The highest level is principled understanding. This is when a model does not merely know examples, but implements a compact rule or algorithm that generalizes the task. A classic example is the phenomenon of grokking in tasks like modular addition. For a long time the model overfits, achieving perfect training accuracy while failing on the test set - until suddenly it starts solving everything. Analysis shows that at this moment, what emerges inside is not a lookup table but a structured solution - for example, representing numbers as angles on a circle and performing addition through operations equivalent to trigonometric identities. This is no longer «memorization», but a discovered principle. At the same time, the authors are honest: such principles are usually crystallized through training, not derived on the fly. This is why humans still outperform LLMs on tasks that require quickly inferring a new rule from just a few examples, such as ARC-AGI. The final conclusion of the paper is perhaps the most important. An LLM is not a unified mind or a coherent thinking system. It is a motley mixture of mechanisms that coexist and compete. Sometimes a structural solution wins, sometimes a superficial heuristic does. Sometimes the model shows impressive understanding, and sometimes it stumbles on seemingly simple problems - simply because the «cheap path» turned out to be stronger. There are structures inside modern models that closely resemble understanding, but they do not form a single, reliable, self-regulating mind. And so the real question is not whether an LLM understands, but which type of understanding was activated in a given moment and what, exactly, overrode it. arxiv. org/abs/2507.08017

Agent Workflows are the fastest and most flexible way to build complex agentic systems, and we put them to the test. Our OSS engineer @itsclelia built a powerful integration with the Agent Client Protocol (ACP) by @zeddotdev, resulting in a fully customizable agent with access to filesystem and bash tools, MCP servers, persistent memory, and built-in TODO tracking 📝 Check out the demo, where the agent explores the LlamaIndex documentation using our dedicated MCP server, or try it yourself with 𝘶𝘷 𝘵𝘰𝘰𝘭 𝘪𝘯𝘴𝘵𝘢𝘭𝘭 𝘸𝘰𝘳𝘬𝘧𝘭𝘰𝘸𝘴-𝘢𝘤𝘱 Get started with LlamaAgents: https://t.co/Odb6MwyjTg GitHub repo 👉 https://t.co/H2JjRbmq9e

We're listening 👂LlamaSheets is in beta and we want your feedback Spreadsheets in the wild are messy—merged cells, broken layouts, headers spanning multiple rows. LlamaSheets (now in beta) extracts regions and tables from these files and outputs clean Parquet files you can actually use. What it does: · Identifies and isolates regions in your spreadsheet · Extracts them as Parquet files (load directly into pandas/polars/DuckDB) · Generates cell-level metadata (40+ features: formatting, position, data types) · Creates titles and descriptions for sheets and regions Built for the spreadsheets nobody wants to deal with manually. We need your feedback. While in beta and actively improving based on real-world use cases. Try it out and let us know what works, what doesn't, and what you need. Get started here: https://t.co/lk1reA8Yl0

Transform messy Excel files into AI-ready data with LlamaSheets—our solution for parsing complex spreadsheets while preserving semantic context and hierarchical structure. Join our live workshop: https://t.co/mgTvCBBHAN January 29th, 11 AM PT 📊 Handle merged cells, multi-level headers, and visual formatting that traditional parsing tools miss 🤖 Build spreadsheet-specific agents for financial analysis, budget parsing, and automated reporting ⚡ Convert spreadsheet chaos into structured Parquet files with just a few lines of code 🔗 Integrate seamlessly with LlamaAgents for complete workflow automation We'll demonstrate real examples including building financial analysis agents and consolidating multi-region data from large sheets. Perfect for anyone dealing with budget files, quarterly revenue tables, or any spreadsheet data that needs to feed AI systems.

Check out the form-filling agent that automates PDF forms using AI by @jerryjliu0 📄🤖 Use any fillable PDF with an agent that fills it out based on your prompts and context files. Our new experiment creates a multi-turn chat experience for form completion. 🔍 Upload fillable PDFs and automatically detect form fields using PyMuPDF 📝 Add custom prompts and context files (parsed via LlamaParse) to guide the AI 🤖 Multi-turn conversations let you refine and correct form entries after initial completion 💾 Download your completed forms when done The agent uses simple tools to list, set, get, and validate form fields. You can chat with it to make corrections and adjustments until your form is perfect. Check out the code on GitHub: https://t.co/Dft8Xr6uGd Or the deployed app here: https://t.co/36nG3EXpxB

I built a form-filling agent that anyone can use 💫 This is an extremely simple but useful (I hope) app. Upload a fillable form 📋, some context files, and chat with the agent to fill the form out automatically ✍️ 1️⃣ Yes it is a Claude Code SDK wrapper 2️⃣ It is better and faster than ChatGPT/Claude UI out of the box 3️⃣ We use LlamaParse to parse the context files, so you can have more trust that we are able to read context without hallucinations (e.g. messy scanned handwriting, drivers license photo, and more). This was one of my holiday Claude Code vibe-coding projects. Built with Opus 4.5, and also powered by Opus 4.5. Feeling the AGI 🫡 App is here: https://t.co/HYipU2fpFE Repo is open-source: https://t.co/GIfSzxGH4j

A problem we see often: long documents with different pieces of repeating content. Example: a resume book with a cover page, a few pages about student curriculums, then back to back resumes Build an intelligent resume processing agent that automatically extracts structured data from repeating content using LlamaSplit to identify where each individual content starts and ends and LlamaExtract to extract structured data: 📄 Upload PDF resume books to LlamaCloud and automatically categorize pages using LlamaSplit to separate individual resumes from curriculum and cover pages 🤖 Extract structured information from each resume using LlamaExtract with custom schemas to capture names, contact info, education, work experience, and skills etc (your choice) ⚡ Orchestrate the entire process with LlamaAgent Workflows 🔍 Process real resume data with confidence scores and structured output ready for filtering, searching, and candidate matching systems The tutorial uses an NYU Resume Book as an example and shows both individual API calls and a complete automated workflow implementation. Check out the full tutorial: https://t.co/snaWXuoHq8

Tired of wrestling with messy Excel files that break traditional parsers? 📊 Join our workshop on January 29th at 11 AM PT to see how LlamaSheets transforms chaotic spreadsheets into clean, AI-ready Parquet files while preserving all the context that matters. 📈 Handle complex structures like merged cells, multi-level headers, and visual formatting that traditional tools miss 🤖 Build spreadsheet-specific agents for financial analysis, budget parsing, and automated reporting 💼 See real examples: consolidating multi-region data and extracting quarterly revenue tables ⚡ Turn spreadsheet chaos into structured data with just a few lines of code We'll walk through practical use cases and show you integration patterns with LlamaAgents so you can build robust data processing pipelines. Register for the workshop: https://t.co/mgTvCBBHAN

Can filesystem tools really replace vector search? We put agentic file exploration to the test against traditional RAG. Our experiment with fs-explorer agent vs. hybrid RAG revealed some surprising insights about when each approach shines: 🏃 RAG is faster - averaging 3.81 seconds quicker thanks to fewer LLM calls and consistent network requests 🎯 Filesystem agents are more accurate - scoring 2 points higher on correctness by accessing full file context instead of chunked fragments 📈 Scale changes everything - at 100-1000 documents, RAG outperforms filesystem exploration in speed and maintains quality ⚖️ Context matters most - filesystem tools excel with smaller files that fit in the LLM's context window, while RAG handles massive document collections The verdict? It depends on your use case. Filesystem agents work great for smaller, focused document sets where accuracy trumps speed. RAG remains king for large-scale applications requiring real-time responses. Read the full experimental analysis by @itsclelia and see the results for yourself: https://t.co/DMG3jnYrKq

Context engineering isn't just about throwing more data at your LLM - it's about giving it the right context at the right time. In this talk for @OReillyMedia, our Developer Relations Engineer @tuanacelik walks through how memory blocks help you build agents that maintain structured context for complex tasks. She demonstrates artifact memory blocks using a restaurant order tracking bot - showing how to distill entire conversations down to just the essential structured information (pizza type, toppings, address) rather than processing the full chat history. Key concepts covered: · Different types of memory blocks (static, fact extraction, vector, artifact) · Context ratio management - balancing chat history vs system prompts vs memory · Using agent workflows to construct and optimize context step-by-step The example shows how artifact memory blocks can transform a meandering conversation into a clean, structured order - exactly what you need for production agents handling real-world tasks. Watch the full talk: https://t.co/jbGUMlobU8

Files are becoming the primary interface for AI agents to manage context, store conversations, and access skills 📁 @jerryjliu0 breaks down how coding agents like Claude Code and @cursor_ai are centralizing around filesystems as core abstractions, moving away from complex tool ecosystems: 📝 Agents store long conversation histories in searchable files to overcome context window limitations 🔍 File-based retrieval with semantic search outperforms traditional RAG patterns for dynamic context traversal ⚡ Skills defined as simple files are replacing complex MCP tools - just copy API specs into markdown files 🛠️ Agents need only ~5-10 core tools (CLI, code interpreter, web fetch) plus filesystem access to be highly capable The challenges ahead include parsing non-plaintext documents (PDFs, Word, Excel) and scaling file search to massive collections. That's exactly why we built LlamaCloud's Parse, Extract, and Sheets capabilities - to convert any document format into agent-ready context. Read the full analysis: https://t.co/Dy5cWYzUc6

Files are all you need 🗂️ I wrote a blog post to capture a trend I’m seeing in the AI agent landscape: that the primary way to equip agents with actions and context is through files and filesystems. 1️⃣ It is an easy way for agents to store context for later (e.g. @dexhorthy’s progressive disclosure) 2️⃣ It is a powerful search interface, in addition to or instead of RAG 3️⃣ It is a more flexible way to equip agents with tool calling. Coding agents + file tools are a good initial proxy for computer use. We’ll see if the trend persists, but there’s a ton more potential to explore here. Blog: https://t.co/wxEmvgan4w

Our mission these days is digitalizing paperwork 📄, and a lot of paperwork has handdrawn stuff - like highlights! If you upload a scanned form into LlamaParse, you can add a simple prompt to output all highlighted text with html tags. This is reflected in both the raw markdown and the preview. It helps you capture what the human annotator cared about, which is helpful for automating downstream extraction, or as additional context for LLMs/agents. You can get these results directly through our agentic mode. Just append “output highlighted text with special html tags” and you’re all set. Sign up: https://t.co/QwzurFBE67

I made an AI agent that can fill out complicated forms from unstructured context 📝 For instance: automatically fill out your expense report 💳 by drag and dropping 5-10 receipt pictures/scans 🧾 Uses Claude Agent SDK + LlamaParse to parse unstructured docs + custom tools for form understanding. It now semantically understands each field, handles multi-turn conversations, and lets you drag up to 10 files. Deployed on Vercel/Render. App: https://t.co/HYipU2fpFE Repo: https://t.co/GIfSzxGH4j LlamaCloud: https://t.co/QwzurFBE67

+1 more

Chinese scientists have developed, The best shortest-path algorithm in 41 years! A team from Tsinghua University has broken Dijkstra's "sorting barrier" - the first improvement since 1984. Just use for a world-map 🤯 Paper - https://t.co/0AhR5O7vl4 https://t.co/a9KMVRuYGx

This is not sped up. So folks. conclusion still stands. Robots are coming for all jobs, even the ”safe” ones. It’s just a matter of time. it’s when, not if. https://t.co/pyPRTrY0dG

DeepMind just did the unthinkable. They built an AI that doesn't need RAG and it has perfect memory of everything it's ever read. It's called Recursive Language Models, and it might mark the death of traditional context windows forever. Here's how it works (and why it matters way more than it sounds) ↓

The paper built a theorem prover that keeps trying LLM ideas until Isabelle finally accepts a full proof. Isabelle checks formal proofs with strict rules, so its automation often gets stuck when goals need many careful steps. Instead of writing proofs by hand, the prover searches for a script, using an LLM as a guide. Their main trick is a loop where an LLM, suggests the next proof command and Isabelle checks it. To guide those suggestions, the system retrieves a small set of relevant earlier lemmas, meaning previously proved facts, and learns which commands to try first. For longer proofs, a planner asks the LLM for an Isar outline, meaning a readable proof skeleton, then fills gaps by calling the stepwise search again. They run it on consumer laptops and test Isabelle goals where Sledgehammer fails, and the stepwise loop proves some, while the fill and repair part usually stalls. The takeaway is that Isabelle's yes or no feedback can keep the LLM honest, and LLM written code still struggles with the toughest planner pieces. ---- Paper Link – arxiv. org/abs/2601.04653 Paper Title: "Vibe Coding an LLM-powered Theorem Prover"

Disclaimer: I had given early access to internal beta version of Grok 4.20 It found a new Bellman function for one of the problems I’d been working on with my student N. Alpay. The problem reduces to identifying the pointwise maximal function U(p,q) under two constraints and understanding the behavior of U(p,0). In our paper https://t.co/pgJw9MaEA1 we proved U(p,0)\geq I(p), where I(p) is the Gaussian isoperimetric profile, I(p) ~ p\sqrt{log(1/p)} as p ~ 0. After ~5 minutes, Grok 4.20 produced an explicit formula U(p,q) = E \sqrt{q^2+\tau}, where \tau is the exit time of Brownian motion from (0,1) starting at p. This yields U(p,0)=E\sqrt{\tau} ~ p log(1/p) at p ~ 0, a square root improvement in the logarithmic factor. Any significance of this result? It will not tell you how to change the world tomorrow. Rather, it gives a small step toward understanding what is going on with averages of stochastic analogs of derivatives (quadratic variation) of Boolean functions: how small can they be?  More precisely, this gives a sharp lower bound on the L1 norm of the dyadic square function applied to indicator functions 1_A of sets A \subset [0,1]. In my previous tweet about Takagi function, we saw that the sharp lower bound on ||S_1(1_A)||_1 miraculously coincides with Takagi function of |A| which (surprisingly to me) is related to the Riemann hypothesis. Here, we obtain a sharp lower bound on ||S_2(1_A)||_1 given by E \sqrt{\tau}, where Brownian motion starts at |A|. This function belongs to the family of isoperimetric-type profiles, but unlike the fractal Takagi function, it is smooth and does not coincide with the Gaussian isoperimetric profile. Finally, in harmonic analysis it is known that the square function is not bounded in L^1. The question here was more about curiosity: how exactly does it blow up when tested on Boolean functions 1_A.  Previously, the best known lower bound was |A|(1-|A|) (Burkholder—Davis—Gandy). In our paper, we obtained |A| (1-|A|)\sqrt{log(1/(|A|(1-|A|)))}. This new Grok’s Bellman function gives |A| (1-|A|) \log(1/(|A|(1-|A|))) and this bound is actually sharp.

🚀🚀🚀We are excited to open-source Tencent-HY-MT1.5, featuring two translation models—1.8B and 7B—designed for seamless on-device and cloud deployment with industry-leading speed and accuracy. Highlights: 🔹 1.8B On-Device Power: Optimized for consumer hardware with a 1GB memory footprint. Using on-policy distillation to align with larger models, it delivers 0.18s latency (50 tokens), outperforming mainstream commercial APIs. 🔹 7B SOTA Performance: An upgraded version of our WMT25 champion, surpassing mid-sized open-source models and rivaling the 90th percentile of closed-source giants like Gemini-3.0-Pro. 🔹 33+ Languages & Dialects: High-fidelity translation across 33 languages and 5 Chinese dialects. 🔹 Production-Ready: Native support for custom terminology, long-dialogue context, and maintaining document formatting. Already powering multiple Tencent services, our dual-model synergy ensures consistent and stable performance across both on-device and cloud environments. 🌍 👉🏻 Try it now: https://t.co/MOGj8Uwzwu 🔗 GitHub: https://t.co/a65YZGBj7B 🤗 Hugging Face: https://t.co/EJJQM4x7EZ

+3 more

LLM memory is considered one of the hardest problems in AI. All we have today are endless hacks and workarounds. But the root solution has always been right in front of us. Next-token prediction is already an effective compressor. We don’t need a radical new architecture. The missing piece is to continue training the model at test-time, using context as training data. Our full release of End-to-End Test-Time Training (TTT-E2E) with @NVIDIAAI, @AsteraInstitute, and @StanfordAILab is now available. Blog: https://t.co/woCpiIrq0T Arxiv: https://t.co/3VkFlS3wx3 This has been over a year in the making with @arnuvtandon and an incredible team.

Introducing SeedFold from ByteDance Seed, a biomolecular structure prediction model that outperforms AlphaFold3 on protein-related folding tasks. https://t.co/4a93w6VLJL

Try it here ➡️ https://t.co/0oLFfTNXyY

As AI workloads are getting more complex, the AI stack needs to evolve. In our latest video, Modular CEO and Co-Founder @clattner_llvm shares why Modular is rethinking AI infrastructure from first principles and how our MAX Framework unifies performance, portability, and modeling. Watch here: https://t.co/pxHLhydcZh

Also made a more introspective blogpost for those interested https://t.co/uIvfSV7DCg

Beautiful Rust CLI for browser automation by @ctatedev. Agents love CLIs so I expect this to gel really well with Claude Code, Codex & OpenCode for OS ai automation. https://t.co/9q8zMNO6BO https://t.co/be0NuOQVgS

It's the New Years 🥳! But are you still stuck in your old workflows? Where you prompt, your agent doesn't understand, you cry (of frustration maybe), and then you prompt again. Well not anymore. This new year, we'll make sure you ship code that actually works. Let us introduce ourselves.

keep getting these on LI they make no sense to me, feels scammy https://t.co/3woDoSSouW

SEO in 2026 is just a checklist: - Canonical URLs - JSON-LD schemas (Website, Organization, BreadcrumbList) - hreflang tags - DNS prefetch for third-party domains - RSS feed - Proper OG images The magic isn't in knowing the list—it's in actually doing every item. Just did a big SEO cleanup for https://t.co/I0kEbEpSX3

Founder Coach Claude Code Skill Bookmark this one 👇🏼 https://t.co/UUS5uSbvwG

@Suhail use https://t.co/fAQKjTpL20