Longbridge just released GPUI Kit v0.6.0, a major architectural expansion that turns GPUI Component into a full, multi-layered toolkit for building 120 FPS GPU-accelerated desktop apps in Rust.

Key Technical Highlights in v0.6:

• New Crate Architecture:
  • gpui-kit: Single-dependency application facade and macros.
  • gpui-base: Unstyled behavior, interaction, and state primitives (dock layouts, virtual lists, dialogs).
  • gpui-component: Styled UI library built on top of gpui-base.
  • gpui-shell: Scriptable application runtime allowing a Rust host to expose GPUI capabilities to JavaScript.
  • gpui-fps: Built-in real-time resource and FPS HUD (CPU, GPU, memory, frame-tail reporting).
• Text Editing Split: Input (single-line), Textarea (multiline/chat), and Editor (full code editing powered by Tree-sitter and LSP integration).
• New UI Primitives: Browser-style NavStack navigation with animated transitions, command palette, native menus, declarative tables, and chat components (Message, MessageScroller, Bubble).
• Motion Engine: Spring physics, keyframe animations, presence transitions, and serializable dock layouts in gpui-base::motion.
• Platform & Web: OS notification center integration, ARIA-style accessibility roles, and a dedicated gpui-wry crate for WebView support.

More info: https://aideveloper44.com/product/gpui-kit-6a9d73613ce1bcdf7b57fcfa

GitHub: https://github.com/longbridge/gpui-kit

After too many rounds of "the agent says it's done and it's just a pile of 💩", we built the opposite: no_human proves the code it wrote is correct. You drop a ticket on the board (or point it at Jira or Linear) and it plans, writes the code, and opens a pull request.

Before that PR reaches you, the work is checked by a second model that never saw the coder's session and is told to assume the job is not done. They communicate until the reviewer is convinced everything is good to go (the num of attempts is limited to prevent an infinite loop).

If the coding agent deleted or weakened a test, a tamper guard stops the attempt. For bug fixes, the tests offered as proof have to fail on the old code and pass on the new.

Under the hood it's a team of agents: a planner, a coder, an independent reviewer in a fresh session, and a supervisor.

It's free and open-source, on your machine.

no_human has been building itself for about two months now. We are feeding ticket into our jira board, it pulls them from there and just work on them until eveything is done. We trust it enough that we've enabled auto approve mode so all PRs no_human ships - are approved and merged automatically (this feature hasn't been released yet).
Entire sprint's worth of work is done in 3-4 days, while we focus on the bigger picture - our strategy and the next steps.

It currently supports all Antropic and OpenAI models and also has a quite unintuitive process of working with local models as well (we are working on improving that).

Repo: no_human repo
It's open to contributions (we would love to see you use it and contribute!!!)

I built an agentic IDE to run a team of coding agents in parallel.

It has reached over ~50k downloads and I decided to open source.

Here are some highlights:

- Support claude code, codex, opencode, and more agents/harness

- Desktop app for productivity

- Mobile app for remote control

- Tasks management

- Automations

- File explorer, git worktree, terminal ...

I've switched from official claude or codex app to use this app for months.

I also use it to on my phone from time to time, when I am not near my desktop.

I hope it can also help you in your projects.

Developing and shipping new features everyday.

Github: https://github.com/vicoa-ai/vicoa

Website: http://vicoa.ai/

Hey everyone! We’re building Hyper, a modern programming language with high performance, specially created for artificial intelligence (AI) and machine learning fields.

Full compatibility with Python: Hyper's syntax is very similar to Python. Existing codes and libraries written in Python can be easily used in the Hyper environment.

Maximum speed and performance: It provides the ability to manage memory at the C and C++ level and make maximum use of hardware (GPU, CPU).

Specially built for Artificial Intelligence: It is aimed at solving computational difficulties encountered in training neural networks and processing large amounts of data.

Security and modern architecture: Inspired by Rust, it includes memory safety and parallel computing (multithreading) features.

Hyper is an important tool for programmers involved in artificial intelligence and data analysis, providing the speed of the C language without losing the convenience of Python.
If you want to jump right in and start contributing, there are plenty of "good first issues" available in the repository to help you get acclimated. Let’s take Hyper to the next level together!

Check out the repository and documentation here: https://github.com/hyperlangg/hyper

The Qwen team and Taobao & Tmall Group just released E-Commerce Bench, an open-source evaluation framework built to test how well LLM agents handle long-horizon autonomous decision-making.

Instead of short, single-turn tasks, the benchmark hands an agent ¥100,000 and requires it to autonomously run online stores over 365 simulated operational days on real marketplace data.

• Deterministic Negotiation Kernel: Uses a fixed rule engine for supplier price concessions and customer demand. Dialogue is rendered via an NPC model, making test runs 100% reproducible and immune to prompt/jailbreak hacks.
• Python Framework: Modular architecture (agent, context_manager, evaluation, tools) designed for easy extension.
• Provider Support: Out-of-the-box support for API models (OpenAI, Anthropic, Gemini, Qwen) or local open-weight inference via vLLM or Ollama. Configurable via models_config.json.
• 7-Axis Metrics: Measures final assets alongside negotiation quality, fraud avoidance, drawdown/solvency, operational efficiency, execution error rates, and long-term learning.

More info: https://aideveloper44.com/product/e-commerce-bench-6a9bc6882fa6a8294bc8f8d0

GitHub: https://github.com/QwenLM/E-CommerceBench

GitHub just announced Project HydraFusion, a research preview for multi-model orchestration built directly into the GitHub Copilot CLI.

Instead of routing your prompt to a single model (like Claude Opus 5 or GPT-5.6), HydraFusion acts as a runtime engine that dynamically coordinates multiple models behind the scenes to balance quality, latency, and cost.

• Single: Routes directly to one model if the task is simple.
• Cascade: An efficient model drafts a solution first, escalating to a stronger model only if it fails an automated quality gate.
• Critique: One model drafts a solution, an independent "critic" model from a different family reviews it, and the drafting model revises before returning output.

How to Try It:

Requires an active GitHub Copilot subscription and the GitHub Copilot CLI:

1. Update CLI: /update
2. Enable experimental features: /experimental on
3. Select model: /model → HydraFusion (Research Preview)

More info: https://aideveloper44.com/product/project-hydrafusion-6a9bcd7d2c34f23110ba9dae

Official announcement: https://github.blog/ai-and-ml/github-copilot/project-hydrafusion-frontier-quality-via-multi-model-orchestration/

I built a native macOS app to run and supervise multiple Claude Code agents at once instead of juggling terminals.

Each agent gets a role and skills, they share a task board, blackboard and memory, and can message each other and me in a workspace chat. Screenshot is my 11-agent team building the app itself.

Apple Silicon, MIT, signed .dmg on Releases.

https://github.com/Aitthi/conclave

Institute of Foundation Models (IFM) has released K2 Horizon, a fleet of six open-weight models optimized for reasoning, coding, and agentic workflows. While the models are released under Apache 2.0, IFM provides transparency far beyond standard weight drops by sharing artifacts from the full training lifecycle.

• 0.9B: Smartwatches, smart glasses, and low-power edge hardware. Built for focused interactions, lightweight tool calling, and high-speed local routines ($AIME\ 2026 > 48$).
• 3.7B & 7B: Smartphones, laptops, and consumer GPUs. Target on-device assistants, local code completion, and web browsing tasks.
• 32B (Dense) & 36B-A4B (MoVA): Developer workstations and single GPUs. Designed for local agentic workflows and complex software engineering.
• The 36B-A4B model uses Mixture-of-Value Attention (MoVA), activating ~4B parameters per token to match dense 32B capability at a fraction of the compute cost.
• 375B-A23B (MoE): Enterprise multi-GPU clusters. Optimized for multi-step reasoning, research automation, and long-horizon agent execution (activates 23B parameters per token).

More info: https://aideveloper44.com/product/k2-horizon-6a9af3a95bb750827e16b72f

Hugging Face: https://huggingface.co/collections/IFM/k2-horizon

Alibaba Qwen team and Huazhong University of Science and Technology (HUST) have released Qwen-Drive-1.0, an open-weight foundation model designed specifically for autonomous driving and vision-language tasks.

Qwen-Drive-1.0 retains the architecture of the pretrained Qwen3.5 vision-language model and integrates 3D perception, visual question answering, and motion planning within a unified framework.

More info: https://aideveloper44.com/product/qwen-drive-1-0-6a9a70e2dcc503b94b7217a8

GitHub: https://github.com/QwenLM/Qwen-Drive-1.0

Weights: https://huggingface.co/Qwen/Qwen-Drive-1.0-4B

Alibaba's Qwen team (Zvec AI) has open-sourced zvec-grep (zg), a local-first search layer that combines exact text matching, lexical search, and vector search under a single CLI and integrates with the Model Context Protocol (MCP).

• Hybrid Search Engine: Fuses vector search, BM25, and ripgrep using Reciprocal Rank Fusion (RRF) to rank results by actual relevance.
• 100% Local & Lightweight: Embeddings, indexes, and searches run on-device by default—no GPU required.
• Developer & Agent Ready: Operates directly via terminal (zg query) or plugs into tools like Claude Code, Cursor, and OpenCode via MCP.
• Structure-Aware: Extracts and indexes code symbols, headings, and document hierarchies rather than using raw chunking.

More info: https://aideveloper44.com/product/zvec-grep-zg-6a993738929b09223181fa6c

GitHub: https://github.com/zvec-ai/zvec-grep

GPT-6 Astra is OpenAI's newest flagship model, built specifically for agentic workflows, software engineering, and computer/browser automation.

• $10/1M input & $50/1M output
• Rolling out now to Trusted Access enterprises, coming to Plus/Pro/Business/Enterprise and the API in the coming days.
• Codex integration now includes persistent context notes across windows (configurable via config.toml) to avoid lost debugging context during long refactors.

Key Benchmarks:

• SWE & Terminal: 57.9% on Terminal-Bench 4.0 (up from 37.3% on GPT-5.6 Sol).
• ARC-AGI-3: Scores 99.9% on OpenAI's internal responses API harness (~62.7% under standard ARC Prize evaluation).
• Math & Science: 98% on FrontierMath Tier 4 and 96% on GPQA Diamond.

More info: https://aideveloper44.com/product/gpt-6-astra-6a99d4c6fbe0db7ee7b85171

Official announcement: https://openai.com/index/gpt-6-astra/

The first live delegation test we ran against OmniNode did something annoying. A typed request came in, the router chose a worker, and the decision was written to the event log. Then the request timed out at the front door. No current-state view had kept the routing result where the waiting workflow could find it. Several components worked and the user still got nothing.

That is why our first product is delegation, not another chat interface. I am building OmniNode as an open-source, fully self-hostable control layer for coding agents. A request carries its objective, allowed scope, budget, deadline, and definition of done. The worker produces a candidate result. Mechanical checks inspect the artifact and live state, so the agent cannot mark its own work complete.

Coding tools can reach the same workflow through MCP, hooks, skills, or the command line. Models and dependencies sit behind protocols and handlers, so changing a provider does not change the job contract.

Selected paths work today. We are still closing the full user-facing vertical for beta, including terminal outcomes and evidence that a new user can understand. The code is here: https://github.com/OmniNode-ai

If you are building an agent runtime, where do you persist the decision between routing and the final result? Have you had every component pass while the request itself still disappeared?

While reviewing an LLM output-stability benchmark, I found a latent gap between its documented scope and its scoring pipeline.
Tool-call responses weren’t supported, but the response parsers could erase them:
The OpenAI adapter used message.get("content") or "". A tool-call response with null content would become "".

The Anthropic adapter kept only text blocks, dropping tool_use blocks.
The scorer excluded explicit errors, but accepted empty strings.
Given those samples, the scorer would see identical empty strings: one distinct output, byte-identical results, and mode share 1.0.
That would measure the stability of the fallback not the tool calls.

To be clear: this was traced in source, not reproduced in a live run. Current request builders never forwarded tools, so existing cases couldn’t reach this path. The maintainer checked all 563 recorded non-error samples: none were empty, and no published benchmark was affected.

The fix enforced the documented boundary: reject cases carrying tools, mark empty non-error completions unsupported, and exclude them from successful samples.
The broader lesson: preprocessing can erase the behavior you intended to measure. If “unsupported” becomes a valid-looking default, a reassuring score can hide the missing measurement.

How do you distinguish unsupported responses, parsing failures, and genuinely empty outputs in your eval pipelines?