New research from Meta and collaborators. This is a good paper showing what's possible with proper world models. World models need actions to predict consequences. The default approach today requires labeled action data, which is expensive to obtain and limited to narrow domains like video games or robotic manipulation. But the vast majority of video data online has no action labels at all. This new research tackles learning latent action world models directly from in-the-wild videos, expanding beyond the controlled settings of previous work to capture the full diversity of real-world actions. The challenge is significant. In-the-wild videos contain actions far beyond simple navigation or manipulation: people entering frames, objects appearing and disappearing, dancers moving, fingers forming guitar chords. There's also no consistent embodiment across videos, unlike robotics datasets, where the same arm appears throughout. So how do the authors address this? Continuous but constrained latent actions, using sparse or noisy regularization, effectively capture this action complexity. Discrete quantization, the common approach in prior work, struggles to adapt. Without a shared embodiment, the model learns spatially-localized, camera-relative transformations. The results demonstrate genuine action transfer. Motion from a walking person can be applied to a flying ball. Actions like "someone entering the frame" transfer across completely different videos. By training a small controller to map known actions to latent ones, the world model trained purely on natural videos can solve robotic manipulation and navigation tasks with performance close to models trained on domain-specific, action-labeled data. Latent action spaces learned from unlabeled internet videos can serve as a universal interface for planning, removing the bottleneck of action annotation. Paper: https://t.co/BL6mpuLZGD Learn to build effective AI agents in our academy: https://t.co/JBU5beHQNs

On building more powerful self-evolving agents. LLM agents struggle to learn from experience after deployment. Fine-tuning is expensive and causes catastrophic forgetting. RAG retrieves based on semantic similarity alone, often pulling noise instead of what actually works. Similarity and utility are not the same thing. This new research introduces MemRL, a framework that enables agents to self-evolve through non-parametric reinforcement learning on episodic memory, keeping the LLM completely frozen. The core idea is to treat memory retrieval as a decision-making problem, not a matching problem. Each memory stores an Intent-Experience-Utility triplet. The utility is a learned Q-value representing expected returns, continuously refined through environmental feedback. MemRL implements Two-Phase Retrieval. First, filter candidates by semantic similarity to ensure relevance. Then, rank by learned Q-values to select what actually works. This distinguishes high-value strategies from semantically similar noise. When the agent succeeds or fails, it updates the Q-values of retrieved memories using Bellman-style backups. No gradient updates to model weights. The frozen LLM provides stable reasoning while the memory evolves plastically. Results across four benchmarks: On HLE (knowledge frontier tasks), MemRL significantly outperforms both RAG and existing memory systems like MemP. The pattern holds on BigCodeBench for code generation, ALFWorld for exploration tasks, and Lifelong Agent Bench for OS and database operations. Analysis confirms a strong correlation between learned utility scores and actual task success, validating that Q-values capture genuine functional value rather than superficial similarity. Why does it matter? Decoupling stable reasoning from plastic memory enables continuous runtime improvement without the catastrophic forgetting or computational costs of fine-tuning. Paper: https://t.co/HvLUnXW2Jd Learn to build effective AI agents in our academy: https://t.co/zQXQt0PMbG

I applaud Anthropic for relentlessly making Claude Code easier to use. You can now leverage modes within Code in Claude Desktop. Ask, Plan, and Execute are some of the most important components to make an agent work. And they are now available at the press of a button. https://t.co/SV5MGSYJeY

Super interesting paper from Meta Superintelligence Labs. This work suggests complex reasoning and search capabilities can emerge solely through self-evolution, challenging the assumption that human supervision is necessary for advanced agent abilities. Let's break down the paper: Self-evolving LLMs can improve without human-curated data by generating their own training problems. However, existing data-free frameworks focus on narrow domains like math and coding. They struggle with open-domain search agents due to limited question diversity and the massive compute required for multi-step reasoning with tools. But what if search agents could evolve from scratch using only an external search engine? This new research introduces Dr. Zero (DeepResearch-Zero), a framework enabling search agents to self-evolve without any training data, demonstrations, or human annotations. The core design: a proposer-solver feedback loop where both models initialize from the same base LLM. The proposer generates diverse questions to train the solver. As the solver improves, it pushes the proposer to create harder yet still solvable queries, establishing an automated curriculum. Standard GRPO requires nested sampling, generating multiple queries each with multiple responses. This becomes computationally prohibitive for multi-turn search agents. Dr. Zero introduces Hop-Grouped Relative Policy Optimization (HRPO), which clusters structurally similar questions by their cross-hop complexity to construct group-level baselines. This eliminates nested sampling while maintaining stable training. The proposer reward balances verifiability and difficulty. If the solver gets everything right, the question is too easy. If it fails completely, too hard. The sweet spot maximizes the learning signal. Results: The data-free Dr. Zero matches or surpasses fully supervised search agents by up to 14.1% on complex QA benchmarks, including HotpotQA, 2WikiMQA, and MuSiQue. On Qwen2.5-7B, Dr. Zero achieves 0.372 average score compared to 0.347 for supervised Search-R1. Paper: https://t.co/CjkbRQNQIl Learn to build effective AI agents in our academy: https://t.co/zQXQt0PMbG

UniversalRAG RAG systems retrieve knowledge to ground model responses. However, most existing approaches are limited to a single modality, typically text. For many real-world RAG systems, some queries need images. Others need videos. Many need combinations. This new research introduces UniversalRAG, a framework that retrieves and integrates knowledge from heterogeneous sources across diverse modalities and granularities. Real-world queries vary widely in what knowledge they need. A universal RAG framework that dynamically routes to the right modality and granularity serves diverse information needs that no single-corpus approach can address. Instead of forcing everything into one embedding space, UniversalRAG uses modality-aware routing. A router dynamically predicts which modality-specific corpus best matches the query, then performs targeted retrieval within it. This sidesteps the modality gap entirely by avoiding cross-modal comparisons. Beyond modality, the framework also handles granularity. Complex analytical questions may need full documents or complete videos. Simple factoid questions are better served with paragraphs or short clips. UniversalRAG organizes each modality into multiple granularity levels: paragraphs and documents for text, clips and full videos for video, plus tables and images. The router can be trained or training-free. The trained version uses inductive biases from existing benchmarks. The training-free version prompts frontier models like Gemini to predict the best modality-granularity pairs directly. Validation across 10 benchmarks spanning text, images, tables, and videos shows UniversalRAG outperforms both unimodal RAG baselines and unified embedding approaches by large margins on average. Paper: https://t.co/OAfR65bEm2 Learn to build effective Agentic RAG systems in our academy: https://t.co/JBU5beIoD0

This is great insight from Cursor on long-running agents. It turns out planning is all you need. On a serious note, planning is critical to be productive and effective with AI Agents. It's aligned with how I get Claude Code to effectively work on long-running tasks. (More of my thoughts on Claude Code towards the end of the post) First, let's discuss the insights from the Cursor article. The big problem with multi-agent systems today is the coordination/communication. The solution Cursor proposes is careful planning. I agree that the best way to deal with this challenge today is to do careful planning. Planners can explore the codebase and create these tasks. Then, subplanners are spawned to address specific categories of tasks. The great thing about this is that it enables parallelization and recursive loops, ideal for this kind of work. From here, subagents can focus on assigned subtasks once they are completed (and push changes). One important aspect of this work is that subagents don't coordinate at all and are oblivious to the bigger picture. But they don't need to be to produce high-quality code that doesn't conflict. The issue with having subagents talk to each other is that this can lead to communication bottlenecks, duplicate work, and potential drift. This can operate in cycles, which are all verified using a judge agent. The judge agent determines if work can continue or if there is an issue to address on every cycle. Cursor managed to build a web browser from scratch with this approach. The agent ran for a week, writing over 1M+ lines of code across 1K files. Cursor found that GPT-5.2 is better for this set up. They find that Opus 4.5 tends to stop earlier, take shortcuts, and quickly yield back control. The simpler system worked best. "Too little structure and agents conflict, duplicate work, and drift. Too much structure creates fragility." An interesting finding: designing an effective system prompt to focus over long periods was more important than the harness and models themselves. Why this resonated with me, even though I am not a Cursor user: I have been testing Claude Code on long-running tasks. And what Cursor reports is aligned with my own findings. However, better planning and tuning of the system prompt, including tuning CLAUDE MD, has allowed me to leverage Claude Code more effectively for these long-running tasks. Here are a few notes on planning and how you get something like this to work in Claude Code: You can do effective planning in many different ways. You can create an initial plan and complete it with Claude Code (in plan mode). Or you can brainstorm the plan with Claude Code directly (in plan mode). Claude Code is excellent at managing plans for you in case you don't want lots of moving parts. This, together with subagents works extremely well in Claude Code already. However, you can also get more creative with how planning is done to mimic the subplanners proposed by Cursor. Claude Code is extremely flexible with all its functionalities (Skills, Slash Commands, Subagents, Hooks, etc.). I will share more on this later after I finish with some experiments I am currently working on. When planning, it helps if you are also involved in the process. If you are a Cluade Code user, you can trigger the AskUserQuestion tool to inject inputs that will help with making the plan robust. From here, you can offload individual work to subagents (in parallel if you want). The great part about this is that in Claude Code subagents manage their own context, which keeps the main orchestrator's context clean and only for the high-level stuff. You can customize your subagents with models and tools. The planning is core for the coordination to work. The system prompt helps to maintain stability and better manage context. The subagents are just in charge of executing the work. I will be sharing more on my setup in the coming weeks. I am fascinated by how far we can push agent harnesses for long-horizon tasks. Stay tuned!

The reality is that we should all be trying to build our own ideal agentic coworker. Anthropic's Cowork signals a new wave of agent orchestration tools on the horizon. It's not just about making it easy to use Claude Code. IMO, it's more about building intuitive interfaces to interact, manage, and orchestrate agents to be more productive with AI. There is room for innovation in how human-to-agent (and vice versa) communication happens. And I mean everywhere and every domain you can imagine. With the rise of Skills and plugins, anyone can build powerful experiences with these agents and tools. You don't need to be technical to disrupt and build creative and insanely useful skills (either for work, a personal project, or even a startup). You need to have good taste in the domain you are operating, pay close attention to emerging AI technology, experiment relentlessly, build context, and build with a compounding mindset. Exciting times ahead. It's time to build!

Autonomous Memory Management in LLM Agents LLM agents struggle with long-horizon tasks due to context bloat. As interaction history grows, computational costs explode, latency increases, and reasoning degrades from distraction by irrelevant past errors. The standard approach is append-only: every thought, tool call, and response permanently accumulates. This works for short tasks but guarantees failure for complex exploration. This research introduces Focus, an agent-centric architecture inspired by slime mold (Physarum polycephalum). The biological insight: organisms do not retain perfect records of every movement through a maze. They retain the learned map. Focus gives agents two new primitives: start_focus and complete_focus. The agent autonomously decides when to consolidate learnings into a persistent Knowledge block and actively prunes the raw interaction history. No external timers or heuristics forcing compression. It declares what you are investigating, explores using standard tools, and then consolidates by summarizing what was attempted, what was learned, and the outcome. The system appends this to a persistent Knowledge block and deletes everything between the checkpoint and the current step. This converts monotonically increasing context into a sawtooth pattern: growth during exploration, collapse during consolidation. Evaluation on SWE-bench Lite with Claude Haiku 4.5 shows Focus achieves 22.7% token reduction (14.9M to 11.5M tokens) while maintaining identical accuracy (60% for both baseline and Focus). Individual instances showed savings up to 57%. Aggressive prompting matters. Passive prompting yielded only 6% savings. Explicit instructions to compress every 10-15 tool calls, with system reminders, increased compressions from 2.0 to 6.0 per task. Capable models can autonomously self-regulate their context when given appropriate tools and prompting, opening pathways for cost-aware agentic systems without sacrificing task performance. Paper: https://t.co/bVkeQlrvGJ Learn to build effective AI agents in our academy: https://t.co/zQXQt0PMbG

Ralph Research now has a dashboard to monitor progress. While the ralph-research loop cooks inside of Claude Code, I can now visually track code implementation and experiments. Claude Code hooks are very cool! Now building a control center to orchestrate & scale experiments. https://t.co/qXmxSmfVxN

A huge claim from this paper on the end of reward engineering. Reward engineering remains a persistent bottleneck in multi-agent RL. This paper argues that LLMs enable a fundamental shift: from hand-crafted reward functions to natural language objectives. If language can specify what we want and LLMs can translate that into working rewards, the end of reward engineering may mark the beginning of truly scalable multi-agent coordination. Instead of translating human intent into numbers, a lossy and error-prone process, we can describe it in the same language we use with each other. EUREKA demonstrates GPT-4 can generate reward functions achieving human-level performance from language descriptions alone, It outperforms human-designed rewards on 83% of robotics tasks. CARD enables autonomous reward refinement without human intervention. RLVR (as in DeepSeek-R1) shows that language-based training produces emergent reasoning capabilities. What enables all of this? First, semantic reward specification: language preserves intent that numerical functions lose. "Collaborate efficiently" carries rich meaning about task division, smooth handoffs, and failure recovery that no weighted sum captures. Second, dynamic adaptation: when reward hacking occurs, an LLM can observe trajectories, generate feedback in natural language, and refine rewards automatically. No more weeks of manual debugging. Third, inherent human alignment: language objectives are interpretable. Debugging "minimize delivery time while avoiding collisions" is far easier than debugging opaque weight vectors. A few challenges remain: computational cost of LLM inference, hallucination risks in safety-critical systems, language ambiguity, and scaling to hundreds of agents. Paper: https://t.co/czW7QPVML1 Learn to build effective AI Agents in our academy: https://t.co/Y5kVy5iKiQ

The better the plan, the better your agents perform. Long-horizon agents break not because they can't plan. They break because they plan over entangled contexts. The default approach to LLM agent planning falls into two camps. Step-wise planning (like ReAct) interleaves reasoning and acting but makes short-sighted decisions. One-shot planning generates complete plans upfront but becomes brittle when execution errors occur. But both share the same flaw: a single, growing execution history that mixes information across multiple sub-tasks. This new research introduces Task-Decoupled Planning (TDP), a training-free framework that replaces entangled reasoning with explicit task decoupling. How does it work? A Supervisor decomposes tasks into a directed acyclic graph (DAG) of sub-goals. A Planner and Executor then operate with scoped contexts, reasoning only over the active sub-task. This reminds me of the new blog published by Cursor, which uses a similar tactic where planning is decoupled. When something goes wrong, replanning stays local. Independent decisions remain untouched. Isolating context, decisions, and error correction at the sub-task level prevents local failures from cascading across the entire workflow. On TravelPlanner, TDP achieves the highest hard-constraint micro pass rate (32.5%) under DeepSeek-V3.2. On HotpotQA, it reaches 85.88% delivery accuracy. On ScienceWorld, it matches or exceeds strong baselines across both GPT-4o and DeepSeek models. TDP reduces token consumption by up to 82% compared to Plan-and-Act while improving task outcomes. On HotpotQA, it uses just 1,747 output tokens versus 9,929 for the baseline. Fewer tokens, better results. Sub-task decoupling offers a unified mechanism that works across heterogeneous demands like multi-hop reasoning, interactive environments, and constraint-heavy tool planning. You get all of this without sacrificing performance or efficiency. Paper: https://t.co/0hOsV3wFsZ Learn to build effective AI agents in our academy: https://t.co/JBU5beIoD0

Honored to announce that Yann LeCun @ylecun is joining Prior Labs’ Scientific Advisory Board. https://t.co/lP03QKKa49

Honored to announce that Yann LeCun @ylecun is joining Prior Labs’ Scientific Advisory Board. https://t.co/lP03QKKa49

This by @joshua_saxe is a spot-on and pithy diagnosis of where things stand on AI & cybersecurity. It feels like a calm before the storm. https://t.co/wKmkVXfD6q https://t.co/gU8actUXzb

“These findings provide clear evidence that data collected on MTurk simply cannot be trusted.” Researchers have long argued about whether Amazon Mechanical Turk (MTurk) survey data can be trusted. This paper takes a simple approach to evaluating the quality of data currently produced by MTurk. The author gives respondents pairs of questions that are obviously contradictory. For example: "I talk a lot" and "I rarely talk." Or: "I like order" and "I crave chaos." If people are paying attention, agreeing with one should mean disagreeing with the other. At minimum, the two answers shouldn’t move together. The same exact survey is fielded on three platforms: Prolific, CloudResearch Connect, and MTurk. On Prolific and Connect, things behave normally: most contradictory items are negatively correlated, just as common sense predicts. On MTurk, however, the results are the opposite. Over 96% of these clearly opposite item pairs are positively correlated. In other words, many respondents give similar answers to statements that literally contradict each other. The authors then try what most researchers would do next: -restrict the sample to "high-reputation" MTurk workers -apply standard attention checks -drop fast responders and straight-liners None of it fixes the problem. Even after aggressive screening, many contradictory items remain positively correlated on MTurk. The implication is severe: careless responding on MTurk isn’t rare noise; it’s systematic enough to flip the sign of relationships and generate results that are the opposite of what they really are. Wow; this is damning.

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