r/IA_Italia

Hey everyone,

I just open-sourced TuneForge.

The goal is simple: let your coding agent manage the full LLM improvement loop without ever leaving the chat window.

You can now tell your agent something like:

“Build me a customer support bot from this FAQ”

…and it can:

• Generate a clean synthetic instruction dataset (with LLM judging for quality)

• Run LoRA supervised fine-tuning on any Hugging Face causal LM

• Do a quick policy-gradient RL step using Ollama as the reward judge

• Merge the adapter, evaluate on a test set, and iterate

Everything runs locally, uses 4-bit quantization so it fits on modest hardware, and uses background jobs (with job_id polling) so long training tasks don’t freeze the MCP connection.

It’s built around the Model Context Protocol (MCP) for seamless integration with Claude Desktop, Cursor, Zed, Continue.dev, etc.

Tech: Python + Transformers + PEFT + bitsandbytes + Ollama + SQLite for job state.

Super early stage (just released), MIT licensed.

Would love feedback or ideas on what to add next. If you’re into agentic fine-tuning workflows, give it a try and let me know how it goes!

Buon pomeriggio a tutti, volevo condividere con voi la pessima esperienza che sto avendo con gemini da 1 mese a questa parte. Principalmente utilizzo i servizi IA per studiare (studente al primo anno di uni) e per codifica. Ho il piano pro di gemini da circa ottobre 2025 dato che era gratuito con l’email istituzionale, e inizialmente mi ci trovavo molto bene, direi molto meglio rispetto a chatgpt che avevo precedentemente. Da circa 1 mese mi sembra che gemini sia completamente andato. Allucinazioni continue, cambia argomento principale appena si richiede di compiere una semplice correzione o cambio nella stessa chat (sempre sul relativo argomento), sembra che le reti neurali gli esplodano durante la sessione, dato che mi genera un file e al prompt dopo mi dice che non può generare file(questa cosa mi fa impazzire), eccetera. Ho switchato piano con chatgpt plus, anche perché ero curioso di provare codex, e mi sto trovando veramente benissimo, sia da studente che da appassionato di tutta la parte che riguarda la costruzione di codici, algoritmi, app… Vorrei sapere se anche voi se avete riscontrato questi tipi di problemi con gemini, vi lascio in allegato la foto della chat di oggi.

Un IDE dove il codice lo scrive l'AI, lo lanci tu, e il sandbox fa il resto.

Si chiama WebCraft. È dentro NHA 3rdArm gratis.

A parte questo, cerco disperatamente community per portare avanti il progetto! Tra lavoro e impegni, sta diventando difficile......siete interessati? L'applicativo ha tante alte features, tra cui una sezione avanzata per i connettori con market place

👉 nothumanallowed.com

https://nothumanallowed.com/3rdarm

Link all'intervista:
https://www.youtube.com/watch?v=x2VHFgyawPE

Guardandola mi sono rimaste soprattutto due impressioni.

La prima è che la paura della concorrenza cinese sia ormai uno dei principali motori del discorso delle aziende di IA americane. Più che parlare di innovazione, sembra che il messaggio sia: dobbiamo correre perché la Cina ci sta raggiungendo.

La seconda riguarda il rapporto con il Dipartimento della Difesa degli Stati Uniti. Mi è sembrato che Amodei cercasse di mantenere una posizione volutamente ambigua: da un lato prende le distanze da certi utilizzi militari dell'IA, dall'altro lascia chiaramente aperta la porta a collaborazioni con il Pentagono quando fanno comodo.

Sono io che sono malpensante, oppure il messaggio di fondo è che i principi valgono finché non entrano in gioco la competizione geopolitica e i contratti governativi?

Curioso di sentire le vostre opinioni.

Builders-welcome post with the substance up front (disclosure: I'm the maintainer). OmniRoute is a free, MIT, self-hosted AI gateway — one OpenAI-compatible endpoint over 237 providers — built around two problems: runs dying on a provider 429, and tokens bleeding on tool/log output.

One endpoint, 237 providers — 90+ of them free. You point any tool or agent at a single OpenAI-compatible endpoint (localhost:20128/v1) and it can reach 237 LLM providers without you rewriting anything. 90+ have free tiers and 11 are free forever (no card), which aggregates to ~1.6B documented free tokens/month — and that's honest, pool-deduped math (we count each shared pool once instead of inflating it; the methodology is public in the repo). There's a one-command setup-* for 13+ coding tools (Claude Code, Codex, Cursor, Cline, Roo, Kilo, Gemini CLI…), so switching your existing setup over takes seconds.

Fallback combos — so it never stops mid-task. A "combo" is a ladder of models the router walks automatically: your subscription first, then API keys, then cheap models, then free ones. When a provider returns a 500 or you hit a rate limit, it slides to the next target in milliseconds, mid-request, and your tool never even sees the error. There are 17 routing strategies (priority, weighted, round-robin, cost-optimized, auto/coding:fast…) plus three resilience layers — a per-provider circuit breaker, a per-key cooldown, and a per-model lockout — so one dead key can't take down a whole provider.

Fusion — an ensemble mode for the hard steps. Beyond simple routing, there's a fusion strategy that fans a single prompt out to a panel of different models in parallel and then has a judge model synthesize one best answer (mixture-of-agents, built in). It's cost-aware, so easy turns stay on one fast model and it only fuses when the step is worth it.

A 10-engine compression pipeline — the part most routers don't have. Every request flows through a transparent compression pass you can toggle/stack per combo. Instead of one trick, it stacks the best of the open-source ecosystem: RTK filters command/tool output (git diffs, test logs, builds) at 60–90%, Microsoft's LLMLingua-2 does ML semantic pruning, Caveman handles prose, session-dedup strips repeats across turns. Critically, code, URLs and JSON are preserved byte-perfect, and a default-on inflation guard throws the compressed version away and sends the original if compressing would actually grow the prompt — it never makes things worse. On tool-heavy sessions that's ~89% average input-token reduction (an 8k-token git diff becomes a few hundred). Full credit to every upstream project (RTK, Caveman, LLMLingua-2, Troglodita) is in the README.

Agent-native — the agent can drive the router itself. There's a built-in MCP server (95 tools across 30 audited scopes, over stdio / SSE / streamable-HTTP), plus A2A (v0.3, JSON-RPC 2.0) support. That means an agent can query providers, switch combos, read its own remaining quota and manage memory through the gateway — not just consume tokens through it.

It's 100% local (zero telemetry, AES-256-GCM at rest), MIT-licensed, has a prompt-injection guard on every LLM route, opt-in memory, and runs on npm, Docker, desktop or your phone via Termux.

For context on whether it's worth your time: it's grown to ~9.8K GitHub stars, 1,490+ forks and 280+ contributors in ~4.5 months, with 21,000+ automated tests and 1,830+ issues closed — so it's a battle-tested project, not a brand-new experiment.

npm install -g omniroute

GitHub: https://github.com/diegosouzapw/OmniRoute · Site: https://omniroute.online

Would value a critique of the routing/compression architecture from this crowd.

Hey everyone!
I'd like to share a project I've been working on, it's called Orin and it's a coding agent.

I use coding agents constantly, and at some point I realized I had basically no idea what was happening between me hitting enter and code showing up.

Also I was tired of building apps I wasn't able to really debug because I didn't know how they were being built in the first place so I got busy studying: read a bunch of articles, still felt like a black box, so I just tried to build one.

Couple things worth saying before anyone digs in:

It's mostly AI-written code, no point in hiding that, but I don't think "written by AI" and "sloppy" have to go together.

I try to run all my projects in the most professional way I know of, following actual SDLC practices: spec first, then an issue, then the implementation, then a real PR review before anything merges, not vibe-coding where you just accept every diff.

Whether that shows in the actual code is for other people to judge, not me.

Also this isn't some original idea I came up with: I cloned and read through pi.dev, nanocoder, and opencode as primary references (and skimmed Cline/Kilo Code for patterns), and basically tried to take what made sense to me from each and put it into one implementation.

My whole idea was try and build something that took the best from each to make a coding agent that would perform well. I plan to benchmark it on SWE-bench Verified sooner or later, but I don't think it's ready just yet: there are rough edges and bugs, but its usable.

Some of the actual implementation stuff, for anyone who cares about those rather than the pitch:

• The loop is just: stream a response from the provider, push it to message history, if there are tool calls run them, push the results back, repeat until there's nothing left to call.
• The loop is completely headless — it doesn't touch the terminal, it just emits events. The TUI (SolidJS on top of OpenTUI, just like opencode) is a separate subscriber to those events. You could swap in a totally different frontend without touching the loop at all.
• Another thing I got from OpenCode are edits: they go through a fuzzy replacer chain, not a single exact string match — if the model's oldText is off by whitespace or indentation, it falls through a chain of matchers before giving up. I had never thought about this and can confirm it's the kind of thing you don't appreciate until you actually try to implement it.
• There's a model routing mechanism that switches different models based on what the agent has to do:
  • explore runs on a cheap/fast model by default,
  • implement on a code-tuned model,
  • review on the main model.
• Another thing I borrowed from the web is a delegate_read tool that lets the main agent hand off read-heavy grunt work (scanning a big file, summarizing logs) to a cheap model so that content never bloats the main context.
  • It's basically a one off LLM call that only returns a distilled summary, seems dumb but works surprisingly well with capable models like Claude who know exactly what to look for and delegate super well to other agents.
• Tool selection isn't a static allow-list. Every turn runs a BM25 retrieval pass over the full tool catalog (including MCP tools) via a super cool library called Ratel, so the model only ever sees the tools relevant to what it's doing in that specific turn instead of the whole catalog every time. There's even an A/B flag to compare tool_pool=ratel vs tool_pool=default in your own telemetry to see if it even makes a difference (similar to how rtk gain works).
• Every file write gets snapshotted into a shadow git history before it happens, including stuff done through raw bash — allowing the agent to have a proper /undo /redo command.
• When I implemented subagents I wanted to explore different isolation mechanisms and ended up with 3 different ones you can configure yourself:
  • shared (edits land on the main working tree, safe because they run serially),
  • worktree (isolated branch)
  • sandbox (a real E2B cloud VM, edits get thrown away on dispose — for code you don't trust at all).
  • The lead model can escalate isolation for a given task but never go below the configured floor.
• I implemented hooks borrowing from nanocoder and opencode. This allows the agent to be expanded by third party code and I bundled some sensible defaults:
  • there's a before_tool hook that rewrites bash commands through rtk so that command output gets compressed before it ever reaches the model.
• In my daily work I build AI agents and vibe coded internal tools for my company and after a while I saw how much telemetry is crucial for debugging and actually understanding agent behaviour, so I decided that my agent would ship native OTLP tracing by default.
  • This means that by adding just one environment variable you can see full traces in your telemetry platform (Langfuse, Tempo, Jaeger, whatever you like) out of the box.
• Orin is also provider-agnostic (currently supports OpenRouter, OpenAI, Anthropic, OpenCode Go/Zen and Regolo if you want an EU-hosted option) — switching provider or model happens at runtime through a provider registry, no restart needed.

None of this is groundbreaking, it's just what I landed on after reading other people's code and deciding what to keep.

Try it:

git clone https://github.com/thetombrider/coding_agent.git

cd coding_agent

./install.sh

orin

There's also a deepwiki writeup if you want the architecture without reading source: https://deepwiki.com/thetombrider/coding_agent

I would really appreciate feedback in any shape or form. I'm learning and sharing my journey, hope it helps someone.

A while back, after yet another night on the balcony wrestling with Windows crashes, Mac drivers that wouldn't cooperate, and a prehistoric astro camera, I decided enough was enough. I built an iPhone app that does live-stacking astrophotography natively — no extra hardware, no laptop, just the phone.

It's called AstroStackerPro. You shoot a sequence of long exposures, watch the stack build up frame by frame on screen, and the Milky Way slowly emerges from the noise. Designed to be usable even if you're not an astronomer or a pro photographer. Nothing leaves the phone — no cloud, no account, no analytics.

Public TestFlight beta is open right now (v1.0.1). One-person project, so it definitely has rough edges here and there. iPhone only for the moment — if this gets traction I'm seriously considering an Android port.

Honest caveat: for some targets you'll still want a tripod, a star tracker, or a dedicated iPhone telephoto lens — but I'm actively working to minimize the extra gear you need.

If you give it a shot, real feedback at this stage is the best gift you can give me. Brutal is fine, just go easy 🙏 — best is email at astrostackerpro@icloud.com, I personally read and reply to every one.

🛰 https://testflight.apple.com/join/aYaV63UV

🌌 https://astrostackerpro.com

Clear skies, and thanks.

Hey everyone, I'm a solo indie dev and I've spent the better part of this

year building The Termi Protocol, a cozy 3D room your CLI coding agents live

and work in. I'd love your honest take on it.

Instead of watching Claude Code or Codex scroll by as text in a black

terminal tab, each agent gets a little robot with its own desk, and the room

mirrors what it's really doing, live. It sits somewhere between a dev tool

and Animal Crossing. What it does:

The mirror: nothing is a canned animation. When an agent reads a file, its

robot walks to the filing cabinet and digs through it. When it writes

app.tsx, the code streams onto its little monitor while the robot types.

npm install makes digit rain fall into a book. All of it is driven by the

agent's real activity.

Terminal: every robot's screen is a real shell. Click in and type whenever

you want to take over, and if you close the app, Claude agents resume their

exact conversation when you come back.

Messages: talk to the agent, paste screenshots, drag files in straight from

the file tree.

Tasks: a live todo board the agent maintains itself, marking work done, in

progress or up next. You can add or remove tasks while it works. Run several

agents and sync mode gives them one shared board with file locks, so two

robots never edit the same file at once. A graph view shows what they tell

each other.

Memory: everything an agent remembers, searchable, plain or semantic, with

receipts. Which file it grabbed and why, which websites it visited while

building, and which script that research ended up in.

Checkpoints: every agent snapshots its work, so when one goes off the rails

you diff and roll back. Git worktree isolation is handled here too.

Git tree: hit analyze and a small local model explains the diff between two

versions, so comparing scripts costs no tokens.

Activity and status: tokens burned and cost per agent, plus how much of your

5 hour and weekly limits are left. Checking it doesn't spend anything.

Skills: attach a skill to a specific agent with one click. It focuses the

agent and visibly cuts token cost.

Approvals: when an agent needs a yes or no, it doesn't blink in a tab you

forgot about. A card pops up over its desk with allow and deny, and you get

a native notification if you're in another app.

Code: a built in editor for when you'd rather type it yourself. Your manual

edits land right next to the agent's.

The room: this is the cozy part. Pick a palette, drag furniture in from a

catalog, adopt a pet you have to feed, throw a stress ball that really

bounces off the furniture. Sticky notes, a whiteboard you can draw on, a

pomodoro timer, a day and night cycle with occasional rain. Every project

gets its own room, and the room grows as you add agents.

The point is that your work stays on your Mac. Agents run in real local

shells under your own accounts, and their memory, boards and checkpoints are

plain files in a local folder. The semantic search and the diff analysis run

small local models. The only network traffic is your agents talking to their

own models.

Full honesty for this sub: it's Electron, because the whole app is a live

Three.js scene. It actually started as a web app, then Claude Code itself

suggested the desktop port and wrote most of it, over 90% of this project is

Claude's code on Opus 4.8. macOS first, a Windows build exists too. The app

is paid, you bring your own coding agent and your existing AI subscription,

it never resells tokens.

It's early and moving fast, updates land often and some things will break

along the way. Honest feedback is exactly what helps me fix and prioritize.

Download: https://termiprotocol.com