Model Releases

ComfyUI Integration for MiniMax-H3 — MiniMax-H3 now has official ComfyUI nodes, letting you wire up video, audio, and synchronized AV generation in a node graph instead of wrestling with APIs. If you’ve already built ComfyUI pipelines, this slots right in; if you haven’t, it’s a solid reason to start.

Kimi-K3-GGUF: Unsloth Quantized Version for Local Deployment — Unsloth’s imatrix-quantized GGUF builds of Moonshot’s Kimi-K3, optimized for local inference with endpoint compatibility. The quantization quality holds up better than naive GGUF, but you’re still running a MoE model locally — plan your VRAM accordingly.

Open Source Releases

AirLLM: 70B Model Inference on Single 4GB GPU — Layer-wise offloading lets you run a 70B model on a 4GB GPU by streaming weights from CPU/DRAM. It works, but latency is what you’d expect — think seconds per token, not milliseconds. Useful for experimentation on consumer hardware, not production serving.

agent-inbox 0.51.0: SQLite mailbox for local LLM agent communication — A local-first message bus for LLM agents built on SQLite and ActivityStreams, with an MCP server so coding agents can talk without external infrastructure. Clean abstraction if you’re orchestrating multiple agents locally; overkill for single-agent workflows.

Research Worth Reading

Learning Compositional Meta-Routing for Agentic Workflows: An Executable Benchmark — A benchmark where controllers must choose between answering, decomposing, retrieving, executing code, delegating, or verifying — moving beyond “which model” to “which strategy.” Finally, a framework that treats routing as a compositional policy problem.

Progressive²: A Teacher-Student Progressive Co-Evolving Knowledge Distillation Method for Substantial Model Compression — Teacher and student co-adapt during distillation rather than the usual frozen-teacher setup. Claims better QoS at high compression ratios for client-side deployment. The co-evolution idea isn’t new, but the progressive scheduling here is well-executed.

Verifier-Induced Support Reshaping in On-Policy Optimization — Identifies a failure mode in RLVR where verifiable rewards make successful trajectories for later objectives too rare to sample. Defines “effective rewardable support” and shows how verifier design warps the trajectory distribution. If you’re doing RL with verifiers, this explains why your late-stage learning stalls.

Similarity-Aware Machine Unlearning — Selects influential parameters using both forget-set importance and similarity to retain-set parameters, avoiding catastrophic forgetting during unlearning. Practical if you need surgical removal without full retraining; the similarity metric is the key knob.

Agentic Bayesian Optimization through Surrogate-Augmented Autoresearch — LLMs generate hypotheses about problem structure to seed Bayesian optimization surrogates, improving sample efficiency. Clever framing: the LLM isn’t the optimizer, it’s the prior generator. Works best when domain knowledge is expressible in language.

Uncertainty-Aware Simulation-Based Inference for Operations Research with Large Language Models — Addresses myopic policy formulation in LLM-based OR by using uncertainty-aware simulation to check if partial formulations can be validly extended. Niche but relevant if you’re using LLMs for optimization modeling — the “lookahead” mechanism prevents dead-end formulations.

Today’s Synthesis

If you’re building local-first agent workflows, three pieces from today fit together cleanly: AirLLM lets you run a 70B model on a 4GB GPU via layer-wise offloading, agent-inbox gives you a SQLite-backed message bus so multiple agents can coordinate without external infra, and the Compositional Meta-Routing benchmark frames the controller’s job as choosing between answering, decomposing, retrieving, executing code, delegating, or verifying — not just “which model.” Wire them up: spin up a few specialized agents (coder, retriever, verifier) on AirLLM, route tasks through a lightweight controller that implements the meta-routing policy, and let agent-inbox handle the handoffs. The latency hit from offloading is real, but for batch-oriented or human-in-the-loop workflows where you’d otherwise pay for API calls or a second GPU, it’s a viable trade-off. Start with the benchmark’s executable tasks to stress-test your routing logic before adding domain-specific agents.