Senior AI Solution Architect — Agentic GenAI @ Almaviva | Former ITD-CNR Researcher | Orchestral Soundscapes Composer.
Genova, Italia
Joined April 2009
- Tweets30.1K
- Following4.6K
- Followers3.2K
- Likes14.8K
Pinned Tweet
Naming proposal: AI = LLM = COGITATOR
Artificial Intelligence now means everything: symbolic systems, deep learning, chatbots. For LLMs, I propose an alias: COGITATOR. Computer comes from compute; cogitator from cogitare, to think. It says what it does.
#AI #LLM #Cogitator
1/4
Giorgio Robino retweeted
Speech generation progress is not just making models bigger.
It is about finding the real boundary that is limiting the system — and then moving it.
From CosyVoice to Qwen-Audio-3.0-TTS, four generations kept the same backbone while solving four different bottlenecks.
Giorgio Robino retweeted
pi-web-access update: the agent can now search, then pull specific values off a page instead of reading the whole thing. Clairic returns just what you asked for, with the line it came from, and flags anything it isn't sure of.
When in codemode the values come back as typed data, so one script can compare prices across results.
Also: reduced the tool descriptions by 60% while retaining same functionality.
pi install npm:pi-web-access
github.com/nicobailon/pi-web…
Giorgio Robino retweeted
Unfortunately, CLI agents are no longer the ideal interface for working with agents.
This has been the case for months now.
It hurts to say because I have been a heavy CLI user.
The reality is that new interfaces like Grok Bot, the Codex app, and others are so good that they make it easier to take advantage of the new ways to work with agents. They also make it easier to scale agent work, collaborate with complex multi-agent systems, build from anywhere, and manage the development lifecycle smoothly (with little overhead).
This shift will become even more obvious in the coming months as LLMs continue to improve at things like persistence, coordination, parallelization, tool calling/MCP, memory, harness optimization, multimodal capabilities, intent understanding, UI generation, etc. The point of contact keeps getting simpler as agents continue to improve. I expect that pattern to continue.
My rule of thumb now is that I don't want to use an interface that holds the model back or keeps me from leveraging it to its absolute limits.
Giorgio Robino retweeted
TTS data cleaning: beyond VAD, diarization, and ASR
Where your audio comes from shapes how you clean it. Background music, multilingual speech, and uneven recording quality call for different checks. Here’s where four pipelines focus their effort.
🤖 Made with AI
Giorgio Robino retweeted
▲ Microsoft just open-sourced Agensh, a multi-agent harness that runs up to 1,024 coding agents with no lead agent in charge.
The key idea is self-organization. Every worker runs the same loop: gather context, claim a sub-task, build, verify, merge. They coordinate through a shared Gitea repo, a Mattermost channel and a shared findings board, instead of an orchestrator.
On the 5 hardest ProgramBench tasks (GPT-5.6-sol, 6 hours, offline), the mean test-pass rate rose from 19.31% with 1 agent to 28.78% with 128 agents. On pandoc, 1,024 agents hit 55.06%, up from 33.89%. With GPT-6.1-sol, 32 agents reached 79.59%. It is a trade-off though: going from 1 to 8 agents added only 1.37 points on the 5-task mean, and token cost is not disclosed.
The full harness, launch scripts and reproduction guide are on GitHub under the MIT license. It runs on Linux with Docker Compose......
Full analysis: marktechpost.com/2026/10/24/…
Repo: github.com/microsoft/Agensh
Paper: arxiv.org/abs/2609.26781
Project: aka.ms/Agensh
@MSFTResearch @msdev @msdev
Giorgio Robino retweeted
Quicksand
Quicksand is an async Python API for launching, controlling, snapshotting, and rolling back QEMU virtual machines to provide isolated sandboxes for AI agents without requiring Docker or root privileges.
github.com/microsoft/quicksa…
Giorgio Robino retweeted
30+B model release train continues.
A new 33B open model beat Qwen3.8-27B on 18 of 20 published benchmarks and its Q4 is only 19.1GB. 👈 👀
Nanbeige released Nanbeige4.3-33B.
Stats
🧠 33B dense
💾 Q4_K_S → 19.1GB
📚 512K context
🔓 Apache 2.0
🛠️ tool calling + thinking
Supported on
⚙️ llama.cpp / Ollama / LM Studio / vLLM / SGLang
Agent benchmarks are notable
Nanbeige → Qwen3.8-27B
Terminal-Bench 2.1
80.9 → 73.0
Terminal-Bench 4.0
23.8 → 6.3
DeepSWE
65.5 → 42.5
Automation Bench:
54.2 → 38.3
JobBench
44.8 → 34.5
DeepPlanning
63.3 → 49.2
Nanbeige says it evaluated the models with the same inference hyperparameters and harnesses.
The 19.1GB Q4 weights can fit on a 24GB GPU but not at 512K context won't.
This is a conventional dense Llama architecture with a growing KV cache, and early community testing is already showing performance falling as context fills.
Giorgio Robino retweeted
Microsoft open-sourced an app that watches you do a task once, then teaches your AI agent to do it for you. 4.3K stars.
How Skill Recorder works:
1. Hit record (⌘⇧R or Ctrl+Shift+R) and do the task normally. You can talk through it out loud too.
2. It captures your clicks, app switches, pages and terminal commands, all on your machine.
3. GitHub Copilot turns the recording into a list of steps you can edit.
4. One click turns it into a skill your agent can run, or an automation on a schedule.
It generalizes from one example, so recording yourself submitting one form teaches the agent to submit all of them.
Runs on Mac, Windows 11 and Ubuntu. Needs a GitHub account with Copilot access.
Install: copy the one-line command from the latest release:
github.com/microsoft/skill-r…
Giorgio Robino retweeted
@nanbeige new 33B model beats qwen 3.8 27b
Also, supports a CTX length up to ~524k!
huggingface.co/Nanbeige/Nanb…
Giorgio Robino retweeted
RAG is so back!
This work shows that plain RAG over raw chat history beats complex agentic memory systems on most long-term memory benchmarks.
(bookmark it)
They tested Raw-RAG, which is just dense retrieval plus reranking over the raw conversation, feeding a reader LLM.
Across LoCoMo, LongMemEval, MEME and MemoryAgentBench, it ranks first in six of seven benchmark and model settings, ahead of the strongest agentic memory system by 0.13 to 5.53 points. Ingestion on BEAM-1M takes 0.3 hours, against 3.2 to 27 hours for systems like Mem0, MemOS and Memora.
Why does it hold up? Raw history keeps more of the evidence a question needs, including the relations and dependency paths behind an answer. Rewriting history into memory entries tends to drop those important bits.
Even with complete access to the transformed memory stores, models answer less accurately than with raw evidence.
Before adding a memory layer to your agent, at least run this baseline on your own data.
arxiv.org/abs/2610.30755
Chat with Paper: academy.dair.ai/papers/is-co…
Giorgio Robino retweeted
This new open-weight model is pretty interesting:
EdgeRock-4B works with text and images, and it's designed to handle long reasoning tasks, but there's a twist:
The model keeps its history at a fixed size, making memory usage more predictable as reasoning continues.
As conversations get longer, regular models use more memory on your hardware. This makes it hard for people building AI applications to predict how much memory they will need.
EdgeRock-4B does something different:
• It keeps recent information available
• It maintains a compressed summary
• It learns which information to keep around
Basically, the model tries to keep the most recent details together with the most important information in context.
This is good when you want predictable memory. Basically, you can handle more requests on the same hardware.
But there are trade-offs.
1. The model decides what to remember, so it can lose important information.
2. Accuracy will vary across different tasks. This model will work well for some problems, but not for others.
3. You'll need compatible software to deploy the model because of its specialized memory architecture.
You can see the model's architecture attached to this post.
Giorgio Robino retweeted
NVIDIA releases Nemotron-3.5-Bolt-E4B, a new model that runs locally on 6GB RAM. 💚
Bolt-E4B can run on edge devices like phones and delivers top-tier performance for its size. Trained on Gemma 4, it supports vision.
GGUF: huggingface.co/unsloth/NVIDI…
Guide: unsloth.ai/docs/models/nemot…
Available now: NVIDIA Nemotron 3.5 Bolt E4B 4GB ⚡️
Our newest small open model is built for local assistants, interactive characters and robots that can carry on a conversation and use tools to get things done.
Watch Reachy Mini chat and move, with Bolt handling conversation and NVIDIA Cosmos handling vision. Both models run locally on Jetson Orin Nano 8GB.
Learn more: research.nvidia.com/labs/nem…
Giorgio Robino retweeted
Anthropic 把 Claude Code 使用的沙箱运行时开源了，叫 sandbox-runtime。
macOS 用系统自带的 Seatbelt，Linux 用 bubblewrap，不需要额外启动完整容器，就能限制 Agent 对文件系统和网络的访问。
而且不只支持 Claude Code，自己的 Agent、MCP Server，甚至普通命令行程序都能用。
但这里有个很现实的问题：
Agent 写代码不只是改文件，还要装依赖、拉文档、访问 API。网络白名单收得太紧，任务可能跑不下去；放得太宽，沙箱的安全价值又会打折扣。
所以 Agent 沙箱真正难的，不只是把权限关起来，而是怎么在安全和可用性之间找到平衡。
开源地址：
github.com/anthropics/sandbo…
Giorgio Robino retweeted
🎭 厉害了，MultiTalk 喂几段音频加一张参考图，就能生成几个人对着说话的对话视频，口型还能跟上音频。
MultiTalk 在 GitHub 3000 star，五百个 fork，论文中了 NeurIPS 2025。
以前做一段两个人对话的短视频，要么真人出镜录，要么用数字人工具一个一个生成再剪到一起，人物之间很难有互动。MultiTalk 是直接按多路音频生成同一个画面里的多人对话，提示词还能控制人物之间怎么互动，卡通角色、唱歌视频也能做。
门槛也降下来了：480p 用单张 RTX 4090 就能生成，社区做的 Wan2GP 最低 8GB 显存就能跑，还接进了 ComfyUI 和 Google Colab。
同一个团队后面又接着出了 InfiniteTalk 和 LongCat-Video-Avatar 系列，最新的 1.5 版把推理压到了 8 步。
生成的是真人模样的说话视频，用谁的脸、谁的声音，得先拿到人家同意。
拍对话戏，以后可能真不用凑齐演员了。
GitHub：github.com/MeiGen-AI/MultiTa…
Giorgio Robino retweeted
Open TTS Leaderboard updates 🗣️
> A 31M and a 35B model were added: phonon by @gradium and Drama-3 by @FishAudio. ~1000× apart in size, similar English WER (1.08 vs 1.19)
> New metric: UTMOS, for naturalness of English outputs. Thanks @realmrfakename!
🧵
Giorgio Robino retweeted
专为 Pi 锻炼的模型，还能免费使用🔥
今天看到官方账号转发了一个新模型，不看不知道，一看吓一跳
Recursive Superintelligence 刚发布首个模型 Flint，40B MoE 架构，每次只激活 2.5B 参数，主打快速本地编程
最让我感兴趣的是，Pi 社区提到 Flint 在 Pi Harness 上进行了大量 RL 训练，目的就是让模型更适应 Pi 的工具调用和 Coding 工作流，开箱即用
官方宣称在 M4 Pro MacBook Pro 上能达到 125+ Token/s，速度确实挺夸张
重点是：现在通过 Radius 就能在 Pi 上免费使用 Flint！
不需要自己准备高配电脑，本地部署也有开放权重可用，Apache 2.0 协议
Pi 用户可以去试试这个新模型了，我就不等了去测试一下，看看效果怎么样👍
模型：huggingface.co/RecursiveSI/f…
@Recursive_SI shipped its first model, Flint! Exciting to see they did extensive RL training on the Pi harness, so it works well out of the box.
40B MoE (2.5B active) for fast local coding. Apache 2.0.
Available now for free in Pi via Radius.
Giorgio Robino retweeted
Today, we announce 𝙻𝚒𝚚𝚞𝚒𝚍 𝚁𝙸𝙿𝙻 (real-time inference pipeline), our ultra low-latency inference engine built to put LFMs directly in the request path of real-time workloads like search, ads, fraud, recommendations, and payments.
> complete generated responses end-to-end in sub 50ms
> maintains low latency under continuous peak load
> LFMs get up to 20x faster on RIPL
> RIPL supports Multimodal LFMs
> RIPL supports d1, our decision models too!
RIPL optimizes the full path from request arrival to a complete generated response. As traffic rises, its performance advantage is greatest on the slowest requests. Let’s see some production use cases:
Giorgio Robino retweeted
Run Flint locally on 24GB RAM via Unsloth Dynamic GGUFs!
Flint is the strongest MoE model under 50B parameters.
Recursive’s Apache-2.0 model has 39.8B parameters (2.5B active). Run at 125 t/s on Mac, 150 on RTX Spark
GGUF: huggingface.co/unsloth/flint…
Guide: unsloth.ai/docs/models/flint
Introducing Flint, @Recursive_SI’s first model: a fast local coding model built with our automated research system, the Eureka Machine.
• Best-in-class fast local coding
• Up to 2x faster than comparable models: 125+ tokens/sec on a MacBook Pro, 150+ on RTX Spark
• Built from scratch in under 4 months
Private, unmetered intelligence on your own machine. Open weights available now on @huggingface, run it locally on your favorite framework or try it for free on @opencode or @pidotdev.
Giorgio Robino retweeted
NVIDIA ACABA DE ELIMINAR EL MAYOR PUNTO DE FRICCIÓN EN VOICE AI
han liberado PersonaPlex-7B, un modelo de conversación dúplex completo que puede escuchar y hablar al mismo tiempo
→ no espera a que termines de hablar
→ usa una arquitectura de doble flujo para procesar y responder en tiempo real
→ código disponible en GitHub
y es 100% open source y gratis
os dejo el repo abajo
Giorgio Robino retweeted
Nvidia released Kumo Relational, a small purpose-built AI model to predict what happens next from your relational database.👀
👉Customer churn. | Fraud. | Future demand. | Conversion. | Risk.
This is not a replacement for SQL. SQL tells you what already happened.
Kumo is designed to predict what happens next from the relationships and history already inside your database.
And it can do this without training a separate model for every task or manually engineering features.
Instead of flattening a relational database into one giant table, it works across the relationships between your existing tables.
Give it historical examples in-context, up to 10,000, and ask it to perform classification or regression.
Nvidia tested it across 📊 41 tasks 🗄️ 15 databases
They report it beating supervised relational deep-learning systems and expert-engineered gradient-boosted-tree pipelines.
On SAP SALT, Nvidia says it beat large AutoGluon ensembles by 8% MRR.
You can download the weights and run it locally on CUDA.
The checkpoints are tiny
🧠 Classification → ~120MB
📈 Regression → ~124MB
Your model doesn't just query your private database anymore. It can try to predict what happens next from it.
🔓 NVIDIA-authored code → Apache 2.0
⚖️ Weights → OpenMDW 1.1
Link in ALT
ALT https://docs.nvidia.com/sdgm/kumo-relational/about-kumo-relational/overview