elitizon

Co-Founder and CTO of a technology venture studio.

- Crafting AI strategies aligned to business goals
- AI/ML Strategy and Implementation
- AI Engineering
- Ensuring models deliver repeatable value in production
- Advanced Data Engineering

CTO - ELITIZON Ltd

Quantmetry - Part of Capgemini Invent

Data and AI Architect consultant for "The State-of-the-Art AI company"

Data & AI - Architect Consultant

Decathlon 

- Data Strategy roadmap
- Data Governance design
- Data Engineering (AirFlow / Spark / AWS EMR / Databricks / Scala / Python )
- Data and Analytics Operating Model design
- Modern Data Stack Roadmap
- Cloud data architecture (AWS / GCP)
- AI/ML architecture and DataOps
- Data Factory Ingest - Tech Lead

La French Tech Hong Kong - Shenzhen

Helping French-Startups Ecosystem in HK / China, Great Bay Area

Board Member

WaveX

🌊 Using wave energy to produce electricity while reducing carbon emissions and combating erosion on coastlines

Technical Advisor

Air Liquide

2018 - 2020 : Architect, Design, Develop & Operate a Worldwide Analytics Solution on Microsoft Azure to optimise the Industrial Gases Supply Chain  | Azure DataFactory ETL | Azure DWH Synapse | Azure Cubes | DataViz PowerBI 

2008 - 2020:  Architect, Design, Develop and Maintain a mission-critical global solution to manage and optimise industrial Gas deliveries by truck on 3 continents ( America  | Europe  | Asia  ) - South Africa deployment planed in 2020  | Transport Management System

✅ 2 Billions Euros Business / year
✅ 1.5 millions Deliveries by Truck / year
✅ 40 000 Customers served 

🛰 Real Time Visibility of the Supply Chain
📊 Real Time Inventory at the customer site (Internet Of Things)
📈 Consumption Forecasting
🤖 Vendor Management Inventory | Operation Research & Tactical & Operational Optimisation 


2010 - 2012:  Architect, Design, Develop - Internet of Thing Solution for patients monitoring (Sentinel)

✅ > 100K Patients monitored in France

2016 - present: Signed a strategic Digital Transformation Partnership with L’Oréal Group (Fortune 500) to create and develop embedded softwares and artificial intelligence cloud infrastructures for connected beauty devices 

✅ 2 Connected Beauty Solutions presented at CES Las Vegas (2017 & 2020)
✅ New Beauty Digital Business - Color & Co - L'Oréal USA

2013: first AWS powered Cloud Solution deployed within Air Liquide Group. Adoption of a Cloud First strategy for application development

Founder & CEO at CALIATYS | Air Liquide Group

Winwise

⛰   2000 to 2008 : Developed of one of the leading training and expertise center for software development on Microsoft Technology in Paris (Microsoft .NET |  MS Bitzalk )

👏  2001 : Development of one of the first e-Commerce Solution (connected to SAP) - Spare parts for Sidel Tetra Pack

👏   2002 to 2008 : consulting and expertise to build a new generation heath & life insurance information system (Le Gan | Groupama - Lausanne) 

💵  2000 : Received 1.5 M Euros of founding 

👏  2000 : Signed a consulting contract for AXA Bank - Development of a credit/risk management system

🌱  2000 : Signed a partnership with Microsoft France to train Microsoft Consulting Team and Microsoft Partners on Microsoft Biztalk, Web Services and XML technologies

👉 1998 : Signed a partnership with VALTECH to develop a software expertise practice on Microsoft
 
🚀  1998 : Launched an expertise and consulting spinoff of Winwise Group valued 3.8 M Euros after 2 years. 

Winwise Group was the leading pure player software development company specialized in Microsoft Technologies in France from 1995 to 2008. Winwise was acquired by "ALTEN Group" in 2008.

Business Offer

➡ Microsoft Technology Consulting
➡ Custom Software Development
➡ Innovation Consulting
➡ Software architecture consulting / Audit  / Technical Expertise

🎖 Microsoft Gold Partner
🎖 Microsoft Certified Training Center / Prometric Certification Center


✅ 5K Software engineers  trained

✅ Software expertise missions for:

  ☑ Microsoft France
  ☑ ATOS
  ☑  Business Object
  ☑ Schneider Electric
  ☑ Alcatel
  ☑ Dassault Système
  ☑ Le GAN (Insurance)
  ☑ Sidel / Tetra Pack

Founder & CEO BUSINESS DESIGN CONSULTING | Winwise Group

Microsoft Conference Speaker 

Consulting & Expertise Missions for CORIOLIS Telecom | Schneider | Air Liquide | VALTECH | ALCATEL | D'ARVA | Ministère des affaires étrangères | LECTRA SYSTEM | MICROSOFT

🎖 Microsoft Certified Trainer
🎖 Microsoft Certified Solution Developer
🎖 Microsort Certified Database Administrator (SQL Server)

Software architecture consulting on Microsoft Technology stack.  IT Trainer on Microsoft Technologies

Microsoft Technology Consultant

Banque Populaire

Lead developer of a transaction oriented service bus (ESB)  to implement of a service oriented architecture (SOA) | System & Network programming in C++ 

✅ Distributed architecture deployed in 200 Bank Agencies
✅ Backbone of one of the first Web e-Banking solution in France

Software Developer

On a Mission to Democratize Data Management & AI 🚀

As a seasoned data and AI strategist 🧠, I am on a mission to democratize data management and AI. 

👉 I empower organizations to build robust, scalable data platforms that drive transformative business outcomes. 

👉 With over 20 years of global technology leadership experience, I offer strategic guidance and hands-on expertise to help companies fully leverage the power of data and AI.


My consultative approach begins with deeply understanding your unique requirements and goals. I then craft a tailored roadmap to build, optimize, and scale your data infrastructure and capabilities. Whether you’re looking to transition to a data-centric business model, enhance your AI/ML initiatives, or overcome specific data challenges, I provide the specialized skills and insights you need.

👉 My services include:

-  Architecting scalable, resilient data platforms and pipelines
-  Streamlining deployment and management in the cloud
-  Implementing cutting-edge machine learning models
-  Coaching teams on data engineering and AI best practices
-  Devising data strategies aligned to business objectives
-  Overseeing DevOps, CI/CD, and MLOps processes

As a startup founder and advisor, I recruit and lead high-performing engineering teams. My passion is empowering people and organizations to maximize the value of their data. I have contributed to over €2B in revenue through data-driven software products and successfully grown and sold a company for 140x its initial investment.

With deep expertise across data engineering, machine learning, and product development, I am eager to collaborate with clients to create data-centric cultures and power AI innovation. Let's connect to discuss how we can lead the future together.

Currently, I spearhead a startup studio in Hong Kong and offer consulting services to clients around the globe. My expertise has been sought by Fortune 500 companies, and I am passionate about helping businesses unlock the full potential of their data, amplifying its value and impact.

👉 When you're ready to elevate your data strategy, I'm just a click away: 📆 

https://topmate.io/raphael_mansuy 

In the ever-evolving landscape of data engineering, data science, and AI, staying ahead of the curve is crucial. I share daily insights, tips, and tricks to help you stay informed and inspired.

Let's connect and lead the future together. Follow me for the latest updates and insights. 😎. ↗️ 🔔

Scaling Graph Chain-of-Thought Reasoning: A Multi-Agent Framework with Efficient LLM Serving

Making Graph Reasoning Work: Multi-Agent Architecture Cuts Costs by 95% While Improving Accuracy ...

Can an AI answer "What's the average price of items often viewed with product A?" Most current systems either hallucinate the answer or burn through thousands of tokens trying to figure it out. Here's why—and what changes when we fix it.

WHY This Matters

When LLMs need to reason over structured data like knowledge graphs, they face a dilemma. Traditional retrieval methods treat graphs like flat text, losing all the connections between entities. Chain-of-thought reasoning helps, but it creates a new problem: each reasoning step re-processes the entire context, leading to:

👉 Token costs exceeding $3 per query on commercial models
👉 Accuracy dropping below 50% on multi-hop questions
👉 Latency stretching to 40 seconds per answer

The core issue? Single-agent architectures that stuff everything into one massive prompt, causing the "lost-in-the-middle" problem where crucial information gets buried.

WHAT GLM Does Differently

GLM introduces a multi-agent framework where specialized agents handle distinct tasks:

👉 A classifier determines if a question needs simple lookup or complex reasoning
👉 A reasoning agent maintains a lightweight "notebook" of relevant facts
👉 An action agent generates executable Python code instead of verbose reasoning chains
👉 A graph retriever executes these snippets and returns precise results

Instead of maintaining one enormous context, each agent operates on minimal, task-specific information. The system replaces 8+ LLM calls with 2-3 focused interactions.

HOW It Achieves Better Performance

The technical innovations work in concert:

Vertex-centric caching groups node information with its immediate neighbors, creating reusable chunks that persist across queries. When multiple questions reference the same entities, the system reuses computed representations instead of recalculating them.

Priority-based eviction keeps frequently-accessed graph data in memory while discarding temporary reasoning artifacts. This prevents the cache from filling up with information that won't be reused.

Pipelined execution overlaps graph retrieval with LLM inference. While the model generates code, the system preemptively fetches data, hiding latency that would otherwise stack sequentially.

The results speak clearly: 38% higher accuracy, 95% fewer tokens, 90% lower latency, and 15× higher throughput compared to existing graph reasoning systems.

This matters because structured data powers most enterprise applications—from recommendation engines to medical diagnosis systems. Making graph reasoning both accurate and affordable opens these capabilities to practical deployment.

Raphaël MANSUY

Data Engineering | DataScience | AI & Innovation | Author | Follow me for deep dives on AI & data-engineering

Scaling Graph Chain-of-Thought Reasoning

When AI Agents Learn to Teach Themselves: Inside AgentEvolver's Self-Training Loop ...

What if AI agents could design their own training exercises, learn from their mistakes, and improve without constant human supervision?

Most AI agents today need expensive, hand-crafted training data and waste computational resources exploring randomly. AgentEvolver changes this by letting language models guide their own learning process.

WHY This Matters

Training capable AI agents is prohibitively expensive. Creating realistic tasks requires deep domain expertise. Traditional reinforcement learning burns through compute with aimless trial-and-error. And when agents do learn something useful, they struggle to apply those lessons efficiently.

The result? Most organizations can't afford to build agents that adapt to new environments.

WHAT AgentEvolver Does

The system implements three interconnected mechanisms:

👉 Self-Questioning

The agent explores new environments autonomously, discovers what's possible, and generates its own training tasks. Instead of requiring humans to write hundreds of example scenarios, it observes the environment and asks: "What problems could I solve here?"

👉 Self-Navigating

Past experiences get distilled into reusable knowledge snippets. When facing similar situations, the agent retrieves relevant lessons and applies them—much like humans reference mental notes from previous projects.

👉 Self-Attributing

Rather than treating all actions in a successful trajectory equally, the system evaluates each step's actual contribution. Did this action move toward the goal, or was it irrelevant? This granular feedback dramatically improves learning efficiency.

HOW It Works in Practice

On benchmarks like AppWorld and BFCL, AgentEvolver achieved 45-58% task completion with 7B parameter models, outperforming much larger baselines. The 14B version reached 58-73%.

More importantly, it got there using far fewer training samples. By generating its own diverse tasks and learning precisely from each action, the system extracts more value from every interaction.

The framework is open-source and modular. Researchers can swap in different exploration strategies, experience management approaches, or reward schemes without rebuilding the entire pipeline.

The Practical Implications

This approach addresses three bottlenecks: task scarcity, exploration inefficiency, and poor sample utilization. For teams building agents in specialized domains—medical diagnosis workflows, enterprise software automation, scientific research tools—the ability to bootstrap training data and learn efficiently matters enormously.

Early results suggest agents trained this way generalize better across domains. 

An agent trained on one environment maintained 95% performance when transferred to another, indicating it learned genuinely useful reasoning patterns rather than memorizing specific scenarios.

AgentEvolver

Assessing LLMs for Serendipity Discovery in Knowledge Graphs ...

Teaching AI to Make Lucky Discoveries: A New Benchmark for Serendipity in Drug Research

What if the key to finding new treatments isn't just searching harder—but searching differently?

Researchers at Case Western Reserve University just released SerenQA, a framework that asks a fascinating question: can large language models uncover "serendipitous" discoveries in biomedical research? Think of it like the accidental discovery of penicillin, but guided by AI.

WHY This Matters

Current AI systems excel at finding what we already know. Ask about drugs for pain relief, and you'll get the usual suspects: opioids, NSAIDs. But what about unexpected connections—like discovering a heart medication could treat Alzheimer's?

Drug repurposing (finding new uses for existing drugs) depends on these surprising insights. Yet most AI tools optimize for relevance and accuracy, missing the "happy accidents" that drive scientific breakthroughs.

WHAT They Built

👉 A Serendipity Metric (RNS)
The team created a mathematical measure combining three dimensions:
- Relevance: Is it actually related to the question?
- Novelty: Does it add new information?
- Surprise: Is it unexpected given what we know?

👉 A Drug Repurposing Benchmark
Using the Clinical Knowledge Graph (15M+ entities, 220M+ relationships), they built 1,529 expert-verified questions. Each answer is labeled not just as correct/incorrect, but as "expected" or "serendipitous."

👉 A Three-Phase Evaluation
Knowledge retrieval → Subgraph reasoning → Serendipity exploration

HOW It Works (and What They Found)

The framework tests whether AI can navigate from known drugs to surprising alternatives through multi-hop reasoning in knowledge graphs.

The results? Eye-opening.

Frontier models like GPT-4o and DeepSeek-V3 perform well on basic retrieval (78% accuracy for simple queries). But when asked to explore serendipitous connections? Performance drops dramatically—often below 10% for complex, multi-hop queries.

Even more telling: no single model excels across all tasks. Some are great at retrieval but poor at reasoning. Others identify novel paths but struggle with accuracy.

The Implications

This research reveals a crucial gap: today's AI can find needles in haystacks, but struggles to notice the unexpected needle that might be even more valuable.

For drug discovery, this matters enormously. The next breakthrough treatment might not come from obvious connections, but from surprising relationships hiding in plain sight within biomedical databases.

The SerenQA framework provides the first systematic way to measure and improve this capability—complete with open datasets and reproducible benchmarks.

LLMs for Serendipity Discovery in Knowledge Graphs

Google Research Nested Learning: The Illusion of Deep Learning
Architectures

What if Deep Learning Has Been Hiding Its True Structure All Along?

WHY This Matters

Current language models excel at tasks within their training distribution but struggle with continual learning. They can't easily acquire new knowledge after deployment without expensive retraining.

Think of it like a person with anterograde amnesia: they remember everything from before a certain point but can't form new long-term memories. Their knowledge is frozen in the past, with only fleeting awareness of the present.

WHAT Nested Learning Reveals

👉 The Core Insight

Nested Learning (NL) shows that neural networks are actually integrated systems of optimization problems, each operating at different timescales. Rather than a flat stack of layers, models contain hierarchies of components that update at different frequencies.

Consider how this applies to a simple example: when you train a network with momentum-based gradient descent, you're actually running two nested optimization processes. The momentum term itself is a memory system that compresses past gradients, while the outer loop updates the main weights.

👉 Three Key Discoveries

The paper demonstrates this perspective through:

Deep Optimizers: Common algorithms like Adam are revealed to be associative memory modules. This insight enables designing more expressive optimizers with deeper memory structures.

Self-Modifying Models: HOPE, a new architecture that learns to modify its own update algorithm, achieving stronger performance on language modeling and continual learning tasks.

Continuum Memory System: A generalization beyond "long-term/short-term memory" where different components update at frequencies matching their role—fast updates for immediate context, slow updates for stable knowledge.

HOW It Changes Our Approach

👉 Practical Implications

This framework suggests we can build more capable models by adding "levels" rather than just layers. Each level operates on its own context flow with its own update frequency, similar to how different brain regions process information at different timescales.

The experiments show HOPE outperforms Transformers and modern recurrent models on language modeling benchmarks while maintaining better continual learning abilities. The architecture naturally handles long contexts by consolidating information across multiple timescales.

👉 A Different Lens

Nested Learning provides a mathematically transparent view of what happens inside neural networks during training. Instead of treating optimization and architecture as separate concerns, it shows they're fundamentally intertwined.

This perspective opens new design dimensions: rather than asking "how many layers?" we can ask "how many levels?" and "what update frequencies?" The result is models that more naturally adapt and learn continuously, addressing one of the key limitations of current systems.

The Illusion of Deep Learning Architectures

Why Training AI Agents Is Still So Expensive—And How Synthetic Experience Changes That

How do you teach an AI agent to navigate websites, control robots, or use tools—without burning through compute budgets or waiting weeks for real-world data?

Traditional reinforcement learning (RL) for language model agents hits a wall: collecting interaction data from real environments is slow, costly, and often unsafe. Every click, every API call, every Docker container adds up. And when environments are dynamic or lack reset mechanisms, training becomes nearly impossible.

👉 The Core Problem

Most RL setups require agents to interact with actual systems—web browsers, simulators, live APIs—to learn. This creates three bottlenecks:

- Sparse, expensive rollouts: Real environments are slow to query and hard to parallelize
- Limited task diversity: Manually designing thousands of valid tasks requires expert validation
- Unstable rewards: Dynamic systems produce noisy, inconsistent feedback that breaks learning

The result? RL remains impractical for most real-world agent applications.

👉 A Scalable Alternative: Synthetic Experience

Instead of replicating environments pixel-by-pixel, DREAMGYM builds a reasoning-based experience model that operates in an abstract text space. Think of it as a learned simulator that predicts what happens next—not by copying raw observations, but by reasoning through consequences.

Key mechanisms:

- Chain-of-thought state transitions: The model explains why an action leads to a particular outcome, grounding predictions in causal logic
- Experience replay with retrieval: It references similar past trajectories to stay factually consistent
- Curriculum task generation: High-entropy tasks (where the agent sometimes succeeds, sometimes fails) are automatically expanded into harder variations

This approach produces diverse, informative training data without touching the real environment.

👉 What This Enables

On benchmarks where RL infrastructure doesn't exist (like WebArena), DREAMGYM makes training feasible for the first time—achieving 30%+ improvement over baselines.

On expensive but RL-ready tasks (WebShop, ALFWorld), it matches traditional RL performance using zero real interactions. And when used as a warm-start before real-environment fine-tuning, it cuts required data by 90% while boosting final performance by 40%.

The insight: agents don't need perfect environment clones. They need consistent, causally grounded experiences that teach credit assignment and exploration strategies.

👉 Why This Matters

Scaling agent learning has been bottlenecked by data collection costs. By synthesizing experiences through reasoning rather than simulation fidelity, this work demonstrates a path to training general-purpose agents without prohibitive infrastructure.

It's not about replacing real-world testing—it's about making the learning process efficient enough to actually reach it.

Scaling Agent Learning via Experience Synthesis

Why Your AI Search Agent Burns Through Tokens (And How TeaRAG Fixes It)

Ever noticed how AI search systems give you the right answer but take forever and cost a fortune in API calls?

Here's the problem: Current AI agents that search and reason through information are incredibly inefficient. They retrieve massive chunks of text, overthink simple problems, and perform redundant searches—wasting computational resources while delivering results.

WHY This Matters

When you ask an AI to find information and reason about it, two things drain tokens:

- The retrieved content itself (often verbose document chunks filled with irrelevant context)
- The thinking process (unnecessary reasoning steps and repeated searches)

Most systems optimize for accuracy alone, ignoring this efficiency problem entirely.

WHAT TeaRAG Does Differently

Researchers from USTC, City University of Hong Kong, and Xiaohongshu developed TeaRAG—a framework that compresses both retrieval content and reasoning steps.

👉 The retrieval innovation:

Instead of feeding the AI full text chunks, TeaRAG builds a Knowledge Association Graph that combines:

- Semantic chunks (context-rich but verbose)
- Knowledge triplets (concise facts)
- Co-occurrence relationships (what appears together)

Using Personalized PageRank, it filters this graph to keep only high-density, relevant information.

👉 The reasoning innovation:

TeaRAG introduces Iterative Process-aware Direct Preference Optimization (IP-DPO). Rather than just rewarding correct final answers, it evaluates each reasoning step:

- Does this step acquire necessary knowledge?
- Are we overthinking?
- Are we repeating searches unnecessarily?

This trains the model to think more efficiently.

HOW Well It Works

Testing on six question-answering benchmarks:

- 4% better accuracy on Llama3-8B while using 61% fewer tokens
- 2% better accuracy on Qwen2.5-14B while using 59% fewer tokens

The system handles both simple single-hop questions (answered in one step) and complex multi-hop questions requiring multiple reasoning stages.

The Technical Insight

The key realization: information from different sources that refers to the same fact (co-occurrence) provides a strong relevance signal. When a text chunk and a knowledge triplet both mention the same entity, that's high-confidence information worth keeping.

This co-occurrence mechanism, combined with process-level training rewards, creates a system that's both more accurate and dramatically more efficient.

The code is open source, and the approach works across different language model families—suggesting these efficiency gains are broadly applicable.

For teams building AI search systems, this represents a practical path toward production-ready agents that don't require massive computational budgets.

TeaRAG: A Token-Efficient Agentic RAG

The Reality Check: How AI Models Actually Perform on Real Software Engineering Tasks

Most coding benchmarks test AI on simple puzzles. But real software engineering isn't about solving algorithms—it's about fixing bugs across thousands of files, refactoring legacy code, optimizing performance, and deploying systems that actually work.

So how do today's top AI models perform when faced with the messy reality of production codebases?

Why This Matters

Current benchmarks focus almost entirely on Python bug fixes. That's like testing a surgeon only on papercuts. Real developers work across multiple languages, handle diverse tasks, and navigate complex repository structures.

The gap between benchmark performance and real-world capability has been unclear—until now.

What SWE-Compass Reveals

A new study evaluated 10 leading AI models (including Claude Sonnet 4, GPT-4.1, and Qwen3-Coder) across 2,000 real-world software engineering tasks:

👉 8 task types: bug fixing, refactoring, feature implementation, test generation, performance optimization, code understanding, configuration, and documentation

👉 10 programming languages: from Python and Java to Rust and Go

👉 8 scenarios: application development, ML systems, database engineering, security, infrastructure, and more

Each task came from actual GitHub pull requests with executable tests—no synthetic problems.

The Results Are Humbling

Even the best model (Claude Sonnet 4) resolved only 33% of tasks. Most models hovered around 20%.

The difficulty hierarchy was clear:
- Easiest: Code understanding and configuration tasks (40-50% success)
- Medium: Refactoring and feature enhancement (25-30%)
- Hardest: Feature implementation and test generation (15-20%)

Language matters too. Models performed better on Java and JavaScript than on systems

SWE-Compass

adk-code / Google ADK Coding Agent in GO

Your AI coding agent just cost you $50. Here's why—and how to fix it.

Last week, Google released ADK (Agent Development Kit) for Go. Today, I'm open-sourcing adk-code—the first production-grade coding agent built with it.

🔴 The Problem Everyone Ignores

Most AI agent demos look impressive. Then you run them in production:

Turn 1: 250 tokens
Turn 5: 1,220 tokens
Turn 20: 40,220 tokens
A simple 20-turn conversation? $3.42 on Gemini 2.5 Flash.

That's 20x more expensive than it should be. This is why agent projects die after the demo.

✅ What adk-code Does Differently

Built on Google ADK Go, adk-code solves three production-killers:

- Session Compaction: LLM-powered summarization reduces token usage by 60-80%. Same 20-turn conversation? Now $0.68.
- Immutable Event Log: Every decision, tool call, and result logged in SQLite. Full audit trail, no data loss, replay-ready.
- MCP Integration: Plug in ecosystem tools (GitHub, databases, Slack) without recompiling. JSON config, automatic discovery.
- Dynamic Sub Agent compatible with Claude Code Agent

🛠️ What It Actually Does

27 built-in tools across 6 categories:

- Read/write files
- Execute commands
- Apply code patches
- Search with grep
- Delegate to sub-agents

Example: "Fix my failing tests"

The agent autonomously:
Runs tests, sees the error
Reads relevant files
Makes a wrong guess, backtracks (yes, it self-corrects)
Finds root cause
Applies patch
Verifies tests pass
7 turns. 1,900 tokens. $0.14.

📊 Why Go? Why ADK?

Go gives you:
53MB single binary (zero runtime dependencies)
<500ms startup

Native concurrency for parallel tool execution

Type safety for complex state machines

ADK gives you:

- Official Google framework
- Built-in tool calling
- Session management primitives
- Production-ready abstractions
- MCP Support 

🎯 The Real Innovation

Most frameworks focus on pretty UIs. adk-code focuses on economics:
Naive agent: $3.42 per 20-turn session
adk-code: $0.68 per 20-turn session

That 80% reduction is the difference between "cool demo" and "production-viable product."

💡 Technical Deep Dive

- The agent loop is trivial (50 lines). The value is in:
- Token-aware compaction (triggers at 70% context window)
- Tool standardization (4-step pattern, scales to 30+ tools)
- Error recovery (graceful failures, no infinite loops)
- MCP protocol support (stdio, SSE, HTTP transports)

🚀 Get Started

export GOOGLE_API_KEY=<your-key>
./adk-code
> "Review my code for security issues"

The agent discovers files, analyzes code, reports findings—autonomously.

It is a very early version started last week.

GitHub: https://lnkd.in/gH3zU7yT

Read the full architecture breakdown (token economics, compaction algorithm, production examples):

ADK Code - Coding Agent in built with Google ADK in GO

Solving Million-Step Tasks With Zero Errors: A New Approach to Reliable AI Systems

Can AI Systems Really Execute a Million Steps Without Making a Single Mistake?

Most large language models fail catastrophically after just a few hundred consecutive steps. Even with a 99% per-step accuracy, you're virtually guaranteed failure at scale. This paper introduces a system that solves tasks requiring over one million LLM steps with zero errors.

Why This Matters

When AI systems need to execute long-running processes—think supply chains, medical protocols, or complex software development—even rare errors compound into inevitable failure. Current benchmarks test LLMs on tasks with dozens of steps, but real-world applications often require thousands or millions of dependent operations.

The researchers used Towers of Hanoi as their testbed: a puzzle that scales naturally from trivial to impossibly long. With 20 disks, the optimal solution requires 1,048,575 moves. State-of-the-art models consistently fail after a few hundred steps.

What They Built

👉 The Framework: MAKER (Massimal Agentic decomposition, first-to-ahead-by-K error correction, and Red-flagging)

The core insight: break tasks into the smallest possible subtasks, assign each to a focused microagent, then use voting to catch errors.

Three key components:

- Extreme decomposition: Instead of one agent handling multiple steps, each agent executes exactly one step
- First-to-ahead-by-k voting: Multiple agents independently solve each step; the first answer to get k votes ahead wins
- Red-flagging: Discard responses showing signs of confusion (unusual length, formatting errors)

How It Works

The math is elegant. With per-step accuracy p and voting margin k, the probability of solving all s steps correctly is:

P_full = (1 + ((1-p)/p)^k)^(-s)

This scales logarithmically with task length—meaning you can maintain high reliability even as tasks grow exponentially longer.

The system solved the 20-disk Towers of Hanoi perfectly using gpt-4o-mini (not even a reasoning model). Total cost: predictable and manageable because most errors get caught in the first few voting rounds.

The Surprising Part

Smaller, cheaper models work fine. The framework doesn't require cutting-edge reasoning capabilities—it needs reliable execution of simple steps. This challenges the assumption that scaling AI means building ever-larger models.

The approach draws parallels with error correction in classical computing, quantum systems, and even biological processes. Just as these domains achieve reliability through redundancy and verification, linguistic computing can scale the same way.

The implications extend beyond puzzles. Safety-critical systems, long-running workflows, and complex multi-step reasoning all benefit from this architecture. By decomposing tasks and checking each step, you reduce both failure rates and potential for harmful behavior.

Maker

LeJEPA: The Theory-Driven Approach to Stable Self-Supervised Learning

What if we could train AI models without labels, without collapse, and without the usual bag of tricks?

Most self-supervised learning methods today are fragile. They need teacher-student networks, stop-gradients, careful hyperparameter scheduling, and still might collapse during training. It's like building a house of cards—one wrong move and everything falls apart.

LeJEPA changes this by answering a fundamental question: what distribution should learned representations follow to minimize risk on downstream tasks?

WHY This Matters

👉 Current self-supervised methods lack theoretical grounding
Researchers have been adding heuristics to prevent collapse—momentum encoders, asymmetric architectures, exponential moving averages. These work, but nobody knew why. The field became an empirical guessing game.

👉 Foundation models need reliable pretraining
When you're spending millions on compute, you want guarantees. Current methods offer none. Training might succeed or fail, and you only know after the fact.

WHAT LeJEPA Provides

The paper proves that isotropic Gaussian embeddings uniquely minimize worst-case risk across downstream tasks—for both linear and nonlinear probes. This isn't just theory; it's a design principle.

They introduce SIGReg (Sketched Isotropic Gaussian Regularization), which enforces this optimal distribution through:
- Random 1D projections of embeddings
- Characteristic function matching
- Linear time and memory complexity

The complete training objective combines prediction loss with SIGReg. That's it. No teacher network, no stop-gradient, no momentum encoder.

HOW It Works in Practice

👉 Implementation simplicity
The entire method takes roughly 50 lines of PyTorch code. One hyperparameter controls the trade-off between prediction and regularization. Works out-of-the-box across ResNets, ViTs, ConvNets—over 60 architectures tested.

👉 Training stability
Loss correlates 99% with downstream performance when properly scaled. This means you can select models without labeled validation data—a first for self-supervised learning.

👉 Domain-specific pretraining

On Galaxy10 dataset, LeJEPA pretrained on 11,000 samples outperforms DINOv2/v3 trained on billions of natural images. The method scales down as well as it scales up.

Results on ImageNet-1k: 79% top-1 accuracy with ViT-H/14, competitive with methods using 3x more training epochs.

The theoretical foundation removes guesswork. The simple implementation removes barriers. The stable training removes risk.

Yann Lecun latest paper LeJEPA

Building AI Agents That Actually Work in Production

Ever wondered why most AI agents fail when they leave the lab?

The gap between a working prototype and a reliable production system is massive. Most agent frameworks force you to choose between flexibility and safety, between local testing and remote deployment, between simple demos and complex real-world applications.

WHY This Matters

Software agents are moving beyond assistive tools into autonomous systems that run for hours on complex tasks. But deploying them reliably requires foundations that earlier frameworks simply didn't need: durable state management, secure sandboxed execution, and consistent behavior from local development to cloud production.

The OpenHands team learned this the hard way. Their original architecture—which helped them reach 64k GitHub stars—became increasingly brittle as it scaled. Configuration sprawl, tight coupling between components, and mandatory sandboxing created friction at every turn.

WHAT They Built

The OpenHands Software Agent SDK is a complete architectural redesign based on four principles:

👉 Optional isolation: Agents run locally by default but can switch to sandboxed environments transparently when needed.

👉 Stateless by default: All components are immutable. Only the conversation state changes, making sessions recoverable and behavior deterministic.

👉 Strict separation: The agent core is decoupled from applications, eliminating the monolithic tangle that plagued version 0.

👉 Two-layer composability: Four modular packages (SDK, Tools, Workspace, Server) combine flexibly, and developers can extend capabilities by adding typed components.

HOW It Works

The SDK provides what others don't: seamless transition from local prototyping to production. Change one line—swap LocalWorkspace for DockerWorkspace—and your agent moves from running on your machine to executing in a secure container.

It includes native support for 100+ LLMs through model-agnostic routing, automatic security analysis of agent actions, built-in REST and WebSocket APIs, and interactive workspace access through VSCode Web, VNC, and browser interfaces.

The system achieves 72.8% on SWE-Bench Verified and 67.9% on GAIA benchmarks, demonstrating that architectural soundness doesn't sacrifice performance.

Perhaps most importantly, it's the only SDK with continuous LLM-based integration testing and built-in academic benchmark evaluation—treating reliability as a first-class concern rather than an afterthought.

The difference between a research demo and production-ready infrastructure often comes down to these unsexy details: proper state management, security boundaries, and deployment flexibility. This SDK gets them right.

The OpenHands Software Agent SDK

Teaching AI Agents to Learn Like Scientists: The AgentEvolver Approach

What if AI agents could teach themselves instead of waiting for humans to handcraft every training example?

Most autonomous agents today face a costly bottleneck: they need massive amounts of manually created tasks and extensive random exploration to learn anything useful. It's like teaching someone to cook by having them randomly try ingredients until something works—inefficient and expensive.

👉 The Core Problem

Current reinforcement learning approaches for LLM-based agents suffer from three key limitations:

- Manual task construction is prohibitively expensive in new environments
- Random exploration wastes computational resources on redundant trials
- Sparse rewards fail to identify which specific actions actually contributed to success

This makes agent training a laborious process that doesn't scale.

👉 A Self-Directed Learning Framework

Researchers from Alibaba's Tongyi Lab introduce AgentEvolver, a system where the language model itself drives its own improvement through three mechanisms:

Self-Questioning: The agent explores unfamiliar environments autonomously, discovering what's possible and generating its own training tasks. Think of it as curiosity-driven learning—the agent asks "what can I do here?" and creates challenges based on what it finds.

Self-Navigating: Instead of random trial-and-error, the agent builds a memory of past experiences and reuses successful patterns. It learns which approaches worked before and applies them to similar situations, dramatically reducing wasted exploration.

Self-Attributing: Rather than treating all actions equally, the agent uses its reasoning capabilities to determine which specific steps contributed to success or failure. This enables more precise learning from each attempt.

👉 Practical Results

On standard benchmarks, AgentEvolver shows substantial improvements. A 14B parameter model achieves 49% task completion on AppWorld and 70% on BFCL v3—outperforming much larger 30B+ models trained conventionally.

The framework is open-source and designed for practical use, with standardized environment interfaces and modular components that developers can adapt to specific needs.

The shift here is fundamental: from human-engineered training pipelines to agent-directed learning loops. The model doesn't just execute tasks—it formulates them, learns from experience, and refines its own judgment about what works.

AgentEvolver: Towards Efficient Self-Evolving Agent System

AI Product Manager @ Google | Open Source Awesome LLM Apps Repo (#1 GitHub with 79k+ stars) | 3x AI Author | Views are my Own

We just ran the biggest AI Agent course ever 🤯

Here's the list of all the resources we released from Day-1 to Day-5.

250+ pages of production AI Agent insights. 100% free.

📌 Day 1: Introduction to AI Agents (50 pages)
Most agent demos fail in production. This covers the 5 levels of AI agents, from basic reasoning to self-evolving systems, plus the security and architecture patterns that actually work at scale.

Link: https://lnkd.in/dQSzVjR7

📌 Day 2: Agent Tools and MCP (50 pages)
MCP servers can add new tools without your approval. Your poetry bot suddenly gains purchasing power overnight. This breaks down tool design, the Model Context Protocol, and the security risks hiding in plain sight.

Link: https://lnkd.in/dUztxWDA

📌 Day 3: Context Engineering and Memory (70 pages)
Agents with zero long-term memory treat every session like meeting you for the first time. Learn how to build memory systems that actively curate context, not just save conversations.

Link: https://lnkd.in/dMqjwrqF

📌 Day 4: Agent Quality (50 pages)
Traditional QA doesn't work for agents. You can't unit test judgment. This covers the 4 pillars of agent quality (effectiveness, efficiency, robustness, safety) and how to actually evaluate the reasoning process.

Link: https://lnkd.in/dQR3_HkG

📌 Day 5: Prompt to Production (40 pages)
Building an agent takes 2 weeks. Trusting it in production takes 6 months. Learn evaluation gates, circuit breakers, and evolution loops that close the gap between demo and deployment.

Link: https://lnkd.in/dVHSeWmE

With insights from experts including Antonio Gulli, Alan Blount, Michael Zimmerman, Vladimir Vuskovic, Michael S., Kanchana Patlolla, Santiago (Sal) Diaz, Madhurranjan Mohaan, Kimberly Milam, Meltem Subasioglu, Turan Bulmus, Wafae Bakkali, PhD, Dr. Sokratis Kartakis, Gabriela Hernández Larios, Ran Li, Elia Secchi, and Huang Xia 🔥

Kudos to Kanchana Patlolla, Anant Nawalgaria and Polong Lin for the amazing organization 🙌

The best part?
250+ pages. Zero fluff. 100% free.

Repost this so your network doesn't miss it ♻️

Making AI Reasoning Verifiable: How VeriCoT Checks Logic Step-by-Step

When ChatGPT or Claude gives you a multi-step answer, how do you know the logic is sound? Even when these models reach the right conclusion, their reasoning path might contain subtle errors that undermine trust—especially in high-stakes domains like medicine or law.

WHY This Matters

Large language models predict plausible text, but they lack built-in mechanisms to verify logical validity. A model might tell you "Charlie qualifies for benefits because he's 18" when the actual age limit is 21. The final answer could be correct by accident, while the reasoning is flawed.

This creates a real problem: we can't rely on AI explanations in domains where the reasoning path matters as much as the answer.

WHAT VeriCoT Does

Researchers from UPenn and AWS have developed a neuro-symbolic verification system that checks whether each step in an AI's chain-of-thought actually follows logically.

The approach works in three parts:

👉 Translation: Each reasoning step gets converted into formal first-order logic

👉 Grounding: The system identifies which premises support each step—whether from the source document, common sense, or prior reasoning

👉 Verification: An automated solver checks if the logic is valid and the premises are sound

When reasoning fails verification, the system pinpoints exactly why: contradictions, ungrounded claims, or steps that can't be formalized.

HOW It Improves AI Systems

The verification signals enable three practical improvements:

Self-reflection at inference time: Models can detect and fix their own logical errors, improving verified answer rates by 46% on average

Better training data: Verified reasoning chains create high-quality datasets for supervised fine-tuning

Preference learning: The system generates reward signals for training models to produce more logically consistent reasoning

Tests across ProofWriter, LegalBench, and BioASQ datasets show that verified chains predict correct answers more reliably than raw model outputs. Fine-tuned models maintain accuracy while generating 18% more verifiable reasoning.

The code translates natural language into SMT-LIB format and uses the Z3 solver for consistency checks. When premises can't be found in context or common sense, the system flags the reasoning as ungrounded rather than accepting it.

This matters because it makes AI reasoning transparent and checkable—not just by other AIs, but by humans who need to understand whether to trust the logic.

VERICOT: NEURO-SYMBOLIC CHAIN-OF-THOUGHT

Google ADK and GEPA (Genetic Evolutionary Prompt Augmentation): Your AI Agent's Instructions Keep Breaking. Here's Why—And How to Fix It Automatically ...

Ever spent hours perfecting your agent's prompt, only to watch it fail on the first real user request?

You're not alone. The problem isn't you—it's the approach.

WHY Manual Prompt Engineering Fails

When you build an AI agent in Google ADK, you write detailed instructions that define how it should behave. Think of it as the agent's Standard Operating Procedure.

Here's what happens next:

You add a rule to fix a bug. That rule conflicts with an existing one. You add an exception. The exception breaks something else. You patch that. Soon, you have 100+ interconnected rules that nobody can safely modify.

Worse: your prompt works perfectly on your 10 test cases, then fails spectacularly in production on edge cases you never imagined.

The core issue? Prompts are complex systems with interacting rules. Manual optimization doesn't scale.

WHAT GEPA Does Differently

GEPA (Genetic Evolutionary Prompt Augmentation) treats your agent's instructions as an evolving system, not a static document.

Instead of guessing improvements, GEPA:

👉 Tests your prompt against real scenarios

👉 Uses an LLM to analyze why failures occurred

👉 Generates targeted improvements addressing root causes

👉 Tests the improvements and keeps what works

👉 Repeats until your prompt reaches target performance

The breakthrough: combining genetic algorithms with LLM intelligence. Traditional approaches mutate randomly. GEPA mutations are guided by actual understanding of what went wrong.

Real results from the tutorial demo:
- Iteration 1: 0% success
- Iteration 2: 40% success
- Iteration 3: 90% success
- Fully automated, no manual tweaking required

HOW to Get Started in 5 Minutes

Try the simulated demo (free, instant):

cd tutorial_implementation/tutorial_gepa_optimization
make setup && make demo

You'll watch a weak prompt evolve into one that handles all test scenarios correctly.

For real LLM-driven optimization:

export GOOGLE_API_KEY="your-api-key"
make real-demo

This runs actual Gemini calls to analyze failures and generate improvements. Cost: about $0.05-0.10.

The complete tutorial walks through:
- Building evaluation scenarios
- Implementing the optimization loop
- Understanding LLM reflection mechanics
- Deploying to production

What This Means

We're replacing traditional software with LLM agents, but still using pre-LLM development practices. Manual prompt engineering, ad-hoc testing, no systematic improvement.

GEPA brings data-driven optimization to agent development. Your prompts improve automatically based on real performance data, not guesswork.

The tutorial includes production-ready code (535 lines), 18 passing tests, working demonstrations, and deployment patterns.

Stop patching prompts manually. Start optimizing them systematically.

Link in comments 👇

Google ADK and GEPA

Kosmos: An AI Scientist for Autonomous Discovery ... "What if AI could do 6 months of scientific research in a single weekend?"

Can an AI system really discover new scientific insights on its own?

Not just analyze data or search papers—but actually formulate hypotheses, run experiments, and write up findings like a human researcher would.

That's the question behind Kosmos, a new AI scientist from a team spanning Oxford, Stanford, MIT, and several research institutes.

WHY this matters

Scientific discovery moves slowly. A single research project can take months or years. Data sits unanalyzed. Hypotheses go untested. Connections between fields remain unmade.

The bottleneck isn't computing power—it's the iterative human process of reading papers, forming ideas, testing them, and synthesizing results.

WHAT Kosmos does

👉 Autonomous research cycles

Kosmos runs for up to 12 hours, performing parallel data analysis and literature searches. It executes an average of 42,000 lines of code and reads 1,500 papers per run—coordinating hundreds of agent tasks through a structured "world model" that maintains context.

👉 Traceable reasoning

Every claim in its reports links directly to code or primary sources. Independent scientists validated 79% of statements as accurate. Collaborators estimated a single run equals roughly 6 months of equivalent expert research time.

👉 Real discoveries across fields

The paper presents seven case studies spanning metabolomics, materials science, neuroscience, and genetics:

- Three reproduced findings from unpublished or recent manuscripts
- Four made novel contributions, including identifying a new mechanism of neuronal aging in Alzheimer's disease

HOW it works

The system uses two specialized agents—one for data analysis, one for literature search—coordinated by a world model that tracks findings and proposes next steps.

This architecture lets Kosmos maintain coherence across extended research sessions, something previous AI systems struggled with.

The key innovation: instead of trying to do everything in one pass, Kosmos iterates. It explores multiple hypotheses in parallel, updates its understanding, and refines its approach—much like a human researcher would.

The catch
Kosmos isn't perfect. It sometimes makes overly strong claims. It can propose statistically sound but conceptually obscure analyses. And it needs human scientists to curate input data and evaluate final results.

Think of it as a research accelerator, not a replacement. It handles the exhaustive exploration that humans find tedious, freeing experts to focus on interpretation and validation.

The paper is remarkably transparent about limitations—a refreshing approach in AI research.

Link to paper in comments.

An AI Scientist for Autonomous Discovery

DEEPPERSONA: Scaling Synthetic User Profiles Beyond Surface-Level Attributes

Why do synthetic personas keep failing to capture real human complexity? Most AI-generated user profiles are embarrassingly shallow. A handful of traits, maybe a brief bio—that's typically all we get. Yet researchers increasingly rely on these synthetic personas for everything from personalization to social simulations. The gap between what we need and what we have is massive.

The depth problem

Current approaches hit a fundamental wall. PersonaHub generates a billion profiles, but each remains surface-level. OpenCharacter adds conversational flair, but the underlying personas stay thin. The issue isn't quantity—it's that we're missing the semantic richness that makes humans, well, human.

Think about it: real people have layered histories, contradictory values, nuanced preferences across hundreds of dimensions. Existing synthetic personas capture maybe 5-10 attributes. That's not a person. That's a caricature.

A taxonomy-driven solution

DEEPPERSONA takes a different approach. Instead of asking an LLM to freestyle personas, researchers at UCSD and colleagues built the largest human-attribute taxonomy ever—over 8,000 hierarchically organized nodes extracted from real ChatGPT conversations.

👉 Stage one: Mine thousands of actual human-AI dialogues to discover what attributes people naturally disclose about themselves. Use semantic validation to merge and filter, creating a comprehensive tree of human characteristics.

👉 Stage two: Sample from this taxonomy progressively. Start with anchor traits (age, location, values), then systematically explore the attribute space. Each new trait gets generated by an LLM conditioned on everything already established, maintaining coherence while maximizing coverage.

The result? Personas averaging 200+ structured attributes and roughly 1MB of narrative text—two orders of magnitude deeper than prior work.

What this unlocks

The empirical gains are substantial:
* 32% higher attribute diversity versus state-of-the-art baselines
* 44% improvement in profile uniqueness
* 11.6% boost in personalized Q&A accuracy when conditioning GPT models
* 31.7% reduction in deviation from real human survey responses in social simulations
* 17% closer alignment to actual Big Five personality distributions for national populations


Why it matters now

As LLMs become more capable, the bottleneck shifts from generation quality to input quality. You can have the most sophisticated model, but if you're conditioning it on shallow personas, you get shallow outputs.

DEEPPERSONA provides the control surface researchers need: specify anchor attributes, dial depth requirements, generate targeted cohorts. It's a toolkit, not just a dataset. The team is releasing the codebase, taxonomy, and sample profiles to enable exactly this kind of systematic exploration.

DEEPPERSONA

Why Your AI Agents Can't Touch Production Data (And How to Fix It)

Here's a problem most enterprises face: their AI agents are smart enough to write code and analyze data, but not trusted enough to work on real systems. The gap isn't intelligence anymore—it's infrastructure.

WHY This Matters

Think about how databases solved concurrency decades ago. When multiple users query Postgres simultaneously, each one experiences the illusion of working alone. No conflicts, no corrupted data, no chaos.

This works because databases control three things tightly: data isolation through snapshots, compute isolation through transactions, and simple SQL abstractions that hide complexity.

Lakehouses broke this model. By decoupling storage and compute, supporting multiple languages, and spreading workloads across distributed systems, we lost the elegant guarantees that made databases trustworthy.

WHAT the Research Proposes

The paper "Trustworthy AI in the Agentic Lakehouse" by Tagliabue, Bianchi, and Greco introduces Bauplan—a reimagining of lakehouse architecture for agent workloads.

The core insight: solve concurrency first, and governance follows naturally.

👉 Three key mechanisms:

Data isolation through Git-like branching. Every pipeline runs on a temporary branch, merging to production only on success.

Compute isolation via sandboxed functions. Each task runs in its own container, no internet access, controlled package installation.

Declarative abstractions that unify the API surface. Agents express what data they need, not how to fetch it.

HOW It Works in Practice

Consider a self-healing pipeline that fails at 3 AM. An agent can:

- Analyze the failure through platform APIs
- Write corrective code in an isolated environment
- Execute fixes on a data branch (production stays untouched)
- Run automated verification checks
- Submit results for human review before merging

The platform enforces transactional guarantees across the entire pipeline—not just individual tables. If node 3 of a 5-node pipeline fails, nodes 1-2 don't pollute production.

Access control becomes straightforward because there's one narrow API to protect, not scattered tools across SQL engines, Python runtimes, and file systems.

The Bottom Line

We've built lakehouses for human teams. Agent teams need different primitives—ones that provide correctness by construction rather than hoping for careful coding.

Full paper and reference implementation available on arXiv and GitHub.

What governance challenges are you facing with agentic workflows?

Agentic LakeHouse

Anthropic: Code execution with MCP: Building more efficient agents

 Why Your AI Agent Is Wasting 98% of Its Context Window (And How to Fix It)

Ever wondered why your AI agent slows to a crawl when you connect it to dozens of tools?

The answer lies in how we've been building agent architectures. Anthropic just published research showing that traditional approaches waste massive amounts of context—and there's a surprisingly elegant solution.

WHY This Matters

When you connect AI agents to external systems through the Model Context Protocol (MCP), two problems emerge:

👉 Tool Definition Overload

Loading hundreds of tool definitions upfront fills the context window before any real work begins. Each tool description—parameters, return types, examples—consumes precious tokens.

👉 Intermediate Result Bloat

Every tool call result passes through the model's context. Ask your agent to copy a meeting transcript from Google Drive to Salesforce? That transcript flows through the context window twice. For a 2-hour meeting, that's 50,000 additional tokens.

The result: slower responses, higher costs, and agents that break when documents exceed context limits.

WHAT Anthropic Discovered

Instead of exposing MCP tools as direct function calls, present them as code APIs. Let the agent write code that calls these tools.

The difference is dramatic. In their Google Drive to Salesforce example, token usage dropped from 150,000 to 2,000—a 98.7% reduction.

HOW It Works

The agent discovers tools by exploring a filesystem structure:

servers/
 google-drive/
  getDocument.ts
 salesforce/
  updateRecord.ts

Instead of loading all definitions upfront, the agent reads only what it needs. Progressive disclosure at its finest.

The real power emerges in execution:

👉 Filter Before Returning

Process 10,000 spreadsheet rows in the execution environment, return only the 5 relevant ones to context.

👉 Complex Logic Without Context Bloat

Loops, conditionals, and error handling execute in the environment rather than through repeated model calls.

👉 Privacy by Default

Intermediate results never enter the model's context unless explicitly logged. Sensitive data can flow through workflows while remaining invisible to the model.

👉 Persistent State

Agents can save work to disk, resume tasks, and even persist their own code as reusable functions—building up a library of skills over time.

The Tradeoff

Code execution requires secure sandboxing, resource limits, and monitoring. This adds operational complexity that direct tool calls avoid.

But for agents working with many tools or large datasets, the benefits—98%+ token reduction, lower latency, better composition—often justify the infrastructure investment.

The insight feels obvious in hindsight: we're asking language models to write code because they're excellent at it. Why not leverage that strength for tool orchestration too?

AI That Reasons Like a Scientific Research Team

What if an AI system could tackle an International Physics Olympiad problem the same way expert physicists do—by coordinating specialized reasoning, iterative refinement, and multi-stage verification?

SciAgent demonstrates exactly this capability, achieving gold-medal performance across mathematics, physics, and chemistry competitions by organizing problem-solving as collaborative intelligence.

Why This Matters

Current AI systems excel at specific tasks but struggle when problems require different types of reasoning. A physics problem might need diagram interpretation, symbolic derivation, and numerical computation—all coordinated seamlessly. Traditional approaches hardcode solutions for each domain, limiting adaptability.

SciAgent introduces generalistic scientific reasoning: the ability to autonomously select and combine reasoning strategies based on what each problem actually requires.

How It Works

👉 Three-tier architecture

The system operates through coordinated layers:

- Coordinator Agent analyzes incoming problems and routes them to appropriate specialists
- Worker Systems handle domain-specific reasoning (mathematics, physics, chemistry)
- Sub-agents within each Worker execute specialized tasks (symbolic manipulation, verification, modeling)

👉 Dynamic pipeline assembly

Rather than following fixed procedures, the system builds custom reasoning chains for each problem. A physics question triggers collaboration between generation agents, image analyzers, and reviewers—each contributing their expertise when needed.

👉 Adaptive feedback loops

Sub-agents continuously critique and refine intermediate results. If a derivation contains errors, the review agent flags inconsistencies and triggers corrections before proceeding.

Performance Results

SciAgent matched or exceeded average gold medalist scores across five major competitions:

- IMO 2025: 36/42 points (above average gold medalist)
- IMC 2025: Perfect 100/100 score
- IPhO 2024/2025: Consistently above gold medal threshold
- CPhO 2025: 264/320 (significantly exceeding human gold standard)

The system also demonstrated strong generalization on chemistry olympiad problems and the Humanity's Last Exam benchmark, handling questions across biology, chemistry, and interdisciplinary science.

What Makes This Different

Previous systems required manual redesign for each new domain. SciAgent's hierarchical coordination allows it to apply the same organizational principles across diverse scientific fields—from proving mathematical theorems to analyzing chemical reaction mechanisms.

This isn’t about better benchmark scores — it’s about creating AI that adapts its reasoning to each problem, like human experts do.

The research team from Zhongguancun Academy, Peking University, and collaborating institutions has made the system open source, enabling further development of adaptive scientific reasoning architectures.

taplio

Raphaël MANSUY's Linkedin Analytics

Raphaël MANSUY

Performance ScoreRaphaël MANSUY's LinkedIn Performance

Raphaël MANSUY's Best Posts (last 30 days)

Ready to grow your LinkedIn presence?

taplio

.css-6ytdur{background-image:linear-gradient(284deg, rgba(39, 43, 72, 1) 0%, rgba(33, 47, 183, 1) 100%);color:transparent;-webkit-background-clip:text;background-clip:text;}Raphaël MANSUY's Linkedin Analytics

Raphaël MANSUY

Performance Score.css-goub6s{font-size:var(--chakra-fontSizes-md);font-weight:500;color:var(--chakra-colors-gray-600);display:block;margin-top:var(--chakra-space-1);}Raphaël MANSUY's LinkedIn Performance

Raphaël MANSUY's Best Posts .css-1emoo84{font-size:var(--chakra-fontSizes-md);font-weight:400;color:var(--chakra-colors-gray-600);}(last 30 days)

Ready to grow your LinkedIn presence?

Raphaël MANSUY's Linkedin Analytics

Performance ScoreRaphaël MANSUY's LinkedIn Performance

Raphaël MANSUY's Best Posts (last 30 days)