Architect Reliable AI Agents on a Solid Data Foundation

AI Agents are only as smart as the data they access. I bridge the gap between Data Software  Engineering and Autonomous AI.

👉 The Problem:

Most AI Agent initiatives fail because of poor data infrastructure. Without real-time pipelines and clean context, agents are just toys.

👉 The Solution:

I provide the Data and Context Engineering rigor required for high-performing AI Agents.

What You Gain:

- Smart Context: Engineering the data pipelines that feed your agents the right information at the right time.
- Reliable Execution: Implementing "Human-in-the-loop" and evaluation frameworks to ensure your agents act safely.
- Scalable Ops: From single agents to complex swarms, I architect the cloud infrastructure (AWS/Azure/GCP) to handle the load.

Legacy Integration: Connect your new AI workforce to your existing ERP, CRM, and internal tools seamlessly.
Why Me?
I combine the agility of a startup founder with the architectural discipline of a Fortune 500 consultant.

👉 Let's engineer agents that actually work: [https://topmate.io/raphael_mansuy]

EdgeQuake 0.3.0 is here — and it's a big one.

EdgeQuake is a high-performance GraphRAG engine built in Rust. Today we're shipping the release that makes it truly provider-agnostic, thanks to edgequake-llm, a new Rust crate for multi-LLM provider support with minimal dependencies.

🔥 Pick your LLM. Any LLM.

0.3.0 ships with 9 active providers and 26 model configurations out of the box: OpenAI, Anthropic, Google Gemini, xAI, Azure OpenAI, OpenRouter, Ollama, LM Studio, and Mock for testing.

That means you can run Claude Opus 4.6, Grok 4.1 with 2M context windows, Gemini 2.5 with thinking capabilities, or OpenAI's o4 reasoning models — all through the same API. Swap providers in config, not in code. Run local models with Ollama or LM Studio when privacy matters. Scale to cloud when throughput matters. No lock-in. No rewrites.

👉 Know what every answer costs.

Every model ships with verified February 2026 pricing baked in. Cost tracking isn't an afterthought — it's infrastructure. You get per-query cost visibility across 26 models and embedding endpoints so you can make real decisions about quality vs. budget before you scale.
👉 
Know where every answer comes from.

This release introduces full lineage tracking across your entire document pipeline. Every chunk knows its position in the source document, which LLM processed it, which embedding model encoded it, and the full document hierarchy from PDF to chunk to entity.

Query it via API, export it as JSON or CSV, or browse it in the WebUI. Lineage is enabled by default because traceability in RAG isn't optional — it's the difference between a demo and a production system.

👉 What else shipped:

Source citations now show actual document names instead of generic "chunk" labels. Folder management for conversations works reliably. The TypeScript, Python, Rust, Java, and Kotlin SDKs all have lineage and metadata methods. And there are zero breaking changes — upgrade and keep moving.

GraphRAG is powerful, but only when you can trust it, audit it, and run it on your terms. That's what 0.3.0 delivers.

Check out the full changelog and get started (in first comments)

Raphaël MANSUY

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

Kelvin Ndumia

Why I rebuilt a PDF-to-Markdown converter in Rust — and made it zero-config

Every time I needed to extract structured text from a PDF, I ended up in the same painful loop: install poppler, wrangle DYLD_LIBRARY_PATH, pray the native library loads, watch it fail on CI.

The Python tools worked — but they were slow, fragile, and required a runtime environment I didn't want to ship.

So I built edgequake-pdf2md — a Rust CLI and library that converts PDFs to clean Markdown using Vision LLMs (GPT-4.1, Claude, Gemini, Ollama).

What makes it different:

🔋 Self-contained binary — pdfium (~5 MB) is compiled into the binary by default. No runtime downloads. No env vars. cargo install edgequake-pdf2md and you're done.

⚡ Fast — concurrent page processing. A 50-page document costs ~$0.02 with GPT-4.1-nano.

🎯 Accurate — a 10-rule post-processing pipeline strips hallucinated image tags, fixes broken tables, and normalises whitespace.

🌍 Truly cross-platform — macOS arm64/x64, Linux x64/aarch64, Windows x64. All verified in CI.

🦀 Library + CLI — use it from the command line or embed it in your Rust application with a clean async API.

👉 Under the hood:

The bundled feature embeds pdfium at compile time. If you're building from source without a prebuilt copy, build.rs auto-downloads the correct binary for your platform and caches it in ~/.cargo/pdfium-bundle/. Zero friction.

👉 Try it in 60 seconds:

Or via Homebrew:

Inspired by the excellent Python project pyzerox, rebuilt for speed and reliability.

The full source, docs, and CI setup are on GitHub — link in the comments.

Would love feedback from anyone working with PDF extraction at scale. 👇

(Coming soon in egdquake)

Doc-to-LoRA: Learning to Instantly Internalize Contexts

What if an LLM could read a document once and remember it forever, without keeping it in context?

That’s the core question behind Doc-to-LoRA (D2L), a new paper from Sakana AI that caught my attention.

👉 WHY THIS MATTERS

Every time you feed an LLM a long document it pays a steep price: quadratic attention cost, huge KV-cache memory, and slower responses. Context distillation (CD) bakes document info into weights but requires expensive per-document gradient updates—minutes and tens of GBs of VRAM. Not practical for frequently changing docs.

So we’ve been stuck between fast-but-costly prompting and slow-but-efficient parameter updates.

👉 WHAT D2L DOES

D2L uses a lightweight hypernetwork (309M parameters) to approximate context distillation in a single forward pass. Instead of running gradient descent per document, a Perceiver-based network predicts the LoRA adapter that CD would produce. One pass, and the LLM can answer questions about the document without seeing it again.

Key results:

- Near-perfect needle-in-a-haystack retrieval at 4x the base model’s context window (32K+ tokens), despite training on 256-token sequences
- Outperforms standard CD on real QA benchmarks (SQuAD, DROP, ROPES) under limited compute budgets
- Internalization in under 1 second vs. 40–100+ seconds for CD
- Memory during updates under 2 GB vs. 40–79 GB for CD with generated queries
- Adapted model uses <50 MB at inference for long docs vs. 12+ GB for in-context baselines

HOW IT WORKS

Three design choices power D2L:

1. Meta-learning objective — train the hypernetwork across millions of contexts to minimize KL divergence between a teacher (LLM with context) and a student (LLM with predicted LoRA, no context). This amortizes query generation and backprop into one phase.
2. Perceiver architecture — cross-attention maps variable-length tokens to a fixed set of latents, producing fixed-shape LoRA matrices regardless of input length.
3. Chunking mechanism — long docs split into chunks, each yields a low-rank adapter; adapters concatenate along the rank dimension so longer docs get higher-rank adapters automatically, enabling generalization beyond training lengths.

One surprising finding: D2L can zero-shot transfer visual information from a vision-language model to a text-only LLM, reaching ~75% accuracy on ImageNet classification despite never seeing images during training.

Limitations: there’s still a gap versus full in-context learning; meta-training is expensive (five days on 8 H200 GPUs); and D2L can cause knowledge interference where internalized info overrides existing model knowledge.

Why it matters practically: sub-second document internalization with minimal memory enables frequent knowledge updates, personalized models, and on-device adaptation that CD alone can’t support.

Paper: "Doc-to-LoRA: Learning to Instantly Internalize Contexts" by Charakorn, Cetin, Uesaka, and Lange at Sakana AI.

Doc-to-LoRA: Learning to Instantly Internalize Contexts

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

World-Model–Augmented Web Agents with Action Correction

Why do AI web agents fail so often at simple browsing tasks?

Usually because they act without considering consequences.

Imagine navigating a complex website to buy a specific item. Before you click, you mentally simulate outcomes: "Checkout" leads to payment, "Back" might lose data. You have a mental model of how the web works.

Most current AI agents lack that foresight. They operate on an observe→reason→act loop. Once they click the wrong button, the damage is done. They can’t easily undo mistakes, causing cascades of errors and failed tasks.

A new paper, "World-Model–Augmented Web Agents with Action Correction," proposes WAC: a system that thinks ahead and corrects itself before acting.

👉 WHY this matters

Current agents suffer from two main problems:

- Cognitive isolation: a single model has limited perspective and can get stuck in reasoning loops.
- Lack of risk awareness: agents commit to actions without evaluating potential failure modes.

WAC treats web navigation not as reactive behavior but as a planned process involving consultation and simulation.

👉 WHAT is WAC?

WAC (World-model–augmented Action Correction) splits decision-making into two stages: Action Generation and Action Deduction. Rather than one model doing everything, WAC introduces a World Model—an AI specialized in understanding web environment dynamics that acts as strategist and simulator.

👉 HOW it works

- Collaboration on demand

When the agent encounters uncertainty, a router detects it and calls the World Model for advice. This provides high-level guidance and grounds the next move in an understanding of web rules.

- Simulation before execution

After the agent proposes an action (e.g., "click the blue button"), the World Model simulates the likely next state of the page instead of executing immediately.

- The correction loop

A Judge Model evaluates the simulated outcome. If the simulation predicts failure or a dead end, the Judge rejects the action and provides feedback. The agent refines its plan and repeats the loop until a high-confidence action is found.

By the time the agent interacts with the live browser, it has already verified the action through simulation and judgment, greatly reducing accidental errors and irreversible steps.

👉 Why this matters for product and research teams=

- More reliable automation for web tasks like form filling, checkout flows, and complex navigation.
- Reduced need for brittle recovery logic or manual intervention.
- A clear path toward safer, more predictable web agents that can be deployed with greater confidence.

WAC doesn’t just add another model—it changes the workflow: plan, simulate, judge, and only then act. That shift could be the difference between flaky web agents and ones you’d trust to complete real user journeys.

World-Model–Augmented Web Agents with Action Correction

Meta SWE-Protégé: Learning to Selectively Collaborate, With an Expert Unlocks Small Language Models as Software Engineering Agents  ...

What if a 7B-parameter model could fix real GitHub issues nearly as well as models 10x its size — by learning when to ask for help?

That's exactly what SWE-Protégé demonstrates. The idea is simple and powerful.

👉 WHY THIS MATTERS

Small language models (SLMs) are fast, cheap, and easy to deploy. But on complex software-engineering tasks like SWE-bench, they've been stuck around 17% accuracy. The core problem: they get trapped in loops, repeating the same commands without making progress. More training data doesn't fix this — it can even make things worse.

Large models like Claude Sonnet solve these tasks but are expensive to run continuously. So: can a small model do most work and only call a big model when genuinely stuck?

👉 WHAT SWE-PROTÉGÉ DOES

Think pair programming: a junior (7B model) handles the keyboard and does the bulk of the work. When stalled, it recognizes the situation, asks a focused question to the senior (the expert), and then follows the advice across multiple steps.

Three learned behaviors enable this:
- Recognizing when it's stuck instead of looping
- Asking targeted questions rather than dumping context
- Executing guidance step-by-step and reporting back, not just acknowledging

Training has two phases:
- Phase 1: supervised fine-tuning on trajectories where a strong model demonstrates when and how to ask for help
- Phase 2: reinforcement learning that penalizes looping and rewards genuine follow-through on expert advice

👉 THE RESULTS

SWE-Protégé-7B reaches 42.4% on SWE-bench Verified — +25.4% over the previous best 7B model, and it even edges past the best open-weight 32B model (40.2%).

Efficiency highlights:
- Only ~4 expert calls per task on average
- Expert tokens are just 11% of total tokens
- Up to 8.2x cheaper than running the expert model alone
- Mean trajectory length drops from 60 steps to 20 after RL
- Looping drops from 31% of trajectories to under 1%

All with minimal compute: 5K SFT trajectories, then 100 tasks and 160 RL steps on a single 8-GPU node.

WHAT I FIND MOST INTERESTING

Ablations show that simply injecting expert calls into trajectories fails — performance drops below baseline. The model must experience coherent multi-turn collaboration to learn from it. Passive strategies (fixed-interval or random expert calls) also underperform the learned policy. The model truly learns when help is valuable.

Broader takeaway: as frontier-model tokens become a constrained resource (cost, rate limits, quotas), training smaller models to use those tokens wisely may matter more than trying to make them never need help.

Paper: "SWE-Protege: Learning to Selectively Collaborate With an Expert Unlocks Small Language Models as Software Engineering Agents" — Kon, Pradeep, Chen, Ellis, Hunt, Wang, Yang, Thompson (Meta, U of Michigan, Stanford).

SWE-Protégé

EdgeWhisper + Voxtral (Privacy-First Voice AI)

🎙️ I stopped sending my voice to the cloud. Here's why you should too.

Every time you use a cloud-based dictation tool, your voice — your actual voice — travels to a remote server. It gets processed. Stored. Logged. Maybe used to train someone else's model.

Your client conversations. Your medical notes. Your code reviews. Your private messages.

All of it. Uploaded. Every. Single. Time.

I built EdgeWhisper because I refused to accept that trade-off.

EdgeWhisper runs Voxtral Mini 4B from Mistral AI — entirely on your Mac.

No cloud. No servers. No accounts. No telemetry. Your audio never leaves your machine.

Here's what makes this different from tools like Wispr Flow ($10/mo, cloud-required):

→ 100% on-device AI. Voxtral Mini 4B runs locally via Apple's MLX framework on the Neural Engine. M1, M2, M3, M4 — all natively supported.

→ Open-source model. Voxtral is released under Apache 2.0 by Mistral AI. You can inspect every weight, every layer. No black box.

→ Works offline. Airplane mode? No Wi-Fi? Doesn't matter. After the initial 3 GB model download, you never need internet again.

→ Works in every app. VS Code, Slack, Terminal, Mail, Google Docs, iTerm2, Warp, JetBrains — if you can type there, EdgeWhisper works there. Including terminals, where most dictation tools fail.

→ Sub-500ms latency. No network round-trip means your words appear as fast as you speak them. Filler words ("um", "uh") are removed automatically.

→ 13 languages. English, French, German, Spanish, Italian, Portuguese, Dutch, Hindi, Arabic, and more. Automatic detection — switch mid-sentence.

→ HIPAA-ready by architecture. Since nothing ever leaves your device, there's nothing to protect on a server. Lawyers, clinicians, and consultants use EdgeWhisper without a BAA.


I'm a developer. I built this for developers, writers, lawyers, and anyone who values their privacy.

Your voice is the most personal data you own. It deserves better than someone else's cloud.

🔗 Try it free: https://edgewhisper.com

⬇️ Direct download: https://lnkd.in/e6mCW5AE

macOS 14+ · Apple Silicon · Powered by Voxtral from Mistral AI


Mistral AI

Mistral AI

Databricks: Can your AI agent actually do the work an analyst does every day?

Not solve a math olympiad. Not pass a bar exam. But open a hundred messy PDFs, find the right numbers across decades of reports, and compute a precise answer.

Turns out, even the best AI systems fail at this more than half the time.

👉 WHY THIS MATTERS

Most AI benchmarks test reasoning in a vacuum: give the model exact context, ask a clever question, grade the answer. Real enterprise work looks nothing like that.

A financial analyst digs through a massive archive, figures out which documents are relevant, reconciles numbers revised across reports, then performs careful calculations. No one hands you the answer page.

The gap between "scores 90% on benchmarks" and "can reliably do this job" is enormous. Until now, we lacked a good way to measure it.

👉 WHAT THEY BUILT

Databricks AI Research released OfficeQA Pro, a benchmark built on nearly 100 years of U.S. Treasury Bulletins: 89,000 pages, 26 million numerical values, scanned 1940s docs to modern PDFs.

133 questions mirror real analyst tasks. Some require data from 20+ pages across reports. Some need external lookups like historical CPI. Some need statistical analysis like linear regression.

Key results:
- Frontier models using only built-in knowledge: under 5%
- With web search: under 12%
- Best agent (Claude Opus 4.6) with full corpus access: 48.1%
- With oracle pages handed to the model: none exceed 67%

No model crosses 50% on the full retrieval task. These are not obscure trick questions — a numerically literate graduate could answer them given time and the right documents.

👉 WHAT ACTUALLY HELPS

The most surprising finding: document parsing quality matters more than model choice. Switching parsers shifted accuracy by up to 22 percentage points — sometimes more than upgrading the model.

Providing structured parsed documents instead of raw PDFs improved accuracy by 16% on average and made agents 4–9x faster.

Other useful findings:
- HTML table format slightly outperforms markdown for complex nested headers
- Combining keyword file search with contextual vector search beats either alone
- Test-time scaling via plurality voting helps weaker models more than strong ones
- Human annotators were slower AND less accurate than the best agents on this task

Persistent failure modes: agents grab the first plausible number instead of checking for revisions, misread scanned tables, struggle with charts, and make subtle formula errors that cascade through calculations.

This benchmark exposes a clear truth: the bottleneck for enterprise AI is not raw reasoning ability. It’s the full pipeline of parsing, retrieval, and precise grounded computation over messy, real documents.

If you’re building AI for document-heavy workflows, OfficeQA Pro is worth studying closely.

An Enterprise Benchmark for End-to-End Grounded Reasoning

Anthropic vs US/Gov: What happens when the U.S. government retaliates against an AI company for refusing to remove safety restrictions from its technology?

That question just moved from hypothetical to real.

👉 WHY THIS MATTERS

Anthropic has filed a 48-page federal lawsuit against 17 U.S. agencies and senior officials, including the Department of War, after President Trump directed every federal agency to "IMMEDIATELY CEASE all use of Anthropic's technology." The trigger: Anthropic refused to drop two usage restrictions on Claude — prohibitions on lethal autonomous warfare without human oversight and on mass surveillance of Americans.

The complaint alleges the government's response was not a routine contract dispute. It was punishment for speech.

👉 WHAT HAPPENED

The timeline is striking:

- Anthropic had been the Department of War's most widely deployed frontier AI model, the only one on classified systems.
- The Department demanded Anthropic replace its usage policy with blanket "all lawful use" terms.
- Anthropic agreed to nearly everything except the two restrictions it considered essential for safety.
- Secretary Hegseth publicly gave Anthropic an ultimatum: comply by 5:01 PM Friday or "pay a price."
- Anthropic's CEO said the company "cannot in good conscience accede."
- Within hours, the President posted a directive banning Anthropic across all federal agencies.
- The Secretary designated Anthropic a "Supply-Chain Risk to National Security" via social media.
- GSA terminated Anthropic's OneGov contract. Treasury, State, HHS, and others followed.

The complaint highlights a contradiction: the government labeled Claude a national security risk while continuing to use it in military operations, reportedly including air strikes with Claude-powered tools hours after the ban.

👉 LEGAL CLAIMS IN BRIEF

Anthropic raises five counts:

1. APA violation: The supply-chain-risk designation exceeds statutory authority and lacked required procedures.  
2. First Amendment retaliation: The government punished Anthropic for expressing views about AI safety limits.  
3. Ultra vires action: The Presidential directive lacks statutory or constitutional basis.  
4. Due Process violation: No notice, no hearing, no process before a government-wide blacklisting.  
5. APA sanctions prohibition: Agencies imposed penalties without delegated authority.

The First Amendment claim is especially notable. Anthropic frames its usage policy and public advocacy on safety as protected speech and cites officials calling the designation "ideological" and saying "there is no evidence of supply-chain risk."

Why it matters: this case sits at the intersection of AI governance, procurement power, and constitutional limits on executive retaliation. Its outcome will influence how technology companies set boundaries on state use of their products.

taplio

Raphaël MANSUY's Linkedin Analytics

Raphaël MANSUY

Performance ScoreRaphaël MANSUY's LinkedIn Performance

What is Raphaël talking about?

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

What is Raphaël talking about?

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)