Follow for Actionable tips, Best Resources and Daily content on Python, Data Science & Machine Learning. 🚀
Joined July 2022
- Tweets1.3K
- Following745
- Followers12.8K
- Likes5.1K
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.
Machine Learning Community ⭐️ retweeted
Turn your entire codebase into a queryable knowledge graph!
Graphify is an AI coding assistant skill that maps your entire project into a knowledge graph you can query. Works with Claude Code, Codex, Cursor, Gemini CLI, OpenCode, and 20+ more coding agents.
Type "/graphify ." and it processes everything in your project. Code across 36 languages, SQL schemas, shell scripts, docs, PDFs, images, and videos, all mapped into one graph. Processing happens locally, no API needed for code.
The output is three files. An interactive HTML visualization you can open in a browser. A Markdown report with key concepts, surprising connections, and suggested questions. And a JSON graph you can query directly.
Instead of grepping through files or hoping your AI finds the right context, you query the graph. "What connects auth to the database?" "Find the path between UserService and DatabasePool." The graph answers precisely because it has the full picture, not just what's in the context window.
Builds a Git hook for auto-rebuild on every commit so the graph stays current as the codebase changes. Pushes to Neo4j for team sharing via MCP server. Generates a PR dashboard showing graph impact before merge.
Key capabilities:
• Maps code, docs, PDFs, images, and videos into one knowledge graph
• 36 languages via tree-sitter, processed locally
• Works with Claude Code, Codex, Cursor, Gemini CLI, OpenCode, and 20+ agents
• Query the graph instead of grepping through files
• Auto-rebuild on commit via Git hook
• Neo4j and FalkorDB integration for team sharing
• PR dashboard with graph impact analysis
100% open source.
I've shared the link in the replies!
Machine Learning Community ⭐️ retweeted
For 25 years, Salesforce, SAP and enterprise software were built around one assumption: humans operate the software.
We’re changing that.
Introducing ERP•AI and Proto: business software built for agents, and an agent that operates business software.
Describe the system you need. ERP•AI builds it.
Then Proto takes over. It manages records, runs workflows and executes actions inside the software you just created.
This is Headless SaaS.
1: get ERP•AI
2: build your SaaS
3: post below
Best one wins a MacBook. First 100 decent entries get $100.
(a message from Steve Papa / founding team)
Machine Learning Community ⭐️ retweeted
AI agents shouldn’t need a fixed toolset for every task!
Most tool-using agents are still built around integrations chosen before the task even starts.
That works when you know exactly what the agent will need.
But once the same agent starts handling very different requests, a fixed toolset becomes limiting. You either expose too many tools upfront or keep adding new integrations every time the scope changes.
Apify MCP takes a different approach.
You connect the agent to one MCP server and describe the task in plain language.
From there, the agent can search the tool catalog, inspect the relevant Actor’s input and output schema, fill in the required parameters, run it, and get structured results back.
So if the task changes from finding local businesses to monitoring prices, collecting event data, or pulling website content, you don’t have to manually choose the tool first.
The agent figures out what capability it needs and finds the relevant Actor during the task.
The part I like here is how the tool discovery works without filling the model context with the entire catalog.
Apify MCP exposes only a small set of core tools. The specific Actor is discovered only when the agent needs it.
That gives you a cleaner loop:
Task → Discover the right tool → Run it → Get the result → Continue reasoning
As agents start working across more kinds of tasks, I think this pattern becomes much more useful than giving every agent a fixed set of tools from the start.
Machine Learning Community ⭐️ retweeted
A clean number off a bank statement means nothing if you cannot prove where it came from.
Pull the ending balance from a six-page statement and you still have a problem. A reviewer has to trust it, and a bare figure gives them nothing to check.
Agentic Document Extraction (ADE) closes that gap at the output.
ADE parses the statement and extracts every figure. Each value comes tied to the exact page and box it was read from.
On the sample stated below, ADE pulls 278 fields from six pages, including all 47 transactions in the register. Click any one in the output and it highlights on the page, right where it sits.
For anyone in a bank or an audit seat, that link is the whole point. The number and its source travel together, so a reviewer checks a value instead of hunting for it.
Run the bank sample yourself. Link in the comments.
Machine Learning Community ⭐️ retweeted
Red-teaming text-to-image models has an evaluation problem!
White Circle just released RISE, an automated red-teaming method for text-to-image models.
A lot of existing jailbreak methods look strong because of how success is measured. The paper shows that once outputs are re-evaluated with better-calibrated judges and human review, some previously high attack-success rates drop close to zero.
The other issue is exploration.
Most methods keep modifying individual jailbreak prompts, which often means they stay close to the same seed attacks.
RISE instead searches over reusable attack strategies that can generate different prompts across scenarios. An abliterated Qwen3-32B proposes and improves those strategies, while calibrated judges score whether the generated images actually violate the target policy.
That gives the red team two things at once: broader exploration and a stricter signal for whether an attack genuinely worked.
The authors test it against production text-to-image systems including DALL·E 3, Nano Banana 2, and GPT-Image-2, where RISE still finds human-verified failures after several previous methods fall close to zero.
The interesting part here is not just finding better jailbreaks.
It is making sure your red-teaming system is actually optimizing for real failures, not for weaknesses in the evaluator.
We are open-sourcing RISE, our red-teaming algorithm that breaks the safeguards of the latest image models from OpenAI, DeepMind, and others.
RISE uses readily available models like Qwen and Gemini Flash under the hood, with no additional training required.
Read more: whitecircle.com/research/bre…
Machine Learning Community ⭐️ retweeted
Claude Code and Codex are powerful, but the workflow is still personal!
The agent runs in one person’s environment, and the rest of the team usually sees the work only after that person brings it back.
Kylon adds a shared company harness around that workflow, so agents and people can work with the same context, tools, memory, and approvals.
The Kylon Mac app brings Claude Code and Codex into shared team rooms while they still run against your local repo, files, and existing setup.
Your team can talk to the agents directly, follow the work in the same thread, and approve what happens next.
Same coding agents. Different operating layer.
🤝 Paid partnership
Introducing Kylon: The first company harness for your humans, agents and tools.
Whether you’re using Codex, Claude, Devin, Hermes, Gemini CLI, OpenClaw, Muse, Instinct, Grok Bot, Dots, Perplexity Computer, Cursor, Antigravity, Microsoft Autopilot, Amp, Droid, Kiro, Cline, OpenCode, Replit Agent, Lovable, v0, Gmail, Slack, Apollo, Supabase, Apify, Treg, Neon, Vercel, Databricks, Novita, RadixArk, GitHub, Seedance, Fish Audio, Plaud, OpenRouter, Gemini, Google Sheets, TikTok Shop, Outlook, Google Drive, Instagram, Airtable, Google Calendar, Asana, HubSpot, Corgi, SharePoint, Google Tasks, Notion, Google Workspace, Telegram, LINE, Zoho Mail, Meta Ads, Google Search Console, Fathom, ClickUp, Reddit, Granola, Google Docs, OneDrive, tl;dv, Amplitude, Dropbox, YouTube, Ahrefs, Xero, HighLevel, Google Analytics, Google Slides, Monday, QuickBooks, ElevenLabs, Linear, PostHog, LinkedIn, Runway, Zoho Bigin, Stripe, Exa, Cal_com, Box, Google Meet, TikTok, Wise, Mercury, Deel, Replit, Resend, Zoom, Fireflies, Typeform, Canva, Facebook, Google Admin, Hostinger, Google Maps, Retell AI, UptimeRobot, Google Photos, Excel, Cloudflare, Beehiiv, Vapi, 1Password, RunPod, Unipile, Read AI, Figma, Microsoft Teams, Trello, Salesforce, Jira, Confluence, Miro, Coda, Todoist, Basecamp, Wrike, Zendesk, Intercom, Freshdesk, ServiceNow, Gorgias, Mailchimp, ActiveCampaign, MailerLite, SendGrid, Postmark, Customer_io, Gong, Clay, Greenhouse, FreshBooks, Zoho Books, Brex, Ramp, PandaDoc, Google Ads, Microsoft Ads, Pinterest Ads, Semrush, Moz, Mixpanel, Google Tag Manager, Microsoft Clarity, Tableau, Metabase, Snowflake, Google BigQuery, ClickHouse, Wix, Contentful, Sanity, Bubble, Make, GitLab, Bitbucket, Sentry, PagerDuty, Grafana, New Relic, Docker Hub, DigitalOcean, Render, Firebase, Prisma, Algolia, Cloudinary, LaunchDarkly, Postman, Midjourney, Veo, GPT-Image2, NanoBanana, Flux, Kling, MiniMax, Replicate, HuggingFace, DeepSeek, Mistral AI, Ollama, Firecrawl, Eventbrite, Webex, Toggl, Harvest, Tailscale, Mural, Discord, TickTick, Calendly, Attio, Higgsfield, Square, Wispr Flow, Readwise, Bright Data, Google Places, FastMoss, PageSpeed Insights, Kalodata, Cerebras, SerpApi, DataForSEO…
Kylon enables them to work better, together.
Machine Learning Community ⭐️ retweeted
Jev as a judge for LLM evals!
JevEval uses Jev as the judge for custom LLM evals instead of relying on another generative LLM for every evaluation.
The idea is pretty simple.
You define the exact decisions you want the evaluator to make, Jev evaluates each one and returns probabilities, and DeepEval uses those results to calculate the final score.
For example, with an AI agent you can evaluate the trace itself, checking whether the agent selected the right tools, followed the expected sequence of actions, and actually completed the task.
Jev handles those semantic judgments, while the scoring logic stays outside the model.
That is the main difference from a normal LLM-as-a-judge setup.
With a generative judge, the model often has to interpret the rubric, reason about the response, and generate the evaluation itself.
With JevEval, you define the decision structure upfront.
You can also assign different weights to different checks or use `strict_mode` when every requirement needs to pass.
So if one part of the agent workflow matters more than another, you can reflect that directly in the scoring logic instead of leaving the entire evaluation to the judge model.
Key capabilities:
- Evaluate agent outputs and traces with Jev
- Define custom checks as bounded decisions
- Use yes/no, score, and closed-choice questions
- Weight different checks or require all of them to pass
- Evaluate both single-turn outputs and multi-turn conversations
This is where Jev makes a lot of sense for evals.
If you already know what needs to be checked, you can define those decisions upfront, let Jev handle the semantic judgment, and keep the final scoring deterministic.
I’ve shared the DeepEval post in the comments.
Machine Learning Community ⭐️ retweeted
Decision models are starting to get serious at long context!
Nace just released Drex 2.0, a 35B-A3B MoE, with around 3B parameters active during inference.
Like Jev, Drex is built for bounded decisions instead of free-form generation. You give it some state and a set of possible outcomes, and it returns probabilities over those options.
What stands out in this release is how far they’re pushing that setup into longer inputs.
Drex 2.0 scores 61.0 on Nace’s Decision Index vs. 58.0 for Jev, and Nace reports up to 38% faster inference than Drex 1.5 on 32K–128K inputs.
The decision can still be small even when the context behind it is huge.
An agent might only need to decide whether to continue, stop, call a tool, or escalate. But making that decision correctly can depend on a long execution trace, a large document, or a lot of workflow history.
That is where long-context decision models become much more useful.
Introducing Drex 2.0 - our Fastest and Smartest Decision Model!
3B active parameters, super fast inference.
Try Drex 2.0: nace.ai/developers
• Up to 38% faster on 32K–128K inputs vs. Drex 1.5
• $0.06 per 1M input tokens
• Runs on @sgl_project
• $25 Sign Up Bonus
Day 0 support from @FireworksAI_HQ’s FireAttention
dedicated deployment.
Machine Learning Community ⭐️ retweeted
Build cross-app AI agents with a single MCP!
I built an AI agent that can discover and execute actions across different apps without wiring every integration upfront.
Under the hood, it uses Liner Actions MCP as the action layer. The agent connects to one MCP server, searches for the capability it needs at runtime, and executes the relevant action through the same connection.
So instead of connecting separate MCP servers for GitHub, Slack, Notion, and every other service, the agent can ask for the capability it needs only when the task requires it.
For example, if the user asks the agent to create a GitHub issue and then send that issue to Slack, the agent first searches for the GitHub action, executes it, takes the returned issue URL, then searches for the Slack action and uses that result in the next step.
The agent still decides what it needs to do next. Liner handles the discovery of the specific action, the connection to the underlying service, and the execution against that service.
That also means account connections can happen only when they are actually needed. If GitHub or Slack is not connected yet, the user can authenticate that service and the agent can continue the workflow without being directly connected to those MCP servers itself.
The main shift here is from giving an agent every tool upfront to letting it discover the exact action it needs at runtime.
Key capabilities:
- One MCP connection for actions across multiple apps
- Runtime discovery of the exact action needed for a task
- Cross-app workflows where one action can feed into the next
- Just-in-time account connection for services the agent needs
- Execution against the underlying app without exposing every integration directly to the agent
I've shared the link to the project in the next tweet!
