Microsoft researchers built a way for AI agents to control computers more efficiently, cutting execution costs by roughly 50% in several benchmarks. 🖥️
The open-source project is called Hybrid Computer Use (HCU).
Developed by @MSFTResearch researchers, including @haoqingeric (Haoqing Wang), it addresses a limitation in how AI agents interact with desktop applications.
Most computer-use agents operate through screenshots, mouse movements, and keyboard inputs.
That's useful, but inefficient.
An AI might need several screenshots and clicks just to identify a button, open a menu, or change a setting.
HCU gives agents three different ways to interact with a computer.
🧠 Three interaction channels
▪️ Programmatic: Use code, shell commands, and file tools when direct automation is more efficient.
▪️ Semantic: Read accessibility information to understand buttons, windows, menus, and other interface elements.
▪️ Visual: Use screenshots and mouse or keyboard actions when graphical interaction is necessary.
The agent selects whichever approach makes sense for each step.
For example, instead of locating every spreadsheet cell visually, it could modify data programmatically, use accessibility information to navigate a dialog, and inspect the final result with a screenshot.
⚡ Why is this better?
HCU includes several optimizations:
▪️ Compact accessibility trees that avoid overwhelming the model with unnecessary information.
▪️ Batches of up to 64 actions in a single call.
▪️ State-change reports showing what actually changed after an interaction.
▪️ Safety checks that reject stale mouse coordinates or accessibility references when the desktop changes.
That last feature matters because AI agents can accidentally click the wrong control if the interface changes between observation and action.
📊 Benchmark results
In Microsoft's evaluations:
▪️ OSWorld 2.0: 72.37% Partial score with GPT-6 Astra, compared with 68.82% using the reference interface.
▪️ OSWorld 1.0: 70.13% versus 62.47%, with 59.1% lower execution cost in the highlighted GPT-5.4 configuration.
▪️ Windows Agent Arena: 80.86% versus 71.89%, at approximately half the cost.
▪️ MacAgentBench: 25 of 28 tasks completed, with 51.4% lower cost.
The improvements depend on the model, platform, and evaluation setup.
🔧 Availability
HCU is available as an MCP server, SDK, and CLI.
It supports Windows, macOS, and Linux, and can integrate with agents such as Claude Code, Codex, and Gemini CLI.
The implementation is open source under MIT.
The bigger implication: smarter computer-use agents may not need increasingly complicated screenshot-based reasoning.
Sometimes the best improvement is giving them better interfaces to the operating system.
🔗 github.com/microsoft/Hybrid-…
#MicrosoftResearch #AIAgents #ComputerUse #OpenSource
Researchers built an AI gaming commentator that can describe games it has never played or even seen before. 🎮
Meet StreamDuo, a two-agent system designed to provide live commentary across unfamiliar video games.
Developed by researchers from Alaya Lab, the University of Tokyo, Georgia Tech, and other institutions, it addresses a problem with current AI commentators.
They can learn when to speak, but they frequently struggle to understand what's actually happening in a new game.
An AI trained on Baldur's Gate 3 might watch Zelda and start confusing its characters with those from Baldur's Gate.
StreamDuo solves this by giving the commentator a research assistant.
🧠 Two agents working together
▪️ Commentator: Watches gameplay continuously, describes events, and decides when additional information is needed.
▪️ Research agent: Examines selected frames, searches the relevant game's wiki, and returns useful information.
The commentator doesn't stop speaking while the research happens.
Instead, it continues watching the game and receives the research results approximately two seconds later.
Imagine an AI watching The Legend of Zelda: Tears of the Kingdom.
It encounters an unfamiliar character but doesn't know their name.
Rather than guessing, it asks the research agent to investigate the character using the current video frames.
The assistant searches the game's wiki and identifies the character, allowing the commentator to continue with more accurate information.
🔧 How is it trained?
The researchers use two techniques:
▪️ Information-gain-guided querying: Teach the commentator when asking a question would actually improve its narration.
▪️ On-policy self-distillation: Teach it to use imperfect retrieved information effectively.
Only the commentator is trained. The research agent remains frozen.
📊 The experiment
The system was trained exclusively on Baldur's Gate 3 and then evaluated on 2,470 clips from ten unseen games.
Compared with a retrained Proact-VL baseline:
▪️ Entity recall improved from 0.082 to 0.116.
▪️ Incorrect references to the training game dropped from 9.9% to 1.0%.
▪️ The system received stronger evaluations for timing, liveliness, and overall commentary quality.
These are research-benchmark results, not evidence that the system is ready to replace professional commentators.
🎥 You can watch the comparison
The researchers published an interactive demonstration comparing StreamDuo against a conventional AI commentator on Zelda gameplay.
You can follow the video and inspect exactly when the research agent provides information.
The implementation is also available on GitHub.
The bigger idea: AI doesn't need to memorize every possible environment.
It can learn when its knowledge is insufficient, research what's missing, and incorporate that information without interrupting its work.
That principle could extend far beyond video games.
🔗 Demo: zixiangao.github.io/StreamDu…
🔗 GitHub: github.com/ZixianGao/StreamD…
#GamingAI #AIAgents #MultimodalAI #AIResearch
Researchers have found a way to edit the same AI-generated image 20 times without everything slowly falling apart. 🎨
It's called TailSteer, a new training technique from researchers at CUHK, SenseTime Research, and Shanghai AI Laboratory.
It tackles one of the most frustrating problems in AI image editing: visual drift.
You generate an image, change someone's clothes, adjust the background, add an object, and modify the lighting.
After several edits, the character's face has changed, small details have disappeared, and the original composition looks increasingly different.
Even if every individual edit appears successful, the accumulated errors eventually become obvious.
🧠 TailSteer approaches the problem differently.
Instead of retraining an entire image model from scratch, it introduces an additional training stage focused on the final part of the diffusion process.
▪️ Early denoising steps: Preserve the original model's learned generation behavior.
▪️ Later steps: Learn corrections that protect image content that wasn't supposed to change.
▪️ Training: Use the model's own editing trajectories rather than requiring manually curated ground-truth image pairs.
▪️ Inference: Continue using the original model architecture and sampling pipeline.
The goal is to improve consistency across long editing sessions without sacrificing normal image-generation quality.
📊 The results are impressive
Researchers tested TailSteer on several image-model families, including:
▪️ FLUX.2 Klein Base 9B
▪️ Qwen-Image-2.1
▪️ SenseNova-U1.5-8B-MoT
In one benchmark involving ten consecutive edits, FLUX.2's image-preservation SSIM increased from 0.289 to 0.621.
Its PSNR improved from 13.85 to 19.96.
The team also demonstrated 20 consecutive pose-guided edits, showing how the same character can follow changing poses while retaining more of its original appearance.
Importantly, single-turn editing and text-to-image performance remain broadly similar to the original models, although some individual benchmarks decline.
🚀 Can you try it?
Yes. The researchers released:
▪️ Training and inference code.
▪️ Model checkpoints on Hugging Face.
▪️ Evaluation datasets and reproduction instructions.
▪️ Interactive comparisons and long editing sequences.
The repository is Apache 2.0 licensed, while individual model weights retain their respective usage conditions.
Why this matters
AI image editing is becoming less about generating a perfect image in one attempt and more about gradually refining something through conversation.
For that workflow to become reliable, models need to remember what should stay unchanged.
TailSteer is an interesting step toward making iterative AI editing much more predictable.
🔗 Project: lyricccco.github.io/tailstee…
🔗 GitHub: github.com/Lyricccco/tailste…
#AIImageEditing #GenerativeAI #OpenSource #AIResearch
NVIDIA researchers found a way to make AI predict physical motion up to 25× faster, while actually improving accuracy. 🤖
The new research is called VFlash, and it addresses a major bottleneck in robotics and autonomous driving: AI models are often too slow at generating detailed movement plans.
Most vision-language models predict coordinates one token at a time.
But a robot planning how to grasp an object or move its arm doesn't necessarily need to generate thousands of coordinate tokens sequentially.
VFlash predicts entire geometric structures in parallel.
🧠 How does it work?
Researchers at @nvidia developed a technique called Flash Primitive Decoding.
Instead of generating every coordinate independently, a lightweight drafting model predicts complete visual primitives in a single forward pass.
These can include:
▪️ 2D and 3D trajectories: Predicting where a robot's arm or an object will move.
▪️ Bounding boxes: Locating objects in camera images.
▪️ Dense motion: Forecasting how points across a scene will move.
▪️ Text instructions: Maintaining conventional language planning alongside spatial predictions.
The method adapts its decoding strategy to the type and structure of each output.
⚡ The performance improvements are substantial
According to NVIDIA's evaluations:
▪️ Approximately 25× faster single-rollout dense 3D motion generation on an H100 GPU.
▪️ 42.6% lower average 3D trajectory displacement error across the evaluated robot settings.
▪️ 5× faster overall robot inference on Jetson Thor.
▪️ Up to 49× faster driving-plan decoding in certain DGX Spark benchmarks.
▪️ 70.2% task success across four MolmoSpaces robot suites, compared with 62.6% for the baseline.
These are task-specific research results, not a universal 25× speedup for every robotics system.
🚗 Why does this matter?
Autonomous systems need to continuously understand their surroundings, predict what might happen next, and update their actions.
When generating a detailed motion plan takes too long, the environment may have already changed.
VFlash makes visual planning significantly less expensive by exploiting the geometry of the problem rather than treating every coordinate like ordinary text.
The technique has been evaluated on robot manipulation, object localization, dense motion forecasting, and autonomous-driving tasks.
The researchers have published the paper, implementation, and technical demonstrations.
The bigger shift: AI systems don't always need to think in words.
For robots operating in the physical world, predicting geometry directly may be a much more efficient form of intelligence.
🔗 research.nvidia.com/labs/lpr…
#NVIDIA #Robotics #PhysicalAI #AIResearch
A developer just built a free AI video engine that claims to render complex scenes up to 20× faster than Remotion and Hyperframes. 🚀
And it doesn't need a browser.
Developer @shinyobjectz_ (Shane Murphy) has released Raea, the Render Anything Engine, a GPU-powered rendering system built with Rust, @BevyEngine, React, and TypeScript.
The idea is to let AI coding agents create videos, motion graphics, 3D environments, games, and sound using code, then render everything locally.
⚡ Why is it potentially so fast?
Traditional browser-based workflows often render video by generating individual frames through Chromium or Playwright.
Raea takes a different approach.
▪️ React and TypeScript describe the composition.
▪️ Bevy handles rendering directly on the GPU.
▪️ Blitz DOM provides browser-free layout capabilities.
▪️ GPU compositing and hardware encoding handle the final output.
The developer claims 10–20× faster rendering for complex scenes and projects containing real footage compared with Remotion and Hyperframes.
Those numbers are developer-reported, not independently verified benchmarks.
As another example, the documentation reports rendering a 90-frame, 1080p animation in approximately one second on an Apple Silicon Mac.
🎬 What can you actually create?
▪️ Videos and motion graphics: Animated typography, transitions, SVG graphics, and footage-based editing.
▪️ 3D scenes: Cameras, lighting, materials, glTF models, and Gaussian splats.
▪️ Interactive games: Physics, user input, sound, and real-time gameplay.
▪️ Music and audio: Sound effects, instruments, audio mixing, and local synthesis tools.
▪️ Automated video editing: Cut footage based on spoken words rather than fixed timestamps.
🤖 Built for Claude Code and AI agents
Raea includes dedicated agent skills and a Claude Code plugin.
An agent can write a composition, render a preview, inspect individual frames, identify problems, modify the code, and render again.
The raea check command can detect issues such as clipped text, low contrast, unsafe areas, frozen frames, and audio loudness problems.
🔧 Availability
▪️ macOS with Apple Silicon.
▪️ Linux x86_64.
▪️ Windows x86_64, currently the least-tested platform.
▪️ Free local rendering with no account or per-render fees.
▪️ Source available under FSL-1.1, which restricts competing products and converts each version to Apache 2.0 after two years.
The project is still in its canary stage, so breaking changes and incomplete documentation are expected.
One distinction worth making: Raea isn't a diffusion-based text-to-video model. AI writes the code, while Raea renders the resulting scenes and animations.
The bigger opportunity?
If rendering becomes fast enough, AI agents can stop delivering a video and hoping it looks right.
They can actually inspect their work, fix mistakes, and iterate repeatedly.
That could make AI-assisted video production much more practical.
🔗 GitHub: github.com/shinyobjectz/raea
🔗 Website: raea.io/
#AIVideo #ClaudeCode #OpenSource #Rust #AIAgents
Your next mobile app could look like it cost $20,000 to design, without hiring a designer. 👀
Meet ExpoKit, an open-source UI library for Expo and React Native that brings polished animations, interactive components, and ready-made interfaces to mobile development.
Built by solo developer @itsmeekaran, the project @expo_kit follows a familiar idea from shadcn/ui: copy the components into your project and own the code.
No mysterious black-box UI library. You can inspect, customize, and modify everything.
🎨 What's inside?
The catalog currently includes:
▪️ 73 UI components with 340+ live variants.
▪️ 44 chart types, including interactive line charts, animated donuts, gauges, heatmaps, and dashboards.
▪️ 12 complete screens for authentication, checkout, settings, messaging, and more.
▪️ 4 app templates for quickly starting larger projects.
▪️ Animated buttons, floating inputs, OTP fields, bottom sheets, swipeable cards, navigation elements, and loading indicators.
▪️ 3D effects and iOS-style Liquid Glass interfaces.
Everything is designed for touch interactions, with smooth animations, gestures, and responsive feedback.
⚡ Installation takes two commands
Inside an existing Expo project:
npx @expokit/cli@latest init
Then install the components you need:
npx @expokit/cli@latest add button otp-input
The CLI copies the actual TypeScript source files into your project, where you can edit them directly.
🧠 There's even AI integration
ExpoKit includes an MCP server and Claude Code plugin, allowing AI coding assistants to discover components, understand their properties, and add them to your application.
That means developers using Claude Code, Cursor, or Codex can incorporate ExpoKit into their AI-assisted development workflows.
📱 Platform support
▪️ iOS, Android, and web.
▪️ Expo SDK 55+.
▪️ Works inside Expo Go without custom native modules.
▪️ Light and dark themes.
▪️ Centralized customization through KitProvider.
▪️ Accessibility support for VoiceOver and TalkBack.
💰 Is it actually free?
The core component collection, CLI, and expo-charts library are free and MIT-licensed, including commercial use.
However, premium 3D animations, advanced components, complete screens, and app templates require a one-time ExpoKit Pro purchase.
Why this matters
AI coding tools can generate entire applications in minutes, but getting the interface to feel genuinely polished still takes significant effort.
ExpoKit gives developers and vibe coders a collection of reusable, production-oriented UI building blocks instead of forcing them to reinvent every button, animation, and navigation pattern.
And because you own the source code, customization doesn't stop at the options exposed by a library.
🔗 GitHub: github.com/ExpoKit/ExpoKit
🔗 Live component gallery: expokit.in/
#ReactNative #Expo #OpenSource #VibeCoding
Vibe coding has a problem: you can build an entire app with AI and still have no idea how it actually works.
An open-source tool called Floorplan is trying to fix that.
Created by Hayden Smith, Floorplan works with Claude Code and OpenAI Codex to turn an existing codebase into an interactive, explorable architecture map.
Instead of staring at hundreds of files, you can see how your application fits together, from frontend screens to backend endpoints and external services.
🗺️ What does it actually show?
▪️ Components, files, routes, and their relationships.
▪️ How frontend requests connect to backend endpoints, even across multiple repositories.
▪️ Databases, external integrations, and application dependencies.
▪️ Which files are responsible for particular features.
▪️ Recent changes made by your coding agent.
Everything gets a plain-English explanation rather than just technical filenames.
💬 You can also ask questions
For example:
What happens when someone places an order?
Which files handle user authentication?
If I change this database table, what might break?
Floorplan can trace the relevant components and display a focused map of the process.
🔍 There's also a Health Check
The tool can look for common problems in AI-built applications:
▪️ API keys exposed in frontend code.
▪️ Supabase tables with missing or overly permissive security rules.
▪️ Firebase configurations that allow unintended access.
▪️ Stripe webhooks without signature verification.
▪️ Backend endpoints missing authentication checks.
These are automated checks, not a substitute for a full security audit.
⚡ Other useful features
▪️ Automatically refreshes the map after code changes.
▪️ Highlights recent modifications and their purpose.
▪️ Generates architecture blueprints from a PRD before you write code.
▪️ Exports a standalone HTML map for sharing.
▪️ Supports JavaScript, TypeScript, Python, Go, Rust, Java, Kotlin, and other languages.
▪️ Works locally, with its map and server running on your computer.
The AI analysis still uses your connected Claude or Codex account, so code processed by those assistants remains subject to their normal data handling.
💰 Free and open source
Floorplan is MIT-licensed and works with existing Claude Code or ChatGPT/Codex access without requiring a separate API key.
You'll need Node.js 18+.
Why this matters
AI coding tools are making software creation accessible to more people, but understanding and maintaining that software remains difficult.
Floorplan attempts to close the gap between "I built it with AI" and "I actually understand what I built."
You can try an interactive demo without installing anything.
🔗 GitHub: github.com/haydenschmitty/fl…
🔗 Live demo: haydenschmitty.github.io/flo…
#VibeCoding #ClaudeCode #Codex #OpenSource
This free Claude Code skill can turn a reference image into an interactive 3D machine you can take apart. 🤯
Developer @elvar_official has open-sourced Teardown, a skill that guides Claude through building detailed, animated 3D simulators entirely from code.
No Blender modeling required.
The result isn't just a rotating 3D object. It's an interactive experience with moving mechanisms, detachable components, live gauges, technical explanations, and optional cinematic walkthroughs.
⚙️ What can you build?
The repository includes examples involving:
▪️ A working V8 engine.
▪️ A Cessna landing gear mechanism.
▪️ A Strandbeest walking machine.
The creator has also demonstrated robotic creatures with articulated limbs and detailed internal components.
You can ask Claude something like:
Build me a simulator of a four-stroke motorcycle engine that I can take apart.
The skill then provides a structured workflow for generating the simulation.
🧠 How it works
▪️ Reference-driven modeling: Start with a visual reference rather than relying entirely on imagined geometry.
▪️ Procedural 3D: Generate parts, materials, and mechanisms using Three.js.
▪️ Shared simulation logic: Make moving components, gauges, and explanatory panels follow the same underlying state.
▪️ Interactive disassembly: Rotate the camera, isolate subsystems, and examine individual mechanical parts.
▪️ Automated visual review: Render frames, inspect the output, identify inconsistencies, and revise the scene.
▪️ Video production: Capture animations frame by frame and produce 60 FPS video with optional sound effects.
The finished simulator can be bundled into a single self-contained HTML file, with its assets embedded.
That makes it possible to run the experience offline or share it without a complicated deployment pipeline.
🚀 Try it yourself
Install the skill with:
npx skills add elvarofficial/teardown -g -a claude-code
You'll need Node.js 20+, with additional setup for Chromium-based rendering. FFmpeg is needed for video output, and Python 3 for sound generation.
The repository is MIT-licensed.
One important distinction: these are code-generated educational visualizations, not automatically validated engineering simulations. Mechanical accuracy still depends on the model and its implementation.
But as a way to explain how machines work, prototype interactive educational content, or build animated technical demonstrations, this is a fascinating application of coding agents.
And you can explore the creator's examples directly in your browser.
🔗 GitHub: github.com/elvarofficial/tea…
🔗 Interactive demos: visual-learning.app/
#ClaudeCode #ThreeJS #GenerativeAI #OpenSource
Kakao just released an AI model that doesn't generate text. It makes decisions instead, and it's remarkably fast. ⚡
The South Korean technology company has open-released Kanana-2-v-decide, a 3.67B-parameter multimodal model designed specifically for decision-making inside AI agents.
While conventional LLMs generate answers token by token, Kanana returns structured probabilities, classifications, and scores.
The idea is simple: not every AI task needs a conversation. Sometimes you just need a decision.
🧠 Three types of decisions
▪️ Noul: Answer a yes/no question with a probability.
▪️ Choice: Select an answer from multiple candidates, returning probabilities for each.
▪️ Score: Evaluate something on an ordered scale.
Imagine an AI customer-support agent receiving a message and a photo of a damaged product.
Instead of asking a large language model to write a paragraph explaining the situation, Kanana can determine:
▪️ Whether the product is damaged.
▪️ Which support category the request belongs to.
▪️ How negative or positive the customer's sentiment is.
The application can immediately use those results to decide what happens next.
🔧 How does it work?
Kanana uses an embedding-based architecture.
It converts the input and question into a vector, creates separate representations for candidate answers, and compares them using cosine similarity.
That makes several things possible:
▪️ No fixed limit on the number of classification options.
▪️ Candidate order doesn't determine how the options are represented.
▪️ Previously calculated answer embeddings can be cached and reused.
▪️ Multiple questions can be evaluated in one request.
📊 Specifications and performance
▪️ 3.67B parameters, including a 3.18B language model and 490M vision encoder.
▪️ Text, JSON, conversation histories, and image inputs.
▪️ Up to 10 images and a 20,480-token context.
▪️ 2,560-dimensional embeddings.
▪️ Average score of 61.23 across two public Decision Index benchmarks in Kakao's comparison.
Kakao also reports approximately 42 ms per decision on one NVIDIA H200 GPU, around 43 times faster than GPT-6 Luna in its specific evaluation setup.
That comparison is task-dependent, not evidence that Kanana is generally smarter or faster at every workload.
Why this matters
AI agents repeatedly choose which tools to call, how to route requests, and whether certain conditions are satisfied.
Using large generative models for every small decision can introduce unnecessary latency and expense.
Specialized decision models offer an alternative.
The weights are available on Hugging Face under the Kanana Open License, which permits commercial use subject to its terms.
🔗 huggingface.co/kakaocorp/kan…
#OpenSourceAI #AIAgents #MachineLearning #MultimodalAI
Game NPCs can now listen to your voice, respond naturally, and interact with the game world. 🎮
ElevenLabs has released the ElevenAgents Unity SDK, making it easier for developers to add conversational AI characters directly into Unity games.
The release was announced by @ElevenLabsDevs, with a technical walkthrough from developer advocate @tadaspetra.
The interesting part isn't just giving characters realistic AI voices.
NPCs can receive information about what's happening in the game and trigger actual gameplay actions.
🎙️ How does it work?
Imagine walking up to a character in a game.
▪️ Enter the character's interaction zone and a voice conversation starts automatically.
▪️ Speak into your microphone and the NPC responds using an ElevenLabs voice agent.
▪️ Walk away and the conversation ends.
▪️ Give the character different personality settings, moods, and voices through dynamic variables.
The SDK uses Unity's Conversation API to manage interactions.
🧠 Characters that understand context
Developers can send contextual updates during a conversation without interrupting the player.
For example:
The player picked up the cellar key.
The agent can incorporate that information into its next response.
Even more interesting, client tools allow agents to execute game functions.
A developer could register an open_door tool that lets an NPC open a specific door when the conversation calls for it.
That creates opportunities for interactive quests, voice-controlled companions, dynamic dialogue systems, and more responsive game characters.
⚙️ Technical details
▪️ Spatial audio through Unity's AudioSource.
▪️ Dynamic variables and per-session voice overrides.
▪️ Audio-volume data for character mouth or body animations.
▪️ Conversation events for transcripts, responses, and interruptions.
▪️ WebSocket and WebRTC transport options, depending on platform.
▪️ Support for Unity Editor, Windows, macOS, Linux, and WebGL.
▪️ iOS, Android, and XR support currently in beta.
The SDK targets Unity 6.3 LTS and includes a GettingStarted sample that the team says takes around 10 minutes to complete.
One important implementation detail: production games should use authenticated sessions and server-generated signed URLs rather than shipping private API keys inside the game.
Why this matters
Traditional NPC dialogue usually relies on predefined conversation trees.
This approach gives developers a way to connect voice interaction, changing game state, and executable actions through one system.
It won't automatically create intelligent characters or good game design, but it makes building more reactive NPC interactions significantly more accessible.
🔗 github.com/elevenlabs/unity
#ElevenLabs #GameDevelopment #Unity3D #AIAgents
Someone built an open-source tool that can study almost any software and then use AI to recreate it. 👀
It's called Craft Anything, and the idea is surprisingly ambitious: point it at a website, desktop app, mobile app, or game, describe what you want, and let an AI coding agent investigate, rebuild, and verify the result.
The project is developed by the ArtCraft team, with its latest v0.5.0 release arriving on November 6.
🔍 How does it work?
Craft Anything follows a four-stage workflow:
▪️ Study: Inspect the original software, including its visible interface, layout, interactions, and behavior.
▪️ Build: Have a coding agent implement a new version using your chosen language, framework, or game engine.
▪️ Check: Compare the generated project against the original, identify differences, and test what needs improvement.
▪️ Refine: Fix the mismatches and repeat until the result is ready to preview.
For websites, the system can compare layouts at three different screen widths.
For games, the project supports reconstruction workflows involving Unity, Unreal Engine, and Godot.
🛠️ What's under the hood?
▪️ Written primarily in Rust.
▪️ 320 inspection and automation tools, accessible through CLI commands and MCP.
▪️ Desktop interface with Simple and Advanced modes.
▪️ Clean-room mode that studies externally visible behavior without reading internal source code.
▪️ Optional Deep mode with binary inspection and Ghidra integration.
▪️ Local project files containing captured evidence, generated code, comparison results, and agent history.
▪️ Available for Windows, macOS, Linux, and FreeBSD.
The most interesting feature is verification.
Instead of trusting an AI agent that claims its recreation is finished, Craft Anything attempts to measure how closely the new implementation matches the original.
However, this is still early alpha software. The Claude Code workflow is the best-tested path, while other coding-agent integrations and some behavioral checks remain experimental.
It's also intended for software you're authorized to examine, not for bypassing DRM or copying protected assets.
Still, the concept is compelling: AI coding agents that don't just write software from prompts, but investigate existing systems, reconstruct their behavior, and check their own work.
Free and open source under MIT/Apache 2.0 licensing.
🔗 github.com/storytold/craft-a…
#OpenSource #AICoding #ClaudeCode #DevTools
One Ring to Approve Them All. 💍
What if you could control your AI agents without ever taking your phone out of your pocket?
Startup @AinaInterface has opened pre-orders for Aina Ring, a $399 smart ring with an OLED display, microphone, speaker, and a tiny joystick-like button.
Founded by @lazyapprove (Apoorv Shankar), a former VP of Hardware at Ultrahuman, Aina wants to solve a growing problem: AI agents can automate tasks, but humans still have to approve their next moves.
Instead of constantly checking notifications, you simply flick your thumb.
🧠 How it works
Aina learns your daily routines from your calendar, location, phone, Mac, and connected services.
Its software anticipates three things you might need next, then displays one contextual suggestion, called a Cue, at the right moment.
For example:
▪️ You usually leave for work at 9 AM? Your ring suggests booking an Uber.
▪️ Running late for a meeting? Approve a message warning your colleagues.
▪️ Starting a meeting on your Mac? Meeting controls appear on your finger.
▪️ Your AI agent needs permission to proceed? Approve or reject its action without opening another app.
⚡ More than AI approvals
The ring also supports:
▪️ Voice notes, reminders, and agent instructions.
▪️ Answering phone calls through its built-in microphone and speaker.
▪️ Controlling music, Apple TV, and other media.
▪️ Context-aware Mac shortcuts, with four gestures per application.
▪️ Voice dictation directly into Mac applications.
🔧 Hardware specifications
▪️ OLED display under protective glass.
▪️ Titanium construction with 140 internal components.
▪️ Seven thumb gestures.
▪️ Up to 18 hours of battery life.
▪️ IP65 dust and water resistance.
▪️ Seven sizes (7–13), with a free sizing kit.
▪️ Charging dock included.
💰 Pricing and availability
The early-access pricing is tiered:
▪️ Super Early Bird: $399
▪️ Early Bird: $419
▪️ General pre-order: $449
▪️ Regular retail price: $499
Amber Gold costs an additional $50.
First shipments are planned for early 2027.
One important limitation: Aina currently supports iPhone (iOS 18+) and Mac (macOS 15+) only. No Android or Windows support.
And while early hands-on impressions are promising, parts of the software are still being developed.
The bigger idea is interesting: instead of building another AI assistant you constantly talk to, Aina is building a physical approval interface for agents that already work on your behalf.
If autonomous agents become part of everyday computing, a tiny screen and a thumb gesture might become surprisingly useful.
🔗 aina.com/
#AinaRing #AIAgents #WearableTech #AIHardware
Hermes Agent now has its own official marketplace, and one of its plugins lets you use Claude without a separate API subscription. 👀
Nous Research has launched the Hermes Marketplace, bringing plugins, MCP connectors, and reusable skills into one centralized catalog.
Instead of searching GitHub repositories and manually configuring integrations, users can discover and install extensions from a single interface.
🧩 What's available?
The marketplace already features 1,000+ plugin listings, with search, sorting, and separate official, certified, and community categories.
▪️ MCP integrations: Connect Hermes to external tools, databases, development environments, and applications.
▪️ Service connectors: Integrations for Slack, Notion, Linear, Jira, Airtable, Stripe, Vercel, and dozens of other services.
▪️ Creative tools: Blender integration for working with 3D scenes, plus extensions for other creative applications.
▪️ Memory and automation: Memory Wiki for browsing agent memory, messaging integrations, and workflow automation.
▪️ Custom skills: Reusable instructions and specialized workflows that extend what Hermes can accomplish.
🔥 The most interesting addition: Claude Subscription
Nous Research also offers an experimental plugin called Claude Subscription DirectSDK.
It allows Hermes to run on an existing Claude Pro or Max subscription, using the official Claude Code CLI rather than requiring a separate Anthropic API key.
The important part is that Hermes retains its own agent loop, tools, approvals, and context management while Claude handles model inference.
Installation is straightforward:
hermes plugins install claude-subscription-directsdk
Then authenticate through Claude Code and select the new model provider in Hermes.
A few limitations worth knowing:
▪️ Requires Hermes Agent 0.21.4+ and an authenticated Claude Code CLI.
▪️ Usage counts against your Claude subscription's allowance. It isn't unlimited, and additional usage charges may apply depending on account settings.
▪️ The integration remains experimental.
Why this matters
Hermes is evolving from a standalone AI agent into a modular ecosystem where users can customize models, tools, integrations, and workflows without rebuilding everything themselves.
And being able to reuse an existing Claude subscription makes experimenting with alternative agent frameworks considerably more accessible.
🔗 Marketplace: hermes-agent.nousresearch.co…
🔗 Claude plugin: hermes-agent.nousresearch.co…
#HermesAgent #AIAgents #ClaudeAI #MCP
☢️ Someone just combined Fallout 3, Fallout: New Vegas, and Fallout 4 into one massive game. And there's even a multiplayer mod.
A modder known as Cobalt has released Fallout 34, an ambitious project that brings the Capital Wasteland and Mojave Wasteland into Fallout 4's engine.
You can explore all three regions with the same character, using Fallout 4's gameplay mechanics, interface, and progression system.
🌍 Three Fallout games, one connected world
▪️ Travel between Washington D.C., the Mojave Desert, and the Commonwealth using a Vertibird at Red Rocket.
▪️ Keep your character's equipment, weapons, perks, and progression when moving between regions.
▪️ Play the main storylines and major side quests from all three games.
▪️ Use converted Fallout 3 and New Vegas weapons, armor, creatures, and companions.
▪️ Adjust difficulty separately for each region to account for your character's level.
▪️ Start a new adventure in any of the three worlds or continue an existing Fallout 4 save.
The mod also adapts karma and older skill mechanics to Fallout 4's progression system.
🎮 And there's multiplayer
A separate mod called Fallout 34 Online introduces cooperative gameplay across all three wastelands.
Players can see each other while exploring their own separate worlds.
When special events appear, participants can enter shared instances featuring cooperative missions and extraction-style PvE challenges.
There's also a local co-op mode where another player joins your save.
The multiplayer system is still highly experimental.
🛠️ How does installation work?
Fallout 34 doesn't distribute copyrighted game assets.
Instead, its installer converts files from your own installations of Fallout 3 and New Vegas into Fallout 4-compatible assets.
You'll need all three games with their DLC, plus several required mods.
The conversion takes approximately 2–4 hours depending on your PC.
⚠️ Not everything works yet
The main campaigns are reportedly playable, but some quests still contain bugs.
DLC support is incomplete:
▪️ Fallout 3: Broken Steel, The Pitt, and Mothership Zeta.
▪️ New Vegas: Honest Hearts.
Other expansions are planned for future updates.
Still, this is an impressive community effort: three enormous RPG worlds connected through one character and one modernized gameplay system.
And adding multiplayer makes the idea even more interesting.
☢️ Main mod:
nexusmods.com/fallout4/mods/…
🎮 Multiplayer:
nexusmods.com/fallout4/mods/…
#Fallout #Fallout4 #FalloutNewVegas #Modding
🧊 An AI agent can now build a complete 3D washing machine with moving parts in just 38 lines of code. No complicated Blender scripting required.
Sandflow has released sand3d, an open-source Python library designed specifically for LLMs and AI coding agents.
Instead of forcing an AI to write hundreds of lines of Blender Python, sand3d provides a compact modeling vocabulary for creating geometry, assembling objects, and defining mechanical movement.
And the results are actual 3D assets, not just rendered images.
🔧 What can sand3d create?
▪️ 3D geometry with precise dimensions, profiles, holes, and curved surfaces.
▪️ Complex assemblies made from individually named components.
▪️ Mechanical joints, hinges, sliders, and rotating parts.
▪️ Parametric objects that can be modified by changing a few values.
▪️ Exportable models for games, CAD workflows, and robotics simulators.
🧺 A complete washing machine in 38 lines
The developers demonstrate a washing machine with:
▪️ A cabinet and internal rotating drum.
▪️ A hinged door with glass and handle.
▪️ A sliding detergent drawer.
▪️ A rotating control dial.
The assembly includes four defined joints, so its components can move independently.
You can inspect the object in an interactive viewer and manipulate individual joints.
⚡ Up to 6× fewer tokens
Sandflow compared its code against other procedural modeling systems.
Median token-count ratios:
▪️ Blender Python: 4.0× as many tokens.
▪️ CadQuery: 2.3×.
▪️ FeatureScript: 6.0×.
▪️ Articraft SDK: 2.0×.
These are developer-reported comparisons on selected CAD and articulated objects, not a universal measure of model-generation performance.
🧠 The entire API fits into approximately 3,600 tokens.
That's one of the most interesting details.
An AI agent can receive the complete API reference in its context, then use a relatively small vocabulary to construct objects programmatically.
Parts, faces, and edges are referenced by name rather than manually calculating every coordinate.
The process is deterministic: running the same program produces the same mesh.
📦 Export to real 3D workflows
▪️ GLB: Meshes, materials, and joint metadata for viewers and game engines.
▪️ URDF: Articulated structures with joint limits for MuJoCo, Isaac, ROS, and other robotics tools.
▪️ USD: Structured scenes for OpenUSD workflows.
▪️ OBJ / STL: Static geometry for conventional 3D tools and fabrication.
🚀 Open source and ready to install
pip install sand3d
The library runs on Blender's bpy engine and supports Python 3.11 and 3.13. Python 3.12 is currently unsupported.
Sandflow also provides a collection of approximately 100,000 programmatically described 3D assets, with datasets available on Hugging Face.
Everything is released under Apache 2.0.
One important distinction: sand3d isn't a generative AI model itself. It's a modeling toolkit that lets language models produce executable 3D programs.
And that's potentially even more useful for certain workflows.
Instead of generating a mesh that's difficult to modify, an agent can create structured, editable geometry with explicit components and mechanical relationships.
A promising direction for AI-assisted CAD, game assets, robotics, and procedural 3D production.
🌐 sandflow.ai/sand3d/
💻 github.com/Sandflow-ai/sand3…
#3DModeling #AIagents #OpenSource #Blender
🎨 OpenAI just published a detailed prompting guide for GPT Image 2.6. And it reveals how to get much more precise control over AI-generated images.
The official documentation covers everything from photorealistic photography and advertising to UI mockups, infographics, consistent characters, and surgical image editing.
The biggest takeaway? Better results come from describing visual requirements precisely, not just writing longer prompts.
🧠 8 practical prompting techniques from OpenAI
▪️ 1. Define the composition. Specify the subject, camera angle, framing, object placement, and aspect ratio. Don't just describe the artistic style.
▪️ 2. Describe visible details. Include materials, textures, lighting, colors, and photographic characteristics. For realistic photography, describe the lens, depth of field, and natural imperfections.
▪️ 3. Separate edits from constraints. Clearly state what should change and what must remain untouched.
▪️ 4. Render exact text. Put required wording in quotation marks, specify its position, and explicitly prohibit additional text.
▪️ 5. Give reference images specific roles. Identify which image provides the subject, clothing, background, or visual style.
▪️ 6. Preserve character identity. Reuse reference images and repeat defining facial features, proportions, and clothing details across scenes.
▪️ 7. Build diagrams like technical specifications. Include required labels, data, visual hierarchy, and layout constraints.
▪️ 8. Iterate one change at a time. Feed the previous result back into the model and explicitly preserve everything that already works.
⚙️ Two controls developers should understand
GPT Image 2.6 separates rendering quality from planning complexity.
Quality: low, medium, high, xhigh, max
Controls visual detail, textures, and fine lettering.
Complexity: low, medium, high
Controls how much planning the model performs before rendering.
For example:
▪️ Low complexity can work well for changing one object.
▪️ High complexity can help with elaborate compositions, complicated layouts, and interconnected visual elements.
Both Flare and Sunburst default to high complexity.
🛠️ Precision editing with markup
You can also upload a transparent annotation layer with a circle marking the object to edit.
The API uses that markup to locate the intended change.
For example:
"Recolor the vase inside the circle to cobalt blue. Preserve its shape, the flowers, lighting, and everything else. Remove the circle."
This is much more specific than asking the model to redesign the scene.
🚀 Flare vs. Sunburst
▪️ GPT Image 2.6 Flare: Optimized for speed and rapid iteration.
▪️ GPT Image 2.6 Sunburst: Designed for demanding layouts, detailed visuals, and precise edits.
Both support image generation, editing, and transparent backgrounds.
The guide also includes side-by-side comparisons showing how different settings affect the same prompt.
One important limitation: prompting alone doesn't guarantee pixel-identical preservation. For exact preservation, OpenAI recommends compositing the approved edit into the original image.
If you regularly generate images with AI, this documentation is worth bookmarking. It's essentially a practical reference for turning vague creative ideas into reproducible visual instructions.
📖 Full guide:
developers.openai.com/api/do…
#OpenAI #GPTImage #AIArt #PromptEngineering
🎬 Higgsfield just unveiled Miracle, an AI technology that promises to edit individual objects inside a video in real time, without regenerating the entire scene.
Imagine changing someone's jacket, removing an object, replacing a sign, or turning daylight into sunset while the original footage continues playing.
That's the vision behind Higgsfield Miracle, a new AI-powered post-production technology.
🧠 How does Miracle work?
According to @higgsfield, Miracle decomposes existing video into editable layers, enabling localized, pixel-level modifications.
The system also incorporates scene depth and what the company describes as built-in world knowledge to help edits remain consistent with the original footage.
Instead of manually masking objects frame by frame, the goal is to identify and modify specific elements while preserving everything else.
🎨 What can you edit?
▪️ Objects: Recolor, move, remove, or add individual elements.
▪️ Clothing: Change the color or appearance of garments without altering the person.
▪️ Lighting: Shift the time of day, sunlight, shadows, and overall atmosphere.
▪️ Backgrounds: Replace environments while preserving the original action.
▪️ Textures: Modify fur, hair, fabric, and other surface details.
▪️ Text: Edit signs and on-screen typography while maintaining consistency between frames.
▪️ Layers: Isolate individual elements and reinsert them into the composition.
⚡ The biggest claim: real-time editing
Higgsfield says edits will appear while the video plays, without waiting for a separate rendering process.
That's a significant ambition for AI video editing.
But there's an important caveat: no independently verified latency figures or detailed performance benchmarks are available yet.
🤖 Coming to AI agents through MCP
Miracle is also planned for integration with Higgsfield MCP.
That would allow agents such as Claude to control editing workflows through natural-language instructions.
For example, an agent could potentially receive a request to change one object throughout a scene and invoke Miracle without manually configuring a traditional editing timeline.
🔒 Availability
Miracle is currently in private beta with selected testers.
▪️ Public release date: Not announced.
▪️ Pricing: Not disclosed.
▪️ Supported input formats and limits: Still to be confirmed.
▪️ MCP integration: Coming soon, not available for Miracle yet.
Users can join the waitlist on the official website.
The interesting shift: AI video tools are moving beyond generating new footage toward making existing footage directly editable.
If Miracle delivers on its real-time promises, it could become a powerful tool for filmmakers, VFX artists, advertisers, and AI-driven production workflows.
🔗 higgsfield.ai/miracle
#Higgsfield #VideoAI #GenerativeAI #AIAgents
🎨 What if an AI image generator could improve its own image quality without relying on an external teacher or feature encoder?
Researchers from @ant_oss (InclusionAI), Tsinghua University, and collaborating institutions have introduced IDM (Intrinsic Distribution Matching), a new method for generating detailed images in just 1–2 diffusion steps.
The most interesting part? The generator uses its own internal representations to learn which visual details it should preserve.
🧠 How does IDM work?
Most few-step image generators struggle with fine details, particularly small text, complex typography, and precise layouts.
Reducing diffusion from dozens of steps to just one or two leaves little opportunity to correct mistakes.
Traditional Distribution Matching Distillation (DMD) helps by aligning generated images with the distribution of real images.
IDM goes further.
▪️ Internal DMD: Estimates the correction signal using the generator's own velocity predictions instead of an additional fake-score network.
▪️ EMA feature extraction: Uses an exponential-moving-average copy of the generator to extract visual features from generated and reference images.
▪️ Moment matching: Compares the means and per-feature standard deviations of those representations.
▪️ Combined supervision: Adds this statistical constraint while retaining the full DMD correction.
The key insight is that the generator already contains useful visual representations. Those features can guide its own distillation.
No external DINOv2 encoder is required.
📊 Typography benchmarks
Using Z-Image-Turbo at two model evaluations:
LongText-CN:
▪️ Z-Image-Turbo: 78.48%
▪️ DMD2: 85.30%
▪️ APEX: 90.38%
▪️ Z-Image-Turbo++: 91.62%
▪️ IDM: 94.25%
LongText-EN:
▪️ Z-Image-Turbo: 72.89%
▪️ APEX: 88.76%
▪️ Z-Image-Turbo++: 89.88%
▪️ IDM: 90.20%
IDM leads the compared methods at this two-evaluation budget on both long-text benchmarks.
Importantly, controlled ablations confirm that adding EMA feature matching improves all five reported aggregate metrics over internal DMD alone.
⚡ Generation speed
The researchers evaluated two architectures:
▪️ Z-Image-Turbo 6B: 0.25 seconds at one step, 0.30 seconds at two steps.
▪️ Qwen-Image 20B: 0.35 seconds at one step, 0.44 seconds at two steps.
These are reported inference measurements on a single NVIDIA A100 using BF16, not guaranteed end-to-end generation times on consumer GPUs.
🔧 Training and deployment
IDM supports:
▪️ Full-parameter fine-tuning.
▪️ LoRA adaptation, including rank-32 and rank-64 configurations.
▪️ One-step and two-step inference from the same trained checkpoint.
▪️ Existing Diffusers-based pipelines.
And there's an important efficiency advantage.
Once training finishes, the additional feature-matching machinery disappears.
Inference only needs the trained generator, text encoder, and VAE.
No external encoder, moment computation, or additional discriminator is required.
🔓 Availability
The inference code is open-source under Apache 2.0.
However, the IDM-trained Z-Image and Qwen-Image checkpoints are not yet publicly downloadable.
The repository currently provides the implementation and instructions for loading future weights.
The bigger idea: making diffusion models faster isn't just about reducing the number of denoising steps.
It's about teaching them to preserve the right information when they have almost no time to refine an image.
And IDM shows that a generator's own learned representations can be surprisingly effective for that purpose.
🌐 inclusion-ai.org/IDM/
💻 github.com/inclusionAI/IDM
📄 arxiv.org/abs/2610.39633
#ImageGeneration #DiffusionModels #OpenSource #AIResearch
⚡ Someone built a Windows GUI that can unlock previously restricted NVIDIA Tensor Core performance on RTX 20, 30, and 40 GPUs, without permanently flashing the VBIOS.
Meet GPU Tensor Unlock Universal, a new open-source toolkit by MindAllik that makes existing GPU compute-unlocking methods easier to use across Windows and Linux.
The underlying technique isn't new. We've already seen Linux projects demonstrate major improvements in FP16 and BF16 tensor performance.
What's new is the automation: hardware detection, pre-boot checks, firmware compatibility validation, benchmarking, and cross-generation support in one package.
🧠 What exactly gets unlocked?
Some GeForce GPUs have reduced throughput for tensor operations that multiply FP16, BF16, or TF32 values and accumulate results in FP32.
The unlock modifies GPU configuration before the NVIDIA driver loads, attempting to restore the unrestricted execution rate.
It targets:
▪️ RTX 20 series (Turing).
▪️ RTX 30 series (Ampere).
▪️ RTX 40 series (Ada Lovelace).
RTX 50 series GPUs are not supported.
💻 Windows: A GUI instead of manual firmware configuration
Previously, users often needed to identify hardware IDs, extract firmware information, edit configuration files, and compile custom UEFI applications.
The new tool automates much of that process.
▪️ Detects GPU model, PCI identifiers, and VRAM capacity.
▪️ Identifies the system's EFI boot configuration.
▪️ Checks Secure Boot and BitLocker-related compatibility.
▪️ Validates expected VBIOS structures before applying changes.
▪️ Simulates the patch operation in memory.
▪️ Builds a bootable UEFI USB environment.
▪️ Provides before-and-after PTX benchmarks.
▪️ Includes an optional GPU power-limit control.
If the firmware structure doesn't match the expected profile, the tool is designed to abort rather than continue.
🐧 Linux support
The package also combines previously separate unlock implementations into one DKMS-based kernel-module workflow.
It supports explicit GPU selection, including systems with multiple graphics cards, and loads before the NVIDIA driver.
📊 RTX 4070 Ti benchmark
The developer tested a Palit RTX 4070 Ti running Windows 11.
For FP16 operations with FP32 accumulation:
▪️ Stock: 86.4 TFLOPS
▪️ Unlocked: 172.8 TFLOPS
▪️ Improvement: 2.00×
BF16 with FP32 accumulation reached approximately 172.7 TFLOPS.
These results come from a specialized tensor-instruction benchmark.
This does NOT mean twice the gaming FPS or twice the performance of every AI model.
Real-world improvements depend on tensor utilization, memory bandwidth, power limits, and the actual workload.
Many supported GPU profiles are still experimental or simulation-tested rather than verified on physical hardware.
🔐 Does it permanently modify the GPU?
No VBIOS flash is required.
The modification targets volatile GPU configuration and is lost after a full power-off.
However, this is still a low-level firmware-stage modification.
⚠️ Important risks
▪️ Secure Boot or BitLocker configurations may prevent the process.
▪️ Unsupported hardware may cause black screens or boot failures.
▪️ Higher compute utilization can increase power draw and heat.
▪️ Firmware compatibility checks reduce risk but don't eliminate it.
▪️ NVIDIA does not officially support this modification, and warranty implications may vary.
The toolkit is open-source under GPL-2.0-only.
The bigger takeaway: consumer NVIDIA GPUs can have substantial compute performance differences caused by configuration rather than different silicon.
This project doesn't invent the unlock. It makes the existing community research more accessible, measurable, and easier to experiment with.
For local AI enthusiasts, that's an interesting development, provided the hardware risks are understood.
💻 GitHub: github.com/MindAllik/GPU-Ten…
#NVIDIA #LocalAI #GPUs #OpenSource
🌍 A new approach to 3D reconstruction can process long video streams without continuously increasing the AI model's memory usage.
Meet ABot-Recon, an open-source streaming reconstruction system developed by Alibaba's AMAP Computer Vision Lab.
It converts video frames into camera trajectories and dense 3D point maps.
And unlike many reconstruction models, it doesn't need to keep the entire video history inside a growing attention window.
🧠 The problem with long-video 3D reconstruction
Modern geometric foundation models can reconstruct impressive 3D scenes from short image sequences.
But scaling them to thousands of frames introduces major problems:
▪️ Growing GPU memory requirements.
▪️ Expensive attention computation.
▪️ Accumulating camera-position errors.
▪️ Inconsistent geometry between distant parts of a sequence.
ABot-Recon addresses these issues through a surprisingly simple design.
🔬 Only 12 frames of local context
At every step, the model uses a fixed local window.
▪️ Cache visual features from the previous 11 frames.
▪️ Process the next frame.
▪️ Estimate a local 3D point map.
▪️ Predict the camera's relative motion.
▪️ Combine that motion with previous estimates to build a global trajectory.
The system uses a constant-size context regardless of how long the video becomes.
That keeps the model's working memory bounded.
Of course, storing the resulting point cloud still requires space proportional to the amount of reconstructed geometry.
📊 Performance
On KITTI-02, using an NVIDIA H100 at 504×280 resolution:
▪️ Processing speed: 24.45 FPS.
▪️ GPU memory: 6.71 GiB.
▪️ No growing long-range learned memory required.
On Oxford Spires, the reported reconstruction results include:
▪️ Absolute trajectory error: 4.35 meters without loop closure.
▪️ Dense reconstruction F1: 91.81%, using the study's four-meter threshold.
These are authors' benchmark results under specific test settings.
🔄 Optional loop closure
A fixed local context is efficient, but camera drift can still accumulate.
ABot-Recon therefore offers an optional loop-closure stage.
When the camera revisits a previously observed location, the system can detect the revisit, add geometric constraints, and refine its estimated trajectory.
This is an additional optimization step, not a requirement for basic streaming reconstruction.
🛠️ What can you export?
The released tools support:
▪️ Camera poses and relative trajectories.
▪️ Local and global point maps.
▪️ Confidence values.
▪️ Colored point clouds in PLY format.
▪️ Bird's-eye camera trajectory visualizations.
▪️ Videos illustrating reconstruction progress.
The project doesn't directly generate a finished textured game mesh. Its primary output is geometric reconstruction data.
🔓 Available now
▪️ Public checkpoint.
▪️ Inference and evaluation code.
▪️ Linux and NVIDIA CUDA workflow.
▪️ Optional loop-closure dependencies.
▪️ Apache 2.0 source code, with separate terms for model weights.
The bigger opportunity: processing long recordings incrementally could make learned 3D reconstruction more practical for robotics, mapping, spatial computing, and large captured environments.
Instead of rebuilding an entire scene from scratch, the system can keep extending its geometric understanding as new frames arrive.
🌐 amap-cvlab.github.io/ABot-Re…
💻 github.com/amap-cvlab/ABot-R…
#3DReconstruction #ComputerVision #Robotics #OpenSource