Follow for Actionable tips, Best Resources and Daily content on Python, Data Science & Machine Learning. 🚀
Joined July 2022
- Tweets1.3K
- Following743
- Followers12.8K
- Likes5.2K
Machine Learning Community ⭐️ retweeted
The next frontier for AI agents is scientific research!
Science’s Last Exam is a new benchmark designed to test whether an AI agent can carry out an entire research cycle on its own, not just solve isolated scientific problems.
Instead of giving the model a question with a known path to the answer, SLE gives it a research objective, the required tools and materials, and a limited computational budget.
From there, the agent has to decide what to do next.
It needs to formulate hypotheses, choose experiments, run computations, interpret the results, react when something fails, and decide whether the evidence is strong enough to support a final conclusion.
One of the tasks makes this especially clear.
The agent has to identify the lowest dose of an antithrombotic drug that can suppress dangerous blood clots without disrupting normal hemostasis.
That means it cannot simply find one dose that works once.
It has to test different dosing intervals, vessel geometries, blood-flow conditions, and pharmacological response profiles, then use each result to decide what experiment is worth running next.
Even after finding a workable regimen, it still has to ask whether the dose can be lowered further, whether the result holds under different conditions, and where the evidence stops being reliable.
Once the agent submits its final result, the answer is frozen and evaluated against hidden checks defined in advance by domain experts.
SLE also breaks the research process into individual capabilities such as hypothesis discovery, protocol planning, experiment observation, scientific computing, and scientific software operation, so it is possible to see not just whether an agent failed, but where it got stuck.
The initial release includes 50+ selected tasks across nine scientific disciplines, with researchers from 38 institutions contributing to task design and review in their personal capacities.
And the next step goes beyond simulation.
SLE is also building wet-lab tasks where AI-designed experimental protocols will be executed in real laboratories, with the resulting data sent back to the agent for another round of reasoning and experimentation.
That is where agent evaluation starts looking much closer to actual scientific research.
I’m incredibly proud to share what we’ve been building at the AItonomy Foundation: Science’s Last Exam (SLE). 🧪✨
Can AI do science? Instead of Q&A, we give agents actual research goals and real-world tools (lab data, software), then grade them against hidden expert checks.
Deeply grateful to the brilliant minds at 34 institutions (Harvard, MIT, Stanford, etc.) who helped craft 113 tasks across 9 disciplines. ❤️
The results? Science is hard. Of 8 frontier models, the best scored 37.5/100. On true end-to-end research? All scored 0. We have an exciting journey ahead! 🚀
(Claude Opus 5.5 & GPT-6 Astra coming soon—just clearing bio safeguards).
Everything opens Nov 6. 🗓️
🌐 sciences-last-exam.org
💻 github.com/Gen-Verse/Science…
🤗 huggingface.co/datasets/Gen-…
Thread below on how the exam works and where models break. 👇 (1/14)
#AGI #AIforScience #AIAgents #SciencesLastExam #OpenAI #Anthropic
Machine Learning Community ⭐️ retweeted
Modest intelligence is arriving faster than most people realize.
Today, we're open-sourcing TwIL-8B.
Just 8.8 billion parameters, yet approaching frontier-model scores on several difficult benchmarks:
• 93% of frontier performance on coding
• 92% on instruction following
• 90% on contest mathematics
All from a model small enough to run on your own hardware.
But the benchmarks aren't the most important part of this announcement.
For years, the AI industry has focused on building the most capable model, regardless of the cost required to run it.
I believe that equation is changing.
The next era of AI will be defined by the cost of completing work. Not simply the intelligence of the model, but how efficiently that intelligence can accomplish the task.
If a model with 8 billion parameters can reliably complete the same work as one with hundreds of billions, why pay for the larger model?
As smaller models become more capable, intelligence becomes something we can distribute, specialize, and run across the hardware we already own.
That's the future we're building at @thewebAI
TwIL-8B is available today. Open weights.
And this is just the first of several announcements we're making today.
HF Link: huggingface.co/webAI-Officia…
Machine Learning Community ⭐️ retweeted
NVIDIA Open-Sourced Auto Ontology, a Semantic Layer for AI Agents!
Auto Ontology is a Python framework for building semantic, graph-based reasoning layers over data.
AI agents can already query databases and retrieve documents.
The harder problem is making sure they understand what the data actually means.
A metric like “revenue” might be defined differently across two systems. The same customer can appear under different identifiers. A generated SQL query can be syntactically correct and still use the wrong business definition.
Auto Ontology is built for that layer in between.
It can build a semantic catalog over enterprise metadata so agents can reason about entities, metrics, relationships, lineage, and where trusted definitions come from.
The workflow is roughly:
Enterprise data + metadata
→ Auto Ontology
→ Semantic catalog / knowledge graph
→ AI agent
→ Grounded query + provenance
It can generate ontologies from existing metadata, connect to semantic models you already have, reconcile inconsistent definitions across systems, and expose that shared context through MCP, CLI, or API.
For structured data, it can also translate natural-language questions into SQL while validating the query against the ontology and certified definitions before returning the result.
So instead of an agent simply asking:
“How much revenue did we generate last month?”
it can understand which revenue definition to use, which tables contain the right data, how those entities relate, and where the final answer came from.
Auto Ontology currently supports relational sources including Databricks, Postgres, Snowflake, and DuckDB.
It also exposes an MCP server, which means agents can query the same semantic layer directly.
For enterprise agents, retrieval alone is not enough.
They also need a shared understanding of what the underlying data actually means.
100% open source.
I’ve shared the GitHub repo in the comments!
NVIDIA Open-Sources Auto Ontology, a Semantic Layer for AI Agents
Your boss asks the AI agent: "What was revenue last quarter?"
It answers in 3 seconds. Clean number. Nice chart.
But it used the wrong "revenue" column. 𝗡𝗼𝗯𝗼𝗱𝘆 𝗻𝗼𝘁𝗶𝗰𝗲𝘀.
That's the problem NVIDIA's new open-source library, Auto Ontology, goes after. Its README puts it plainly:
"…𝘢 𝘳𝘦𝘷𝘦𝘯𝘶𝘦 𝘮𝘦𝘵𝘳𝘪𝘤 𝘢𝘯𝘴𝘸𝘦𝘳𝘦𝘥 𝘧𝘢𝘴𝘵𝘦𝘳 𝘪𝘴 𝘸𝘰𝘳𝘵𝘩 𝘯𝘰𝘵𝘩𝘪𝘯𝘨 𝘪𝘧 𝘵𝘩𝘦 𝘯𝘶𝘮𝘣𝘦𝘳 𝘪𝘴 𝘸𝘳𝘰𝘯𝘨."
𝗪𝗵𝗮𝘁 𝗶𝘁 𝗶𝘀:
A "context layer" that sits between an AI agent and your database. It tells the agent where the data lives, what each field means, and whether to use it.
𝗛𝗼𝘄 𝗶𝘁 𝘄𝗼𝗿𝗸𝘀, 𝘀𝘁𝗲𝗽 𝗯𝘆 𝘀𝘁𝗲𝗽:
• 𝗗𝗶𝘀𝗰𝗼𝘃𝗲𝗿: it reads your database metadata and drafts an ontology, a map of business terms like "active customer"
• 𝗚𝗿𝗼𝘂𝗻𝗱: agents use those terms instead of guessing from raw table names
• 𝗩𝗮𝗹𝗶𝗱𝗮𝘁𝗲: it checks generated SQL against certified definitions
• 𝗘𝘅𝗽𝗼𝘀𝗲: agents reach it through MCP, a CLI or an API
• 𝗟𝗲𝗮𝗿𝗻: certified corrections go back into the map
𝗙𝗼𝗿 𝘂𝘀𝗲𝗿𝘀:
Ask a question, get 𝘁𝗵𝗲 𝗮𝗻𝘀𝘄𝗲𝗿, 𝘁𝗵𝗲 𝗦𝗤𝗟 𝗶𝘁 𝗿𝗮𝗻, 𝗮𝗻𝗱 𝘁𝗵𝗲 𝗿𝗼𝘄𝘀. You can check the work, not just trust it.
𝗙𝗼𝗿 𝗯𝘂𝗶𝗹𝗱𝗲𝗿𝘀:
• Apache 2.0, runs with Docker Compose or Helm
• Works with Databricks, Postgres, Snowflake and DuckDB
• Defaults to NVIDIA's Nemotron models, but 𝗮𝗻𝘆 𝗢𝗽𝗲𝗻𝗔𝗜-𝗰𝗼𝗺𝗽𝗮𝘁𝗶𝗯𝗹𝗲 𝗲𝗻𝗱𝗽𝗼𝗶𝗻𝘁 𝘄𝗼𝗿𝗸𝘀
• The MCP server has 𝟵 𝗿𝗲𝗮𝗱-𝗼𝗻𝗹𝘆 𝘁𝗼𝗼𝗹𝘀. There is deliberately no tool to browse raw tables, so agents must go through the business terms
𝗜𝘁 𝗯𝘂𝗶𝗹𝗱𝘀 𝗼𝗻 𝗲𝗮𝗿𝗹𝗶𝗲𝗿 𝘄𝗼𝗿𝗸:
• Cube and dbt MetricFlow: semantic layers you write by hand in code
• Wren AI: an open semantic layer for AI agents, with a context layer built partly by agents
• Snowflake's Semantic View Autopilot: also drafts semantic models with AI, but only for Snowflake
What's different here: 𝗼𝗽𝗲𝗻 𝘀𝗼𝘂𝗿𝗰𝗲, 𝘄𝗼𝗿𝗸𝘀 𝗮𝗰𝗿𝗼𝘀𝘀 𝗳𝗼𝘂𝗿 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲𝘀, 𝗮𝗻𝗱 𝗯𝘂𝗶𝗹𝘁 𝗳𝗼𝗿 𝗮𝗴𝗲𝗻𝘁𝘀 𝘁𝗵𝗿𝗼𝘂𝗴𝗵 𝗠𝗖𝗣.
𝗧𝗵𝗲 𝗵𝗼𝗻𝗲𝘀𝘁 𝗽𝗮𝗿𝘁:
• 𝗧𝗵𝗲 "𝟵𝟬% 𝗳𝗮𝘀𝘁𝗲𝗿" 𝗰𝗹𝗮𝗶𝗺 𝗶𝘀 𝗡𝗩𝗜𝗗𝗜𝗔'𝘀 𝗼𝘄𝗻 𝘁𝗲𝘀𝘁𝗶𝗻𝗴, with no baseline published
• 𝗡𝗼 𝗮𝗰𝗰𝘂𝗿𝗮𝗰𝘆 𝘀𝗰𝗼𝗿𝗲𝘀 𝗮𝗿𝗲 𝗽𝘂𝗯𝗹𝗶𝘀𝗵𝗲𝗱. NVIDIA ships an eval harness (BIRD, 1,534 questions) but no results
• That harness was tested with 𝗖𝗹𝗮𝘂𝗱𝗲 𝗢𝗽𝘂𝘀 𝟰.𝟴, 𝗻𝗼𝘁 𝗡𝗲𝗺𝗼𝘁𝗿𝗼𝗻
• 𝗪𝗶𝘁𝗵𝗼𝘂𝘁 𝗛𝗮𝘀𝗵𝗶𝗖𝗼𝗿𝗽 𝗩𝗮𝘂𝗹𝘁, 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲 𝗽𝗮𝘀𝘀𝘄𝗼𝗿𝗱𝘀 𝗮𝗿𝗲 𝘀𝘁𝗼𝗿𝗲𝗱 𝘂𝗻𝗲𝗻𝗰𝗿𝘆𝗽𝘁𝗲𝗱 in Postgres (per the README)
• It's young: 𝗮𝗯𝗼𝘂𝘁 𝟳𝟱𝟬 𝗚𝗶𝘁𝗛𝘂𝗯 𝘀𝘁𝗮𝗿𝘀, and NVIDIA isn't accepting outside contributions
𝗧𝗵𝗲 𝗯𝗶𝗴𝗴𝗲𝗿 𝗽𝗼𝗶𝗻𝘁: the hard part of AI analytics isn't writing SQL. 𝗜𝘁'𝘀 𝗮𝗴𝗿𝗲𝗲𝗶𝗻𝗴 𝗼𝗻 𝘄𝗵𝗮𝘁 𝘁𝗵𝗲 𝘄𝗼𝗿𝗱𝘀 𝗺𝗲𝗮𝗻.
GitHub: github.com/NVIDIA/auto-ontol…
Links in reply 👇
Machine Learning Community ⭐️ retweeted
Software correctness needs more than tests!
Tests can cover thousands or even millions of cases, but they still only tell you what happened for the executions you actually tested.
Formal verification goes further by defining properties the software must satisfy and mathematically proving that those properties hold across the program states covered by the proof.
GenProof is applying this to real-world software using AI-assisted proof generation with machine-checked formal verification.
They've found 300+ bugs across open-source software including Linux, OpenSSL, curl, and Redis. Some of those bugs had been there for decades. Some were even missed by Anthropic in their formal verification release.
The defensive side needs to get stronger as AI gets better at finding errors and exploring software at scale. Formal methods let us ask whether a specific property of the code can actually be proven correct.
GenProof is releasing QuickProof for verifying properties of C code: you write executable specs, AI agents generate proofs, and Coq checks them. The guarantee depends on the stated property, assumptions and proof boundary.
Worth digging into if you work on software reliability or security.
Today, we're launching @genproof: a research lab making formal methods accessible.
We found bugs in 100+ OSS projects, including 6 libraries “formally verified” by Anthropic. We’re also top-1 on the lean-eval leaderboard.
With our tools, you too can become a verifier: 🧵
Machine Learning Community ⭐️ retweeted
🚨 Huge news 🚨 today we are launching SIE Serverless - a managed inference product focused on small models. It’s useful for spiky workloads on 20+ task specific workloads across Search, OCR and Agentic execution.
Sign up for a $500 credits launch grant 👇
It’s powered by our open source inference engine that has received thousands of github stars in the last few months, battle-tested across finance, legal & tech. We believe that self-hosting is going to be critical given all the trust & security issues in AI, but practically there are always workloads where you’d like somebody else to deal with the GPU quota like synthetic data generation, evals, public research and beyond.
The team at Superlinked has been burning the midnight oil for months and I’m so proud of every single one of you - what a privilege to call you my team mates y’all!
We built it, now help us make some noise 🙌
A like, a comment or a repost would mean a lot! ❤️
Machine Learning Community ⭐️ retweeted
Inference speed is becoming a model benchmark of its own!
For a long time, most model comparisons focused on intelligence, context length, and price.
But as more workloads become agentic and iterative, generation speed starts to matter a lot more. A coding agent, research agent, or RL rollout may make many sequential model calls, so reducing the time for each generation can change the wall-clock time of the entire workflow.
That is why we are starting to see more teams push inference speed much harder.
Looking across the models in this chart, what stands out to me is how differently teams are approaching the same problem.
Some are pushing Flash-class models for low-latency workloads, like DeepSeek V4.1 Flash running on Fireworks at around 1,500 tokens/s. Others are getting much more aggressive with serving around much larger models, like Kimi K3 reaching around 850 tokens/s on NVIDIA Rubin NVL72.
Naive takes a different route. They’re claiming up to 2,000 tokens/s on a single request with Naive-N0.5-Flash in Ultrafast mode.
Behind that is NaiveRT, an inference runtime built specifically for the model, combining speculative decoding, fused kernels, and GPU-driven execution to push single-stream generation speed much further.
What makes this trend interesting is that tokens per second is no longer just an infrastructure number.
Once models sit inside coding agents, research agents, RL rollouts, and other iterative systems, generation latency directly affects how quickly the entire workflow finishes.
Model quality still matters first, but inference speed is becoming another dimension that is increasingly hard to ignore.
Introducing Naive-N0.5-Flash: Building Frontier AI with AI
🔹 309B MoE, 15.5B active: top-tier in coding, leading in AI R&D.
🔹 Native 1M context, no full-attention layers (hybrid SWA + DSA).
🔹 Inference runtime built by AI: up to 2,000 tok/s in Ultrafast mode.
Weights are open today under MIT license.
🔗 Tech blog: naive.ai/en/research/
🤗 Hugging Face: huggingface.co/NaiveAI/Naive…
💻 GitHub: github.com/NaiveAI-Labs/Naiv…
🌐 naive.ai/en/
Machine Learning Community ⭐️ retweeted
RAG system that skips HTML parsing entirely!
PixelRAG is an open-source visual RAG framework that renders documents as screenshots instead of parsing them into text.
Most RAG pipelines start by converting HTML to text. Tables flatten into unstructured rows. Charts disappear. Layout context is gone before the LLM ever sees it. The paper measured this directly: HTML-to-text conversion accounts for 36.6% of retrieval failures on SimpleQA.
PixelRAG skips that step entirely. It renders pages as screenshot tiles using Playwright, embeds those tiles with a fine-tuned Qwen3-VL-Embedding model, builds a FAISS index, and passes retrieved images directly to a VLM reader. No text abstraction in between.
Benchmarked across six datasets against the strongest text-based baselines:
- SimpleQA: 78.8% vs 71.6% (+7.1 points)
- NQ-Tables: 48.8% vs 42.5% (+6.3 points)
- EVQA: +15.5 points
- LiveVQA: +11.3 points
One honest caveat from the authors: this requires Qwen3-VL-4B class models or larger to see the benefit. Smaller models trail text retrieval. The authors also recommend using PixelRAG as an enhancement layer alongside existing text systems rather than a full replacement.
Ships with a pre-built Wikipedia index covering 8.28M articles across 28.1M screenshot tiles. A Claude Code plugin lets Claude take screenshots of any URL and reason over the visual content directly.
Key capabilities:
• Renders web pages, PDFs, and images as screenshot tiles via Playwright
• Fine-tuned Qwen3-VL-Embedding model for visual retrieval
• FAISS index for fast vector search
• Pre-built Wikipedia index: 8.28M articles, 28.1M tiles
• 3x token cost reduction via image compression
• Claude Code plugin for direct URL screenshot and visual reasoning
• LoRA fine-tuning support via pixelrag-train
100% open source.
I've shared the link in the replies!
Machine Learning Community ⭐️ retweeted
Your AI agent may not need a complex memory system!
A new paper called RAW-RAG tests something much simpler: keep the raw conversation history, retrieve the relevant parts, rerank them, and let the LLM reason over the original evidence.
No memory summarization, no graph construction, and no LLM-based memory extraction during ingestion.
The pipeline is basically:
Raw history → Dense retrieval → Reranking → Reader LLM
And surprisingly, that baseline ranks first among the compared memory systems in 6 out of 7 settings across LoCoMo, LongMemEval, MEME, and MemoryAgentBench.
In some settings, RAW-RAG beats the strongest compared agentic memory system by more than 5 points.
The interesting part is why.
Agentic memory systems usually transform conversations into cleaner memories: extract facts, update old information, summarize events, or organize them into graphs.
But every transformation creates another opportunity to lose information.
The paper finds that retrieving the right answer value alone is not always enough. The model may also need the temporal relationships, previous events, and dependency paths around that information to work out what is currently true.
Raw history preserves those relationships.
They even test giving the model complete access to transformed memory stores, and there is still a gap compared with the original raw evidence.
Another interesting result comes from memory mutation. In their tested Mem0 setup, disabling UPDATE and DELETE actually improved accuracy, suggesting that capable reader models can sometimes resolve changing state directly from the underlying history instead of relying on the memory system to maintain the “correct” state for them.
This doesn’t mean agentic memory is useless.
But if a complex memory architecture can’t beat retrieval + reranking over the raw history, that should probably be the baseline you beat before adding more memory machinery.
I’ve shared link to the paper in comments!
Machine Learning Community ⭐️ retweeted
Jev as a reviewer for OCR!
OpenBMB and ModelBest just released MiniCPM-OCR 1.0 for document parsing and MiniCPM-OCR Jev for reviewing the reliability of those outputs.
That second part is what I find more interesting.
OCR errors are often hard to catch once the output looks plausible. A number can be slightly wrong, a formula can be misread, or a table cell can shift, and the result can still look completely reasonable when it moves into the next step of the workflow.
MiniCPM-OCR Jev sits after the parser and evaluates how reliable those outputs are across text, formulas, and tables.
It does not rewrite or correct the OCR result.
Its job is to score the output and help decide which blocks can move forward and which ones should be sent for human review.
So the workflow becomes:
Document → Layout detection → OCR parser → Jev review → Human review where needed
On the parsing side, MiniCPM-OCR 1.0 is a 1.3B model that supports scanned documents, photographed pages, curved inputs, tilted documents, tables, formulas, and key information extraction.
OpenBMB reports 93.68 on Real5-OmniDocBench and 54.7 on OCRBench v2, while DSpark improves end-to-end throughput by 62% in their benchmark setup.
On the review side, MiniCPM-OCR Jev reaches 93.5 AUROC on their JevOCRBench, close to Qwen3.5-397B-A17B at 93.8 and above JEV-35B at 90.1 in the official evaluation.
The useful part here is that you no longer have to treat the whole OCR output as equally reliable.
You can review it block by block and route only the uncertain parts for another look.
I tested both models on my own documents to see how well Jev catches OCR outputs that look right but are actually wrong.
I’ve shared the GitHub repo below!
Machine Learning Community ⭐️ retweeted
RAG for decision models is here!
Parallel just launched the Decisions API, which combines live web search with bounded decision-making in a single call.
Decision models like Jev are useful when the output is small and structured: yes/no, one option from a list, a category, or a routing decision.
The problem is that those decisions are only as good as the context you give them.
If the answer depends on something that changed recently, or information that only exists on the web, the normal flow becomes retrieval first and decision second.
Parallel brings those two steps together.
You provide the state and the questions you want answered. The API searches the web, grounds the decision in what it finds, and returns the typed answer along with probability, confidence, and sources.
That makes it much more useful for agent workflows where a decision depends on current external information, research tasks where the model needs to verify something before choosing an outcome, or eval pipelines where the judgment needs grounding from the web.
It can also answer multiple questions against the same retrieved context in one request, instead of repeating the search for every decision.
So instead of:
Search → retrieve context → decision model → structured answer
you can make the grounded decision directly through one API.
I think this is a pretty natural extension of where decision models are going: bounded outputs are useful, but giving that decision layer access to the live web makes the set of problems it can handle much larger.
Introducing the Parallel Decisions API: the first web-grounded decisions engine.
Decision models like Jev can answer in an instant, but they lack the recency of current news. Now you can get both in a single call.
Decisions API is live today at $0.001 per request.
Try it with 5,000 free requests: platform.parallel.ai/play/de…
Here are some examples we've been experimenting with:
- Fact-check content (@Grok is this true?)
- Refresh stale banking records
- Classify companies and leads with fresh signals
- Backtest trading strategies
- Track competitor e-commerce inventory
Machine Learning Community ⭐️ retweeted
Long-document OCR has an attention problem!
Baidu just released Unlimited OCR 2, an open-source OCR model built around a new Sparse Reference Sliding Window Attention mechanism for parsing extremely long documents efficiently.
The problem is that normal attention gets increasingly expensive as the document grows. Every new page adds more visual tokens, more text tokens, and more history that the decoder may need to attend over.
Unlimited OCR 2 changes that with SR-SWA.
Instead of keeping all text-visual interactions active across the full document, SR-SWA compresses them into a fixed-size set of working references. In Baidu’s setup, that can be as small as 512 tokens.
Two parts make that possible.
Page Gate first decides which pages are actually relevant to the current decoding step.
Token Sieve then filters the visual tokens inside those pages, keeping only the references the decoder needs instead of repeatedly attending over everything it has already seen.
That keeps the working attention state bounded even when the document itself keeps growing.
So the document can move from dozens of pages to hundreds or thousands of pages without the per-step decoding cost growing at the same rate.
Baidu reports up to 7× faster per-step decoding than Full Attention and 5.6× faster than the previous R-SWA approach.
Its page-level chunking and KV-cache reuse also reduce peak KV-cache memory from 47 GB to 1.77 GB in the B=1 setup.
It also reaches 84.6 on MPDocBench and 77.1 on MarathonDocBench.
And this is not just a benchmark setup. They demonstrate parsing all seven Harry Potter books, more than 3,600 pages, and the entire Three-Body Problem trilogy in a single run.
The architecture is the interesting part here.
Instead of solving long-document OCR by simply increasing the context window, Unlimited OCR 2 changes what the decoder keeps paying attention to as the document grows.
100% open source.
I’ve shared the GitHub repo in the comments!
Machine Learning Community ⭐️ retweeted
Claude Code, Codex and Hermes can now work as a team!
BAND lets your local coding agents work together: they share context, hand off work, and unblock one another.
Normally, running multiple coding agents means running multiple separate sessions. Claude Code might handle the backend, Codex the frontend, and another agent reviews the work, but you still end up being the person carrying context between them.
BAND gives those agents a shared room around the task.
One agent can create the plan, split the work into tasks, and hand pieces off to other agents. Those agents can message each other directly, pass the context with the work, and keep the current state outside any single coding session.
Your coding sessions still run locally in the tools you already use. BAND sits around them as the coordination layer, so you can see what each agent is working on, what is blocked, and where a human decision is actually needed.
That also means the planner or reviewer does not have to disappear once implementation starts. They can stay in the same room while the work progresses and step back in when something changes.
Key capabilities:
- Shared context across coding agents
- Direct agent-to-agent messaging and handoffs
- Shared plans, tasks, and work ownership
- Local coding sessions with centralized visibility
- Human decisions and approvals inside the workflow
The interesting part here is that adding more coding agents is easy. Getting Claude Code, Codex, Hermes, or other agents to actually coordinate around the same task is the harder problem.
BAND is building that shared layer around them.
I’ve shared the link in the comments!
Machine Learning Community ⭐️ retweeted
Jev as a decision layer for LLM agents!
LLM agents make a lot of small decisions between the bigger reasoning steps: which tool to call, which argument to use, whether the task is done, or what should happen next.
JevAgentHarness explores what happens when those bounded decisions are shared with a much smaller decision model instead of sending every step back to the LLM.
The decision model returns probabilities over the available options. If its confidence is above a threshold learned from the agent’s own trajectories, the harness uses that decision directly. If confidence is too low, control goes back to the LLM.
But the paper found that standalone decision accuracy is not enough.
The model that performed best on isolated decision questions completed only 69.5% of full agent tasks. And when tool choices were delegated without fitting the confidence threshold, task success dropped by 19 points.
The reason is that agent decisions are sequential. One wrong tool call changes the state the agent sees next, so later decisions happen in situations the decision model may never have seen before.
To address that, the researchers trained AgentDecision-4B on the states agents actually reach, including states that appear after earlier mistakes, with Jev providing the decision targets.
That changes the harness from simply replacing LLM calls with a smaller model into a confidence-based control system where both models handle the decisions they are better suited for.
On tasks similar to its training distribution, the resulting 4B decision models reduced agent cost by 81.1–89% and made execution up to 2.5× faster without losing 3 or more points of task success.
And on shifted tasks, AgentDecision-4B reached 91.5% task success compared with 82% using Jev.
The broader takeaway is useful: if you want decision models inside agents, benchmark accuracy alone is not enough. You need to evaluate them inside the actual agent loop, on the states their own decisions create.
The harness, benchmark, training data, and models are open source.
I’ve shared the paper in the comments!
Machine Learning Community ⭐️ retweeted
Google open-sourced Harness²!
Harness² is a framework for recursively improving the harness around an agent while keeping the underlying model weights fixed.
The interesting part is that it does this at two different levels.
For the current task, Harness² uses a Propose → Probe → Compose loop. It proposes changes to the harness, runs those variants on the same task, compares how the executions behave, and then composes a better harness from that evidence.
That is the task-level recursion.
But the process does not reset after every task.
Harness² also keeps the harnesses it adopted and the lessons supported by execution evidence, then uses those to guide how future harnesses should be improved on new tasks.
That is the harnessing-level recursion.
So one loop improves the harness for the task in front of the agent.
The second loop improves how the system learns to build better harnesses over time.
The editable harness itself can include the system prompt, guardrails, memory, tool guidance, subagents, skills, scripts, and plugins.
You can also run the recursion in two ways:
Parallel recursion explores more candidate harnesses.
Sequential recursion carries the refined harness and accumulated evidence through multiple Propose → Probe → Compose steps.
Google reports that even a single Harness² step improved GLM-5 and Gemini 3.5 Flash across JobBench, LAB, and WorkBuddy-Bench, with larger task-level recursion budgets bringing further gains.
That is what makes Harness² more interesting than just another agent framework.
It is treating the harness itself as something that can be iteratively improved from execution evidence, both within a task and across tasks.
100% open source.
I’ve shared the GitHub repo in the comments!
Machine Learning Community ⭐️ retweeted
Reverse engineer any app with an AI agent!
REA gives coding agents the tools to inspect shipped software, understand how a feature works, and recreate that behavior in your own project even when you don’t have the original source code.
You can point your agent at an app or a specific feature and ask it to investigate how that behavior is implemented.
REA handles the reverse-engineering layer underneath. It can inspect native binaries, JavaScript and Electron apps, .NET applications, websites, and other packaged software, then return the evidence behind what it found.
The agent can follow that evidence across functions, imports, strings, modules, runtime behavior, and other parts of the application until it has enough context to explain how the feature actually works.
The useful part is what happens after that.
Your coding agent can take those findings and build a version of the same behavior for your own project, adapted to your stack and requirements.
So if you like how search, offline mode, sync, or another feature works inside an app, you can ask the agent to investigate that specific behavior instead of trying to infer everything from the UI.
REA also keeps the investigation evidence alongside its conclusions, so the agent can show why it believes something works a certain way instead of simply guessing.
And it doesn’t claim to magically recover the original source code. The goal is to understand the shipped software well enough to reconstruct the behavior.
Key capabilities:
- Inspect apps and features without access to the original source
- Reverse engineer native, JavaScript, Electron, .NET, and browser targets
- Trace how a feature works across functions, modules, imports, and runtime behavior
- Return evidence and limitations behind each conclusion
- Recreate the learned behavior inside your own project with a coding agent
REA works through both MCP and CLI, so tools like Claude Code, Codex, Cursor, and other coding agents can use the same reverse-engineering workflow directly.
100% open source.
Machine Learning Community ⭐️ retweeted
You need to own your own intelligence!
Not just access to a model, but the harness around it too: the context, the tools, the memory, and all the pieces around it.
That is the idea behind Distributed Cognition.
Instead of assuming superintelligence comes from one giant model controlled by one company, they are exploring a different path: multiple specialized models working together through the right communication and coordination layer.
That idea makes sense when you look at how human intelligence works too.
No single person knows everything. We specialize, communicate, share context, build on each other’s knowledge, and make better decisions collectively than any one person could alone.
The same principle could apply to AI.
One model might be strong at planning, another at coding, another at memory, another at verification, and another at a specific domain. The real intelligence then comes from how well those models coordinate, pass context, and make decisions together.
If intelligence becomes something you rely on every day, you should also have control over the harness, the memory, the tools, the routing, and how those models work together.
Distributed Cognition is building around that idea of collective intelligence rather than one model doing everything.
That is a much more interesting direction to me than simply making the next model bigger.
Today distributed cognition exits out of stealth with backing by Verdict Capital.
Our mission is to replicate humanity's collective intelligence.
Read more: dcog.com/research/our-impera…
Most of today's AI power is held in the hands of a few, who can choose what you're allowed to think and what you're permitted to do.
We stand on three substantially different foundational beliefs:
- You shouldn't ask permission for intelligence.
- Superintelligence will be a distributed collective.
- Humans are not meant to be relegated to a permanent underclass.
If we don't distribute intelligence, nobody will.
Machine Learning Community ⭐️ retweeted
Recursive self-improvement is coming to embodied agents!
SenseTime just open-sourced RoboRSI, a harness for embodied agents that uses execution feedback to improve how the agent behaves without changing the underlying model weights.
The idea is pretty simple: let the agent interact with a robot environment, collect the execution traces, failures, intermediate results, and recovery attempts, then use that experience to improve the harness around the model.
That harness includes the evaluation environment, tools, task context, and the policy used to decide what the robot should do next.
So instead of treating every failed robot task as a dead end, RoboRSI turns those failures into reusable experience for the next run.
The interesting part is that they also take this one step further.
SenseTime is releasing RoboRSI-27B-Preview, a 27B embodied model designed to internalize useful experience distilled from the RoboRSI harness back into the model itself.
That creates a two-level loop:
Improve the harness from execution feedback → distill useful experience → improve the model → run again
The results are already pretty strong. On RoboCasa365, success improves from 26.0% to 46.5% while token usage drops by 73%. On LIBERO-Pro, both direct System 2 control and System 2 working with System 1 achieve above 90% success.
The broader point is that embodied intelligence is starting to move beyond “can the model solve this task?” toward something much more practical: can the system learn from interaction, recover from failure, reuse experience, and get cheaper over time?
RoboRSI is 100% open source.
I’ve shared the GitHub repo in the comments!
We release the most comprehensive 𝗲𝗺𝗽𝗶𝗿𝗶𝗰𝗮𝗹 𝘀𝘁𝘂𝗱𝘆 𝗼𝗳 𝗚𝗣𝗧-𝟲-𝗔𝘀𝘁𝗿𝗮’𝘀 𝗲𝗺𝗯𝗼𝗱𝗶𝗲𝗱 𝗶𝗻𝘁𝗲𝗹𝗹𝗶𝗴𝗲𝗻𝗰𝗲 across 12 simulation benchmarks and 8 real-robot platforms, together with 𝗦𝗲𝗻𝘀𝗲𝗡𝗼𝘃𝗮-𝗥𝗼𝗯𝗼𝗥𝗦𝗜: an open-source harness framework and a 27B model that runs at ~1/50 the cost of GPT-6-Astra.
Here's what we found:
🔹 𝗧𝗵𝗲 𝗰𝗮𝗽𝗮𝗯𝗶𝗹𝗶𝘁𝘆 𝗰𝗲𝗶𝗹𝗶𝗻𝗴 𝗶𝘀 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗺𝘂𝗰𝗵 𝗵𝗶𝗴𝗵𝗲𝗿. Under a unified protocol (ICL + up to 10× the interaction budget), GPT-6-Astra achieves clear SOTA across all 12 benchmarks: RoboDojo: 27.6% at 1× → 81.9% at 10×, DexJoCo: 87.3% vs. 40.3% prior SOTA, while the LIBERO benchmarks are pushed to saturation.
🔹 𝗧𝗼𝗼 𝗺𝘂𝗰𝗵 𝗯𝘂𝗰𝗸 𝗳𝗼𝗿 𝘁𝗵𝗲 𝗯𝗮𝗻𝗴. Even a simple task like placing pens in a holder costs ~$55 in inference.
🔹 𝗧𝗵𝗲 𝘄𝗼𝗿𝗹𝗱 𝗱𝗼𝗲𝘀𝗻’𝘁 𝘄𝗮𝗶𝘁. Time matters as real robots overheat, and an egg burned while the model was still thinking.
Our takeaway: GPT-6-Astra has largely crossed the threshold of 𝗲𝗺𝗯𝗼𝗱𝗶𝗲𝗱 𝗰𝗼𝗺𝗽𝗲𝘁𝗲𝗻𝗰𝗲, but 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗮𝗹 𝗲𝗺𝗯𝗼𝗱𝗶𝗲𝗱 𝗶𝗻𝘁𝗲𝗹𝗹𝗶𝗴𝗲𝗻𝗰𝗲 is not here yet.
🌐 Project page: sensenova.ai/has-gpt-6-astra…
📄 Report: sensenova.ai/gpt-6/assets/do…
💻 Code & model: github.com/OpenSenseNova/Sen…
Machine Learning Community ⭐️ retweeted
Turn documents into Agent-Friendly data!
OXR is a 1.3B open-source document parsing model that turns PDFs and document images into structured Markdown or JSON.
Instead of extracting text alone, it recognizes 13 different document elements including tables, formulas, figures, code blocks, footnotes, and chemical structures, while preserving reading order and layout coordinates.
That makes the output much more useful for RAG and agents, where knowing what the text says is only one part of the problem. You also need to know what is a table, where a formula belongs, which caption maps to which figure, and how the document should actually be read.
The technical part I found interesting is how OXR was post-trained.
It uses a recursive self-improvement loop where OXR first parses unlabeled documents, then a general VLM reviews the outputs for errors and uncertainty.
Disagreement across multiple OXR rollouts helps surface uncertain examples, those failures are grouped by cause, and the VLM generates targeted training data for the next round.
So instead of manually labeling new data for every iteration, the model’s own parsing failures help decide what it should train on next.
The architecture is also different from the usual parsing pipeline.
Layout analysis stays independent and pluggable, while recognition and content-aware reading order run in parallel inside the main model. That means teams can replace the layout model for their own document structure without replacing the rest of OXR.
And the results are strong for a 1.3B model.
OXR ranks #1 on olmOCR-Bench, OmniDocBench, and DocParsingBench. In the reported 100-page speed test on a single RTX PRO 6000, OXR finished in about 101 seconds vs. 161 seconds for DeepSeek-OCR-2.
The full model is open source.
Machine Learning Community ⭐️ retweeted
I built a Deep Research Agent with Jev as the review layer!
Nemotron does the research, Tavily for the web search, and Jev decides whether the research is actually good enough to return.
The agent starts with a question, searches across multiple sources, and builds an initial answer from what it finds.
But instead of immediately sending that answer back, it passes the research to Jev.
Jev looks at the result as a decision problem: is the answer sufficiently supported, does it cover the original question, and is there enough evidence to stop researching?
If the answer is no, the agent gets another research pass.
So the workflow becomes:
Research → Draft → Jev Review → Research again if needed → Final answer
That separation is useful because the model doing the research doesn’t also get the final say on whether its own work is complete.
For the stack, I used Nemotron through Nebius Token Factory for the main model, Tavily for the web search, LangChain to run the research loop, and LangSmith to trace what happens across each step.
I built this while trying out the Nebius AI Builder Program.
What made sense for this project is that the program is built around this kind of stack: open models through Token Factory, retrieval with Tavily, orchestration with LangChain, observability with LangSmith, and other components that can be swapped independently instead of locking the whole agent into one setup.
The full project is open source.
I’ve shared the GitHub repo in the comments!
Machine Learning Community ⭐️ retweeted
Build document extraction pipelines for batch jobs and AI agents!
Document extraction has traditionally been a pretty deterministic workflow.
You know which documents need to be processed, what needs to be extracted, and when the job should run, so a CLI works well for batch jobs, scheduled scripts, and repeatable pipelines.
AI agents introduce a different execution pattern. The document might show up halfway through a task, and the agent needs to decide at runtime whether it should extract something from it before continuing with the rest of the workflow.
That is where MCP becomes useful. The extraction capability itself does not need to change, but the way it gets called does.
For example, you might use a CLI to process hundreds of invoices every night, while an agent could receive a single invoice during a conversation, call the extraction workflow through MCP, get the structured fields it needs, and continue with the task.
So CLI and MCP are not really competing interfaces for document extraction. One fits workflows where execution is known and repeatable, while the other fits cases where an agent needs to invoke the same kind of capability dynamically at runtime.
I’ve shared a session from Unstract in the comments where they’re walking through the same extraction project as a CLI batch job and through MCP for an agent workflow.
