AI Daily · 2026-08-26

IBM's open-source Granite 4.2 reasoning family is today's standout: 3B, 8B, and 30B dense models under Apache 2.0 with 512K context, thinking/non-thinking modes, and native tool calling, trained through 15T-token pretraining, reasoning and agent-trajectory SFT, plus multi-stage RL. On the research side, quantization-aware healing produced a 4-bit compressed model that beats its full-precision original on most benchmarks, while EleutherAI's AI lie-detection retrospective found black-box judge models effective at catching larger models' deception and white-box methods highly scenario-dependent. LangChain/LangSmith shipped a dense wave of updates spanning retrieval abstractions, structured tools, plan-and-execute agents, Deep Agents debugging, rubric-based self-correction, and Engine issue detection. Elsewhere, Google showed AgentHands for XR hand gestures, and EVE Online began its migration from Stackless Python 2.7 to Python 3.

North America · First-hand

Google

⭐⭐ [Research] AgentHands: Generating interactive hand gestures for spatially grounded agent conversations in XR

Google Research introduces AgentHands, an LLM-powered XR research prototype published at CHI 2026, which generates synchronized, expressive hand gestures for conversational AI agents to deliver spatially grounded guidance in physical environments. The system is based on a multi-dimensional taxonomy defining legible virtual hands, covering handedness, gesture, spatiality, temporal dynamics, interactivity, and visual effects. Its workflow includes environment awareness, where eye gaze and scene reconstruction register real objects into a 3D spatial registry, and a hand gesture event library spanning deictic, iconic, and expressive categories. AgentHands aims to make AI assistant conversations in XR more natural and engaging by mapping LLM reasoning into real-time physical motions.

Ecosystem & Beyond (Products / Agents / Tools / Opinions)

Model Release

⭐⭐⭐ [Model Release] Granite 4.2 LLMs: How They're Built

IBM introduced the Granite 4.2 family of dense, decoder-only reasoning LLMs in 3B, 8B, and 30B sizes, all released under Apache 2.0. The models are pretrained from scratch on about 15T tokens with a five-phase recipe that extends context to 512K tokens, then supervised fine-tuned on chain-of-thought, reasoning, and agentic-trajectory data, and post-trained with a multi-stage RL pipeline. The 8B and 30B variants also undergo agentic RL inside sandboxed environments, learning tool use, code execution, terminal work, and web search. Every model offers a thinking/non-thinking switch, a low-effort thinking mode, and native tool calling exposed through OpenAI-compatible endpoints such as vLLM. The post provides architecture details and a pre-training overview.

Product Update

⭐⭐ [Product Update] Using LangSmith to Support Fine-tuning

The LangChain team published a guide on using LangSmith to support LLM fine-tuning, covering dataset management and evaluation, with workflows for fine-tuning open-source models on Colab via HuggingFace as well as OpenAI's fine-tuning service. As a test case, they fine-tuned LLaMA2-7b-chat and gpt-3.5-turbo on a knowledge-graph triple extraction task using training data exported from LangSmith, then evaluated the results in LangSmith. The post advises that fine-tuning suits well-defined tasks with ample examples rather than injecting new knowledge, noting that fine-tuning is 'for form, not facts' and can increase hallucination; it identifies dataset collection/cleaning and evaluation as the biggest pain points that LangSmith helps address.

⭐⭐ [Product Update] Timescale Vector x LangChain: Making PostgreSQL A Better Vector Database for AI Applications

Timescale Vector announced its integration with LangChain, enabling developers to use PostgreSQL as a vector database for AI applications. The integration introduces a new search index inspired by DiskANN, achieving 243% faster search speed than Weaviate at about 99% recall on a dataset of one million OpenAI embeddings, and outperforming existing PostgreSQL search indexes by 39.39% to 1,590.33%; enabling product quantization yields a 10x index space savings compared to pgvector. It also offers time-based similarity search, leveraging Timescale's automatic time partitioning and indexing of hypertables to filter vector search by time range or document age for RAG with time-based context retrieval. By combining vector embeddings, relational data, and time-series data in one PostgreSQL database, the integration simplifies the AI infrastructure stack, and lets users store and filter metadata with PostgreSQL data types and JOIN vector search results with relational data. Rich multi-attribute filtering is planned for future releases, and a free 90-day trial is offered.

⭐⭐ [Product Update] Making Data Ingestion Production Ready: a LangChain-Powered Airbyte Destination

The LangChain team announced a deeper integration with Airbyte by adding a LangChain destination within Airbyte. The goal is to help teams move retrieval-based applications from prototype to production, especially the ingestion pipeline requiring reliable scheduling and transformation. Airbyte provides hundreds of sources, orchestration, and scheduled re-indexing, while LangChain contributes transformation logic such as 15+ text splitters and 50+ embedding integrations. The previous integration used Airbyte sources as LangChain document loaders; this one works in the opposite direction, making LangChain a destination inside Airbyte. The post also frames data ingestion as a key bottleneck alongside query debugging and retrieval UX.

⭐⭐ [Product Update] LangServe Playground and Configurability

LangChain announced new playground and configurability features for its deployment tool LangServe. The playground provides a simple UI for chains and agents, supporting streaming outputs, logs of intermediate steps, and adjustable parameters, with shareable links for collaboration. Configurability is powered by new syntax in LangChain Expression Language, allowing any component to be made configurable and configurations to be saved and shared via URLs. Using WebLangChain as an example, the post shows how different LLMs, prompts, and retrievers can be exposed as configuration options. Configurations are not currently persisted, though LangChain is alpha testing a deployment platform that would support persistence.

⭐⭐ [Product Update] Retrieval

LangChain announced a change to its retrieval abstractions, introducing a Retriever concept whose only requirement is exposing a get_relevant_documents(query) -> List[Document] method. The goal is to make it easier to use retrievers built outside LangChain, such as OpenAI's ChatGPT Retrieval Plugin, and to encourage experimentation with alternative retrieval methods like hybrid search. Existing vector-database-based chains were migrated to Retriever-based chains: VectorDBQA became RetrievalQA, ChatVectorDBChain became ConversationalRetrievalChain, and so on. The change is backward compatible, but LangChain recommends migrating to the new retrieval chains as soon as possible.

⭐⭐ [Product Update] Introducing Pytest and Vitest integrations for LangSmith Evaluations

LangSmith announced beta integrations with Pytest and Vitest/Jest for running LLM evaluations, available in v0.3.0 of the LangSmith Python and TypeScript SDKs. These integrations combine the familiar testing framework DX with LangSmith observability, enabling debugging via saved inputs/outputs and stack traces, logging metrics beyond pass/fail, tracking progress over time, and sharing results with the team. The post highlights built-in evaluation functions such as expect.edit_distance and includes code examples using the @pytest.mark.langsmith decorator, including an example evaluating a SQL-generating application.

⭐⭐ [Product Update] Cube x LangChain: Building AI experiences with LLMs and the semantic layer

Cube announced an integration with LangChain in the form of the CubeSemanticLoader document loader, which loads a Cube semantic layer's data model into embeddings stored in a FAISS vector store. This allows free-form natural language input to be matched against views and members in the data model, helping reduce hallucination in text-to-SQL applications. The release includes a Streamlit chat demo app (source on GitHub) and example OpenAI prompts for querying Cube's SQL API. The post shows code snippets for ingesting metadata, setting up the OpenAI model, and querying the vector store.

⭐⭐ [Product Update] Role Based Access Control (RBAC) for LangSmith

LangChain announced new access control features for LangSmith, including Role Based Access Control (RBAC). Enterprise users can assign Admin, Viewer, and Editor system roles within a workspace or organization, and create custom roles for granular permissions. The API key system now supports Personal Access Tokens tied to individual users and Service Keys acting as service principals with admin privileges. Old ls__ API keys have been migrated to service keys and will no longer be supported after July 1, 2024.

⭐⭐ [Product Update] Automating Web Research

The LangChain team initially set out to build an autonomous web research agent, but found the iterative search process was slow. They then leveraged the AI advantage of running many searches and page reads in parallel, and simplified the approach into an efficient retriever. The retriever uses an LLM to generate multiple search queries, executes searches in parallel, picks top K links per query, scrapes pages in parallel, indexes them into a vectorstore, and retrieves the most relevant chunks. They released a new LangChain retriever with documentation, example code, and a Streamlit app, configurable to run in private mode.

⭐⭐ [Product Update] Plan-and-Execute Agents

LangChain introduced a new type of agent executor called 「Plan-and-Execute」, in contrast to the ReAct-based 「Action」 agents it previously supported. The approach separates high-level planning from short-term execution: a language model acts as the planner to define steps, and an Action Agent serves as the executor to carry them out. The team says this design suits more complex long-term planning and improves reliability by decoupling planning from execution, while also making it easier to swap in smaller fine-tuned models later; the main downside is significantly more LLM calls. The initial implementation is in the experimental module, with Python and JS/TS documentation.

⭐⭐ [Product Update] Workspaces in LangSmith for improved collaboration and organization

LangSmith introduces Workspaces, a logical grouping of users and resources within an organization to improve collaboration and security for enterprises and startups. Resources such as trace projects, datasets, annotation queues, and prompts are now scoped to a single workspace instead of being shared across workspaces. User management moves to the organization level with roles like Organization Admin and Organization User, and works with RBAC for granular permissions. Enterprise plan users can create up to 10 workspaces and request a higher limit; billing seat counting and API key scoping remain unchanged.

⭐⭐ [Product Update] LLMs and SQL

The LangChain team, along with community members Francisco Ingham and Jon Luo, wrote this blog post about making LLMs generate SQL queries more reliably. It identifies key challenges including hallucination (LLMs inventing non-existent tables or fields), context window limitations, and handling incorrect SQL output. Proposed solutions include describing the database schema and sample rows in the prompt, limiting exploratory queries to top K rows or summary statistics, and having the LLM learn from errors and rewrite queries. The post also mentions LangChain's SQL chains and SQL agents, and announces a webinar on March 22.

⭐⭐ [Product Update] Multi-modal RAG on slide decks

LangChain published a multi-modal RAG tutorial with a template and a public benchmark for slide decks. It compares two approaches: embedding slide images directly with multi-modal embeddings, or using GPT-4V to summarize each slide and then retrieving the original images via a multi-vector retriever based on similarity to the user question. Both approaches pass retrieved images to GPT-4V for answer synthesis. Evaluating on a Datadog earnings deck with 10 questions, text-only RAG scored 20%, multi-modal embeddings 60%, and the multi-vector retriever with image summaries 90%. The post concludes that multi-modal methods far outperform text-only RAG, while the image-summary design adds complexity and cost, and it provides the template, evaluation notebooks, and a LangSmith comparison page.

⭐⭐ [Product Update] Debugging Deep Agents with LangSmith

LangChain announces new LangSmith capabilities for debugging deep agents. The blog explains that deep agents are harder to debug due to very long prompts, long traces spanning dozens or hundreds of steps, and multi-turn human-in-the-loop conversations. LangSmith tracing uses runs, traces, and threads to structure execution data. Two new tools are introduced: Polly, an in-app AI assistant that lets you analyze traces and threads via chat, and langsmith-fetch, a CLI that gives coding agents like Claude Code debugging abilities.

⭐⭐ [Product Update] Structured Tools

LangChain announced a new 'structured tools' abstraction along with a new agent class. While previous tools took only a single string input, the new tools can accept an arbitrary number of inputs of arbitrary types, enabling more complex interactions between models and tools. A structured tool is defined by a name, a description, an args_schema (a Pydantic-based validation model), and the _run/_arun implementations. The post also reviews the evolution from ReAct chains to multi-action agents and explains how tool naming, descriptions, and argument schemas help agents select and validate inputs.

⭐⭐ [Product Update] Multi-Vector Retriever for RAG on tables, text, and images

LangChain's blog releases three new cookbooks demonstrating RAG on documents that mix tables, text, and images using the multi-vector retriever. The core idea is to decouple documents used for answer synthesis from references used for retrieval: embed summaries of verbose content for similarity search, but pass the full document (or table/image) to the LLM to avoid losing context. The post uses Unstructured to partition PDFs into tables, images, and text blocks, and generates summaries of tables to make them retrievable via natural language. The cookbooks cover semi-structured (tables + text), multimodal (text + tables + images), and private multimodal RAG, and also suggest ways to pair multimodal LLMs with the retriever for image RAG.

⭐⭐ [Product Update] Introducing Rubrics: Build Agents that Evaluate and Correct Their Work

LangChain introduces RubricMiddleware for Deep Agents, enabling agents to self-evaluate and iteratively refine their work until they meet a defined rubric. A dedicated grader sub-agent evaluates the run against the rubric, can call tools and reason over the full transcript, and returns per-criterion feedback that is fed back into the conversation for another attempt until success or an iteration cap is reached. The post provides complete code examples for defining the middleware and passing a rubric at invoke time, noting the approach is most effective for tasks with clear, verifiable success criteria like passing test suites, avoiding forbidden patterns, or covering required report sections.

⭐⭐ [Product Update] LangSmith Engine Improves Agent Issue Detection by 2x

LangChain announced updates to LangSmith Engine, saying it now performs more than 2x better at identifying agent issues on internal benchmarks and 25% better at writing fixes on public benchmarks like Terminal-Bench. Engine is an in-platform deep agent that analyzes production traces, flags issues, proposes fix PRs, and monitors for regressions. New capabilities include self-hosted deployment, Slack alerts, and Linear integration, plus a reduced Analysis mode for cost flexibility. Since launching in May, Engine has scanned over 60 million traces and found more than 20,000 issues, saving tens of thousands of engineering hours.

⭐⭐ [Product Update] Using skills with Deep Agents

Anthropic introduced the concept of agent skills: folders containing a SKILL.md file and related files that agents can dynamically discover and load to perform better at specific tasks. LangChain has added skills support to its open-source deepagents-CLI. The post notes that generalist agents such as Claude Code and Manus tend to use very few tools, with the key insight being to give agents filesystem and shell access rather than bound tools for every task. Compared with traditional tools, skills offer token efficiency via progressive disclosure (only YAML frontmatter loads by default) and lower cognitive load. With deepagents-CLI, users can copy example skills into a skills folder, list them with deepagents skills list, and the agent automatically reads and executes the relevant SKILL.md when a request touches a skill.

⭐⭐ [Product Update] Building Self-Correcting Memory in OpenWiki

OpenWiki implements a self-correcting memory system to address the problem of long-term memories going stale as the source of truth changes. When the agent writes a wiki page, it must also record the page's factual claims along with the code evidence supporting them, located by file path and line ranges. The runtime stores a version for each piece of evidence; if the current source version differs from the one that backed a claim, the claim is flagged as stale. Stale claims are then re-verified against the current code — still-true claims get a refreshed evidence version, while false claims trigger updates to both the wiki content and its evidence. This creates a self-correcting feedback loop rather than regenerating the wiki from scratch, and the claims are also tied to OKF v0.2.

Research

⭐⭐ [Research] What We Learned Trying to Catch AI Liars: An Aletheia's Quest Retrospective

EleutherAI reflects on their participation in Aletheia's Quest, an AI lie-detection competition organized by Cadenza Labs and NDIF with funding from Schmidt Sciences, involving 19 teams. They tested hundreds of detector variants using black-box and white-box methods across models ranging from 27B to 120B parameters. Key takeaways: black-box monitoring performed much better than expected, a small trusted judge model worked well against most deception from larger models, and white-box performance was highly situational. They released a companion repository containing their best methods and a curated battery of deception datasets called the gauntlet. The team held first place for most of the competition but was narrowly edged out by SAIN Groningen near the end, with final placements pending unreleased test data.

⭐⭐ [Research] Quantization-Aware Healing: a compressed, 4-bit model that outperforms its full-precision original

This research introduces Quantization-Aware Healing (QAH), which distills directly from the pre-compression full-precision model into the quantized student instead of from the recovered bfloat16 checkpoint, removing the accuracy ceiling. Applying QAH to a GPT-OSS 120B model compressed to 60B and quantized to MXFP4 yields a model that beats its full-precision (bfloat16) original on 7 of 9 benchmarks, while being smaller and cheaper to run. The authors explain that standard quantization-aware training (QAT) and quantization-aware distillation (QAD) fall short after structural compression, since no independently trained full-precision version of the smaller architecture exists and distilling from the recovered checkpoint anchors the student to a degraded target.

⭐⭐ [Research] Benchmarking Question/Answering Over CSV Data

LangChain published a deep-dive blog on natural-language Q&A over tabular/CSV data. They launched a simple Streamlit app to collect real user questions, used LangSmith to log feedback and flag interesting datapoints, and built a dataset of questions with ground-truth answers. They used LLM-assisted evaluation to compare solutions, debugged shortcomings in the initial approach, and arrived at an improved custom agent based on OpenAI functions with two tools: a Python REPL and a retriever. The feedback app, dataset, and evaluation scripts are open-sourced, with a companion video.

Opinion

⭐⭐ [Opinion] The rise of "context engineering"

LangChain founder Harrison Chase introduces 'context engineering,' defined as building dynamic systems that supply LLMs with the right information and tools in the right format so they can plausibly complete a task. He argues that most agent failures stem not from model capability but from missing or poorly formatted context, or a lack of appropriate tools. Since context comes from multiple dynamic sources, prompt construction logic must also be dynamic. The article contrasts this with prompt engineering, emphasizing that providing complete, well-structured context matters more than clever phrasing, and offers a diagnostic question to separate context problems from genuine model mistakes.

⭐⭐ [Opinion] Agentic Engineering: How Swarms of AI Agents Are Redefining Software Engineering

This article introduces agentic engineering: a multi-agent coordination model in which AI agents act as digital team members with defined roles, shared memory, and unified observability to drive software through the entire delivery pipeline. Unlike coding agents such as Codex or Claude, agentic engineering operates as a higher-level control plane that orchestrates cross-team workflows and maintains long-term memory and state; the two are complementary, with coding agents serving as reasoning and code-generation engines inside worker agents. In a pilot of 20+ debugging workflows, coordinated agent execution cut time-to-root-cause by 93% versus historical baselines and saved over 200 engineering hours across 512 sessions in a month, while development workflows saw a 65% reduction in execution time, mainly from compressing downstream testing rather than code generation. The system is built with LangChain's tooling (LangSmith and LangGraph), reflecting the core insight that the biggest gains come from systems that mirror real-world teams rather than better single-point coding tools.

Other

⭐⭐ [Other]

This LangChain blog post is a cookbook for building an automated company due diligence agent using Deep Agents and Parallel's Task API. The agent orchestrates five research tracks—corporate profile, financial health, litigation/regulatory, news/reputation, and competitive landscape—each handled by a dedicated subagent. After the competitive-landscape track identifies top competitors, the orchestrator fans out to parallel competitor-analysis subagents, then cross-references workpapers, resolves low-confidence findings, and writes a final report with risk flags and citation trails. Parallel returns structured findings with per-field citations, reasoning traces, and Basis confidence scores, and supports interactive follow-up queries. The post includes implementation code and reports end-to-end validation on Rivian Automotive: nine calls in about 23 minutes.

⭐⭐ [Other] How LangSmith and LangChain OSS Help You Meet EU AI Act Requirements

The EU AI Act sets compliance requirements for high-risk AI systems (e.g., financial services, healthcare, HR), with a deadline of August 2, 2026 and penalties up to €15M or 3% of global annual turnover. The post maps specific Act articles (risk management, automatic event logging, traceable decisions, data governance and bias review) to LangSmith and LangChain OSS capabilities. LangSmith offers end-to-end tracing, execution-graph visualization in LangSmith Studio, and Insights Agent for automatically clustering failure modes from trace data, plus custom dashboards and alerts. It provides 14-day base and 400-day extended trace retention, self-hosted/BYOC deployment, and EU data residency. The post also covers continuous quality and safety evaluation on production traffic.

⭐⭐ [Other] How Lyft Built a Self-Serve AI Agent Platform with LangGraph and LangSmith

Lyft built a multi-agent customer support system using LangGraph that handles millions of interactions for riders and drivers. The system follows a router-based multi-agent architecture where a stateful meta-agent dispatches requests to specialized subagents, each implemented as a full LangGraph StateGraph. By letting ops teams, VoC leads, and product managers define and iterate agents through natural language and configuration, Lyft cut the need for MLE involvement and shortened agent development from roughly six months to a few weeks. For production quality, the team relies on LangSmith for tracing, dashboards, and LLM-as-a-judge evaluation, and found that structured prompt writing became a major factor in agent reliability.

⭐⭐ [Other] How We Build Agent Environments & Tasks

LangChain engineers describe their process for building synthetic agent environments and tasks. The approach is a two-step pipeline: first, traces, code, or human input are turned into a detailed task spec (a natural-language description of input, environment, and test script); second, that spec is converted into an eval task and a corresponding environment. They introduce a "world spec" to hold shared project knowledge, scripts, and helper functions. They note the process is highly iterative and have packaged it into an updated eval-engineering skill so teams can adopt the workflow themselves.

⭐⭐ [Other] EVE Online: The Move to Python 3 Begins!

EVE Online has announced the start of its migration from Stackless Python 2.7 to Python 3. The game has run on Stackless Python since its 2003 launch, with the last major upgrade being Python 2.7 in 2010. The migration will begin by running the futurize script across roughly 2.4 million lines of code, followed by manual review of about 20,000 places where Python 2 and 3 behavior differ, such as integer division returning a float in Python 3. The announcement does not explain how Stackless will be replaced, but last year's conference talk described replacing Stackless in the Carbon engine for EVE Frontier using the now open-source carbonengine/scheduler library.