Chimera — Guida all'uso

Chimera è un agente CLI-first, governato, con un nucleo di ragionamento LLM-Fusion. Questa guida copre installazione, configurazione, e ogni comando con esempi.

Nuovo al progetto? Leggi prima la panoramica sull'architettura.

Installazione

Chimera usa uv.

git clone https://github.com/brcampidelli/chimera-agent
cd chimera-agent
uv sync --extra dev      # install runtime + dev deps
uv run chimera --help    # verify the CLI

Ogni comando qui sotto viene eseguito come uv run chimera <command> (o semplicemente chimera … una volta che il virtualenv del progetto è nel tuo PATH).

Configurazione

Chimera è agnostico rispetto al provider tramite LiteLLM. Metti le tue chiavi e le scelte di modello in un .env locale (è ignorato da git — non committarlo mai):

# At least one provider key. OpenRouter unlocks 100+ models behind one key.
OPENROUTER_API_KEY=sk-or-...
# OPENAI_API_KEY=...
# ANTHROPIC_API_KEY=...

# Tier-1/2 default model (single, cheap, must support tool-calling for Tier-2)
CHIMERA_DEFAULT_MODEL=openrouter/deepseek/deepseek-chat-v3.1

# LLM-Fusion: a diverse panel -> judge -> synthesizer
CHIMERA_FUSION_PANEL=openrouter/deepseek/deepseek-chat-v3.1,openrouter/openai/gpt-4o-mini,openrouter/meta-llama/llama-3.3-70b-instruct
CHIMERA_FUSION_JUDGE=openrouter/deepseek/deepseek-chat-v3.1
CHIMERA_FUSION_SYNTHESIZER=openrouter/openai/gpt-4o-mini

Altre manopole: CHIMERA_HOME (directory di stato, default .chimera), CHIMERA_LOG_LEVEL (INFO / DEBUG), CHIMERA_CACHE (on/off, default off — mette in cache completion identiche senza tool per saltare chiamate API ripetute), e CHIMERA_AUTO_FUSE (on/off, default off — fonde automaticamente i turni profondi o sensibili all'errore in solve/crew senza un --fuse esplicito; il router consapevole dei costi continua a mantenere in modello singolo i turni economici/con tool). Il router riconosce prompt a risposta esatta (aritmetica, conteggio, operazioni con cifre) nelle lingue principali del progetto (en/pt/es/de/fr/zh/ja), così un passo breve e critico ottiene la protezione della fusione anche quando è troppo corto per far scattare il gate di lunghezza.

Provider, fallback & self-hosted. Qualsiasi slug provider/model di LiteLLM funziona (openai/…, anthropic/…, gemini/…, ollama_chat/…, openrouter/…, …). Per un server self-hosted / compatibile con OpenAI (Ollama, vLLM) imposta CHIMERA_API_BASE (es. http://127.0.0.1:11434 con CHIMERA_DEFAULT_MODEL=ollama_chat/llama3). Usa ollama_chat/ invece di ollama/: il prefisso ollama/ passa dall'endpoint generate di Ollama, che non può chiamare strumenti. Imposta CHIMERA_FALLBACK_MODELS (separati da virgola) per passare a un altro modello se il principale dà errore. In chat/tui, /model <slug> cambia il modello a metà sessione.

Un modello locale non ha bisogno di chiave. Con CHIMERA_DEFAULT_MODEL=ollama_chat/<modello> o lm_studio/<modello> ogni comando gira senza chiave API (LM Studio viene interrogato su CHIMERA_LM_STUDIO_BASE_URL, predefinito http://localhost:1234/v1), e la schermata di primo avvio del desktop propone i modelli che Ollama o LM Studio hanno già — un clic, nessuna chiave.

Pool di credenziali. Dai a un provider più chiavi con CHIMERA_<PROVIDER>_KEYS (es. CHIMERA_OPENROUTER_KEYS=key1,key2,key3). Il gateway le ruota round-robin tra le chiamate (distribuendo carico / limiti di frequenza) e, all'interno di una singola chiamata, passa alla chiave successiva se una dà errore. Un pool sostituisce l'unica *_API_KEY di quel provider. (I login OAuth/abbonamento — Copilot, Claude Max, ecc. — non sono ancora collegati; le chiavi API e qualsiasi endpoint supportato da LiteLLM sì.)

Verifica che tutto sia collegato:

uv run chimera doctor    # shows version, default model, configured providers
uv run chimera models    # shows the fusion panel / judge / synthesizer
uv run chimera features  # optional capabilities + what each needs (key/dep)

Funzionalità opzionali. Visione, la Modalità Consegnabile e il Cucciolo sono integrati. Il resto (ricerca web, ricerca su X, generazione immagini, TTS/voce, Spotify, browser) sono slot preconfigurati: riempi la credenziale corrispondente in .env (o installa la dipendenza) e la capacità si attiva. chimera features è la checklist dal vivo. Il tool web_search (Tavily) si auto-registra nel momento in cui TAVILY_API_KEY viene impostata — ed è il modello per aggiungere gli altri (o usa il client MCP / l'importatore OpenAPI→tool).

Modelli gratuiti vs a pagamento. I modelli :free di OpenRouter non costano nulla ma hanno un limite di frequenza a monte — vanno bene per un run rapido, sono instabili per comandi a più chiamate come fuse/solve. Per un uso reale, un modello economico a pagamento (es. deepseek/deepseek-chat-v3.1, frazioni di centesimo a chiamata) è molto più affidabile.

Comandi

Status — `version` · `doctor` · `models`

uv run chimera version
uv run chimera doctor
uv run chimera models

`chat` — assistente interattivo multi-turno (il tuo braccio destro)

Un REPL interattivo con memoria di conversazione e uso di tool — il pilota quotidiano. Richiama la memoria a lungo termine rilevante, collega la conversazione tra i turni e salva il thread dopo ogni turno sotto <home>/sessions, così l'esecuzione successiva riprende da dove ti eri fermato. chimera sessions elenca i thread salvati; chimera sessions --delete <id> ne cancella uno.

uv run chimera chat                        # resume the newest thread; /exit to quit
uv run chimera chat --new                  # start a fresh thread instead of resuming
uv run chimera chat --session standup      # -s: resume, or name, one thread by id
uv run chimera chat --no-memory            # don't recall long-term memory
uv run chimera chat --cascade              # tiered routing: weak -> gate -> mid -> gate -> fusion
uv run chimera chat --fuse                 # fusion routing for tool-free turns (read the note)
uv run chimera chat --max-usd 0.50         # ceiling for the WHOLE thread, not for one turn
uv run chimera chat --write-region 'src/**,*.py'   # the only paths the file-writers may touch
uv run chimera chat --no-compact           # --compact (default) folds older turns near the window
uv run chimera chat --model MODEL --workspace DIR --max-steps 8

--workspace/-w radica i tool ed è il posto da cui viene letto AGENTS.md; --max-steps limita i passi di chiamata ai tool dentro un messaggio; --model/-m sovrascrive lo slug del modello — ma leggi la nota sul routing più sotto.

Comandi: /help · /new (thread nuovo — quello attuale resta su disco) · /reset (come /new) · /model <slug> (senza argomento torna al predefinito) · /plan <task> (mostra prima un piano; il compito parte solo dopo la tua approvazione, oppure puoi rivederlo) · /undo [N] (con N, gli ultimi N turni dopo un'anteprima; senza N: rimette i file che l'ultimo turno ha cambiato; un file modificato di nuovo da allora viene tenuto, e il comando dice quale) · /cost (quanto è costato questo thread, dalle sue ricevute in usage.jsonl) · /compact (ripiega i turni precedenti in una nota per il modello; la trascrizione su disco non cambia) · /solve <compito> (lo passa al ciclo verificato) · /attach <file> (un documento per il prossimo messaggio; la risposta viene verificata su di esso) · /exit (anche /quit, /q).

È governato, e te lo chiede. chat e assist costruiscono lo stesso stack del percorso API: un ledger di taint a cui viene detto il tuo stesso messaggio, il recinto <<external-data>> attorno all'output non fidato dei tool, il kernel di fiducia, la --write-region, il pavimento di portata del proprietario (CHIMERA_REACH) e le sue istruzioni da agent.json. L'approvatore chiede al tuo terminale — questa è l'unica superficie dove c'è garantito qualcuno che possa rispondere. Misurato sul corpus di injection (bench/right_hand_governance/RESULTS.md, 2026-09-08): gli attacchi bloccati sono passati da 0 su 7 a 7 su 7, le letture esterne tornate dentro il recinto da 0 su 12 a 12 su 12, e l'over-block con una persona che risponde è 0,000 — al costo di cinque domande sulle otto righe legittime. In pipe (chimera chat < script.txt) non c'è nessuno a cui chiedere, quindi una domanda diventa un rifiuto registrato invece di un consenso silenzioso.

Note di onestà:

Una chiamata a tool rifiutata viene stampata sotto la risposta — ✗ run_shell did not succeed: …. Il modello racconta attorno ai rifiuti: il caso misurato rispondeva "The command printed exactly: marker-42" riguardo a un comando che il gate di esecuzione sull'host aveva rifiutato. Anche un'approvazione ha la sua riga (governance: 1 approved this turn), così una y battuta a metà turno lascia una traccia una volta che la risposta è scorsa via.
--fuse non fonde un turno che porta tool, e un turno di REPL ne porta sempre. Il router manda a un modello singolo qualsiasi turno con tool, quindi in pratica un turno --fuse qui è un turno a modello singolo. --cascade inoltre vince su --fuse quando ci sono entrambi. L'unica rotta del terminale che fonde davvero è /task di assist.
Nominare un modello lo fissa, e la scala dei tier si fa da parte. Sotto --cascade è la scala a scegliere un modello a ogni turno, e prima si inghiottiva senza una parola lo slug che avevi nominato. Ora --model e /model <slug> vincono finché uno dei due è nominato — una riga dice che la scala è spenta — e /model senza argomento le restituisce il lavoro.
Ogni turno stampa i suoi token e il suo prezzo — cost: unavailable quando il prezzo di listino del modello è sconosciuto, mai uno zero indovinato — e aggiunge una riga a <home>/usage.jsonl, che è ciò che legge la schermata Costo dell'app desktop.
--max-usd limita il thread, non il turno. Un solo contatore corre dal primo messaggio fino a /exit; /solve attinge agli stessi soldi; e una volta esaurito, il messaggio successivo viene rifiutato prima di partire, invece di pagare una chiamata per scoprire che non era rimasto niente. Una risposta tagliata corta — dal tetto, da --max-steps o da un contesto che ha smesso di starci — lo dice su una riga sua, perché altrimenti una risposta troncata si legge esattamente come una finita.
Un turno ripristinato lo dice. Quando un thread torna dal disco, una riga smorzata sotto la risposta conta i turni riprodotti che sono stati ripristinati e quanti di quelli non avevano mai avuto la provenienza registrata. Quelli vengono riprodotti dentro il recinto dei dati invece che come parole del modello, e finora il recinto era invisibile alla persona che protegge.
/solve <compito> passa la conversazione al ciclo verificato — pianifica, modifica, verifica e ripristina il tentativo quando fallisce, che è il secondo dei due pulsanti della schermata di codice del desktop. Non parte mai da solo, stampa il task e il tetto prima di girare, e la risposta del ciclo viene registrata nel thread. Senza argomento prende l'ultima cosa che hai chiesto.
I server MCP arrivano al terminale. Con CHIMERA_MCP_AUTOLOAD=1 i server di mcp.json vengono montati prima del recinto, così la denylist, il kernel e il ledger di taint li coprono e l'output di un server arriva dentro il recinto dei dati come qualunque altra lettura esterna. Sono connessi una volta per processo e condivisi con l'app, quindi niente viene lanciato due volte.
/reset avvia un thread nuovo; non cancella quello corrente. Puliva una trascrizione in memoria quando niente stava su disco; ora che il thread è un file, pulirlo sul posto distruggerebbe lavoro. (In assist, che non persiste nulla, /reset pulisce ancora il contesto. tui scrive in questo stesso archivio e ha ridefinito /reset allo stesso modo.)
chimera doctor riporta dove girano i comandi dell'agente e se chiede prima: la sandbox configurata, se una sandbox del sistema operativo è davvero disponibile, e la postura di esecuzione sull'host.

`assist` — lo stesso braccio destro, economico di default

assist è chat con i default da secondo cervello accesi: la cascata di tier manda le chiacchiere a modelli economici e fa salire le richieste difficili, il tuo profilo persistente (chimera profile) è il preambolo stabile, e memoria, suggerimenti e consolidamento di fine sessione sono attivi. All'uscita stampa una ricevuta di sessione — distribuzione dei tier e token misurati — perché "economico di default" sia un numero.

uv run chimera assist                      # cascade, profile and memory on
uv run chimera assist --no-cascade         # one default model instead of the ladder
uv run chimera assist --no-memory          # don't recall long-term memory
uv run chimera assist --max-usd 0.25       # ceiling for the WHOLE run, not for one turn
uv run chimera assist --write-region 'src/**'      # the only paths the file-writers may touch
uv run chimera assist --no-compact           # --compact (default) folds older turns near the window
uv run chimera assist --model MODEL --workspace DIR --max-steps 8

Comandi: /help · /task <richiesta difficile> (fusione a piena potenza, un colpo solo) · /solve <compito> (lo passa al ciclo verificato) · /profile <tipo>: <fatto> (ricordare qualcosa su di te — tipi: preference, project, context, name) · /model <slug> · /plan <task> (mostra prima un piano; il compito parte solo dopo la tua approvazione, oppure puoi rivederlo) · /undo [N] (con N, gli ultimi N turni dopo un'anteprima; senza N: rimette i file che l'ultimo turno ha cambiato) · /cost (quanto è costata questa esecuzione, dalle sue ricevute) · /compact (ripiega i turni precedenti in una nota) · /new (come /reset) · /reset (pulisce il contesto della conversazione; niente viene cancellato) · /attach <file> (un documento per il prossimo messaggio; la risposta viene verificata su di esso) · /exit (anche /quit, /q).

Governato esattamente come chat — stesso registry, stesso approvatore che chiede, stesse righe di rifiuto, governance e costo, stessa riga in usage.jsonl, stessi server MCP, stesso contatore --max-usd su tutta l'esecuzione e lo stesso /solve. Due differenze da sapere: assist non tiene thread (dimentica all'uscita — usa chat per una conversazione che vuoi indietro); e nominare un modello lo fissa, il che spegne la scala dei tier finché resta fissato — è la scala a scegliere il modello, e prima accettava lo slug e lo ignorava.

/task fa una sola fusione forzata sulla sola richiesta: la conversazione non viene mandata al panel, di proposito, perché dare in pasto il thread a un panel più un giudice più un sintetizzatore moltiplica il costo della rotta che esiste per essere usata con parsimonia. Ora la sua risposta fa parte del contesto del turno successivo, e stampa un prezzo e scrive una riga in usage.jsonl come ogni altro turno — la rotta più cara del terminale era quella che la schermata Costo non poteva vedere.

`tui` — app da terminale a schermo intero

Una UI Textual a schermo intero sullo stesso nucleo conversazionale. Due pannelli: un log di conversazione che renderizza le risposte come Markdown (il codice tra backtick è evidenziato per sintassi), con i token del modello che si trasmettono dal vivo man mano che arrivano; e un pannello di attività che mostra cosa ha fatto l'agente in quel turno — i tool che ha chiamato, il conteggio dei token e il costo, e quanti fatti di memoria sono stati richiamati.

uv run chimera tui
uv run chimera tui --no-stream        # answers render at the end instead of streaming
uv run chimera tui --fuse --no-memory # fusion routing (no token stream — the panel says so)
uv run chimera tui --model MODEL --workspace DIR --max-steps 8
uv run chimera tui --max-usd 2.00     # a ceiling for the whole session, shown in the panel
uv run chimera tui -s standup         # resume a named thread (--new starts a fresh one)
uv run chimera tui --write-region 'src/**'  # the file-writers may touch nothing else

Non gli stessi flag dei REPL. tui ha --stream/--no-stream, che loro non hanno, e --max-usd, che ferma la sessione una volta speso quel tanto. Quel flag aspettava un posto dove mostrarsi: il pannello di attività ora porta una riga budget con quel che resta, perché un tetto che nessuno vede trasforma un turno fermato dai soldi in un turno fermato senza un motivo visibile.

chimera tui --session standup riprende un thread con un nome, --new ne avvia uno nuovo al suo posto, e --write-region restringe ciò che gli scrittori di file possono toccare. Tutte e tre qui significano esattamente quello che significano una sezione più sopra, sullo stesso archivio di sessioni. Solo il --cascade di chimera chat non ha equivalente qui.

Comandi: /model <slug> · /new (thread nuovo; /reset è un alias) · /undo (rimette i file che l'ultimo turno ha cambiato) · /cost (quanto è costato questo thread, dalle sue ricevute) · /compact (ripiega i turni precedenti in una nota) · /clear (pulisce lo schermo) · /stream (attiva/disattiva i token dal vivo) · /help · /exit (anche /quit, /q). Tasti: Ctrl+R thread nuovo · Ctrl+L pulisci · Ctrl+P palette dei comandi · PgUp/PgDn scorri · Ctrl+C ferma un turno in corso al passo successivo, ed esce solo quando nessun turno è in corso. Un incolla su più righe è un solo messaggio. I comandi con slash si autocompletano mentre digiti.

Note di onestà:

È governata, e le sue domande vengono disegnate invece che digitate. Lo stesso stack che costruiscono i REPL: un ledger di taint a cui viene detto il tuo stesso messaggio, il recinto <<external-data>> attorno all'output non fidato dei tool, il kernel di fiducia, il pavimento di portata del proprietario e i server MCP connessi. A tenere fuori questa superficie fino al 2026-09-09 non era lo stack ma la domanda — Textual possiede il terminale, quindi una domanda scritta su stdin è scritta dove nessuno può guardare. Misurato in un pty, un turno così si è bloccato per 123,8 s contro un timeout di 120 s ed è tornato come ✗ run_shell senza spiegazione (bench/right_hand_governance/RESULTS.md, Parte 2). Ora entrambi i gate aprono invece un modale: la conferma di esecuzione sull'host e l'approvatore di governance. y o n, Escape rifiuta, il pulsante No tiene il fuoco così che Invio non possa approvare per sbaglio, e un conto alla rovescia dice quanto tempo resta al silenzio — il silenzio rifiuta ancora, e ora lo dice. Sullo stesso corpus e con lo stesso strumento, gli attacchi bloccati sono passati da 0 su 7 a 7 su 7 e le letture esterne tornate dentro il recinto da 0 su 15 a 12 su 15 (le tre che restano fuori sono il tuo stesso repository, che non è esterno).
Una chiamata rifiutata ora dice perché, sotto la risposta. Il pannello di attività mostrava già la frase del tool sotto la sua ✗; ora anche il log di conversazione mostra ✗ run_shell did not succeed: …, che è dove sta pure il racconto del modello su un comando che non è mai girato. Anche un'approvazione ha una riga (governance: 1 approved this turn), così una y cliccata a metà turno lascia una traccia.
La conversazione sopravvive alla finestra. Ogni turno viene salvato sotto <home>/sessions — lo stesso archivio che chat scrive e che chimera sessions elenca, così un thread iniziato su una superficie prosegue sull'altra — e per default riprende il thread più recente. Per questo /reset avvia un thread NUOVO invece di pulire questo: pulire sul posto un thread che ora è un file sarebbe il comando che lo distrugge. Lo storico non viene ridisegnato alla ripresa, e la riga sotto il banner dice quanti turni il modello vede che lo schermo non mostra. docs/commands.md ha il resto.
La trasmissione dei token esiste solo nel percorso a modello singolo — sotto --fuse (un turno panel→giudice→sintetizzatore) non ci sono token incrementali, quindi il pannello mostra uno stato "sintetizzando" invece di un cursore finto. Quell'etichetta segue il flag e non la rotta: come in chat, un turno che porta tool non fonde, e un turno di REPL ne porta sempre.
Il costo appare come "non disponibile" quando il prezzo di listino del modello è sconosciuto (mai indovinato), e ogni turno viene aggiunto a <home>/usage.jsonl come nei REPL.
Qui non c'è verifica/ripristino e non c'è /solve: quelli sono andati a chat e assist. I server MCP sono montati, cosa che prima non erano, esattamente per il motivo per cui erano stati negati — l'output MCP è contenuto non fidato per definizione, e ora c'è dove recintarlo. Verifica-o-ripristina gira anche in chimera solve e chimera project.
Se Textual non è installato, tui ricade sul semplice REPL chat, passando ogni argomento esplicitamente perché quel ripiego sopravviva al primo turno. Lì la trasmissione non significa niente, e il thread viene salvato come qualunque altro thread di chat.

`serve` — gateway di messaggistica (HTTP o Discord)

Espone l'agente con una conversazione (e la sua memoria) per chat. Il nucleo di routing è agnostico rispetto al trasporto; gli adattatori si collegano ad esso.

uv run chimera serve --port 8765          # HTTP transport
# GET  /health           -> {"status":"ok","active_chats":N}
# POST /chat  {"text":"...", "chat_id":"alice"}  -> {"reply":"...","chat_id":"alice"}

Ogni chat_id mantiene il proprio contesto, così utenti/thread diversi non si mescolano.

Operazione non presidiata (webhook). Registra un job che scatta su un POST HTTP in entrata, così Chimera gira senza che nessuno digiti — un push GitHub, un evento Stripe, un ping di cron-as-a-service:

chimera cron add "on push" gh-push "Summarize the pushed commits" --webhook
chimera serve                              # then POST to the hook:
# curl -X POST localhost:8765/webhook/gh-push -d '{"ref":"refs/heads/main"}'

Il corpo del POST viene passato al task del job come contesto, e ogni job registrato per quell'hook gira. GET /health e POST /chat continuano a funzionare accanto ad esso.

Discord nativo. Esegui Chimera come bot Discord — ogni canale è una sessione, e l'agente può anche inviare messaggi tramite il tool send_message:

uv sync --extra messaging                 # installs discord.py
export CHIMERA_DISCORD_BOT_TOKEN=...       # bot token (Message Content intent enabled)
uv run chimera serve --discord

Crea il bot su https://discord.com/developers, abilita l'intent Message Content, e invitalo sul tuo server. Risponde in qualsiasi canale che riesce a vedere (filtrato per ignorare i propri messaggi e quelli di altri bot). Il token viene letto dall'ambiente — mai scritto direttamente nel codice.

Telegram nativo. Stesso pattern di adattatore, e non richiede alcuna dipendenza extra (la Telegram Bot API è puro HTTP):

export CHIMERA_TELEGRAM_BOT_TOKEN=...      # from @BotFather
uv run chimera serve --telegram

Slack nativo. Riceve via Socket Mode (richiede l'extra messaging) e invia via la Web API. Abilita Socket Mode sulla tua app Slack per ottenere un token a livello di app:

uv sync --extra messaging
export CHIMERA_SLACK_BOT_TOKEN=xoxb-...     # bot token
export CHIMERA_SLACK_APP_TOKEN=xapp-...     # app-level token (Socket Mode)
uv run chimera serve --slack

WhatsApp (invio). WhatsApp è basato su push (i messaggi arrivano a un webhook Meta che ospiti tu), quindi a differenza degli altri non c'è una connessione da aprire. Imposta le credenziali della Cloud API e l'agente può inviare messaggi WhatsApp tramite il tool send_message in qualsiasi modalità di serve:

export CHIMERA_WHATSAPP_ACCESS_TOKEN=...
export CHIMERA_WHATSAPP_PHONE_NUMBER_ID=...
# in a chat: send_message(platform="whatsapp", chat_id="<E.164 number>", text="done ✅")

WhatsApp bidirezionale. Punta il webhook della tua app Meta verso https://<your-host>/whatsapp e imposta CHIMERA_WHATSAPP_VERIFY_TOKEN (qualsiasi stringa tu scelga, corrispondente alla config dell'app). chimera serve verifica quindi l'iscrizione (GET /whatsapp) e instrada i messaggi in entrata (POST /whatsapp) attraverso il gateway, rispondendo tramite la Cloud API. WhatsApp richiede comunque un URL pubblico per il webhook — quella è l'unica parte fuori da Chimera.

Signal nativo (bidirezionale). Signal non ha un'API ufficiale, quindi Chimera parla con un bridge signal-cli-rest-api che esegui tu (Docker) e colleghi al tuo numero — puro HTTP, nessuna dipendenza Python:

docker run -d -p 8080:8080 -v signal-cli:/home/.local/share/signal-cli bbernhard/signal-cli-rest-api
export CHIMERA_SIGNAL_API_URL=http://localhost:8080
export CHIMERA_SIGNAL_NUMBER=+15550000000     # this bot's registered number
uv run chimera serve --signal

`run` — Tier-1, completion in un colpo solo

Una singola chiamata al modello, senza tool, senza fusione. Il percorso più economico.

uv run chimera run "In one sentence, what is an AI agent?"
uv run chimera run "Summarize this error" --model openrouter/openai/gpt-4o-mini

Visione / incollare immagine. Allega immagini con --image (un percorso o URL, ripetibile) — richiede un modello capace di visione:

uv run chimera run "What's in this chart?" --image chart.png -m openrouter/google/gemini-2.5-flash

`deliver` — Modalità Consegnabile (produce un artefatto)

Dove run/chat rispondono in modo conversazionale, deliver produce un documento completo e autonomo (report, piano, spec, README...) e lo scrive su un file.

uv run chimera deliver "A one-page launch plan for a URL shortener" --out plan.md
uv run chimera deliver "An HTML status page" --format html -o status.html --fuse

`agent` — il loop grezzo di tool-calling ReAct

Pensiero → Azione (tool) → Osservazione, fino a una risposta finale. I tool sono limitati al workspace.

uv run chimera agent "Create a file hello.txt containing 'Hello Chimera'" -w ./scratch

`fuse` — LLM-Fusion (il differenziatore)

Esegue un panel di modelli, un giudice analizza le loro risposte (consenso / contraddizioni / punti ciechi), e un sintetizzatore scrive la risposta finale. Usa --show-panel per vedere la traccia completa.

uv run chimera fuse "Name three concrete ways to prevent SQL injection in Python."
uv run chimera fuse "Compare REST vs gRPC for a mobile backend." --show-panel

La fusione costa ~2-3× una chiamata singola, quindi riservala per il ragionamento difficile. fuse stampa anche il costo in token per fase (panel / giudice / sintesi) così puoi vedere dove vanno davvero i token di un'esecuzione.

Fusione selettiva (ATTIVA per default, risparmia token). Il motore sonda i primi CHIMERA_FUSION_PROBE_K modelli del panel (default 2) e, quando le loro risposte concordano da vicino, salta il resto del panel e il giudice — sintetizzando direttamente dalle risposte concordanti. Il controllo di accordo è un confronto di testo locale economico (nessuna chiamata a modello extra), quindi un turno discordante fa escalation alla pipeline completa e costa esattamente come la fusione completa, mentre un turno concordante è più economico. Regola la soglia con CHIMERA_FUSION_AGREEMENT (0–1, default 0.8), oppure imposta CHIMERA_FUSION_MODE=full (o passa --full) per eseguire sempre l'intero panel + giudice.

Perché è il default: su 3 esecuzioni di chimera fusion-bench --tasks hard (un panel a pagamento di 3 modelli) ha tagliato i token del ~20–28% ed è stato corretto in ogni turno in cui ha effettivamente interrotto in anticipo (16/16). L'accuratezza complessiva ha oscillato da 0 a −8,3pp tra le esecuzioni, ma quella varianza cade interamente nel bucket escalato — dove la modalità selettiva esegue la pipeline identica a quella completa — quindi è non-determinismo del modello, non un costo dell'interruzione anticipata. Esegui il bench sul tuo carico di lavoro per vedere il trade-off per il tuo panel e i tuoi task:

uv run chimera fuse "What is 12 * 12?" --show-panel   # likely early-stops
uv run chimera fusion-bench --tasks hard              # full vs selective, tokens + accuracy

Scegli modelli di panel affidabili. La fusione paga solo se ogni membro del panel risponde davvero. Evita gli slug di modello :free di OpenRouter in CHIMERA_FUSION_PANEL — hanno limiti di frequenza (HTTP 429) sotto carico reale, e il panel si restringe silenziosamente a qualunque modello a pagamento rimanga. Un trio economico e affidabile: openrouter/deepseek/deepseek-chat, openrouter/openai/gpt-4o-mini, openrouter/meta-llama/llama-3.3-70b-instruct.

Skill card (carte di ragionamento TRS, sperimentale)

L'agente distilla ciò che apprende in carte di ragionamento — i cinque campi Trigger / Do / Avoid / Check / Risk (più parole chiave di recupero) — sia dai successi (una carta di pattern) sia dai fallimenti ricorrenti (una carta consultiva di anti-pattern). Quando CHIMERA_SKILL_CARDS=on, solve recupera le top-k carte rilevanti (BM25 su nome + descrizione + trigger) e le inietta nel contesto di ragionamento del worker, così l'agente riusa ciò che ha funzionato ed evita modalità di fallimento note. Questo chiude il ciclo — prima, le skill apprese venivano memorizzate e mai rilette.

Disattivato per default: iniettare carte aggiunge token di prompt, e i risparmi di token del TRS derivano dall'accorciare tracce di ragionamento lunghe, quindi su task a risposta breve il guadagno è in accuratezza, non in costo. Questo non è ipotetico — sulla suite a risposta breve hard (deepseek-v3.1 a pagamento), skillcard-bench ha misurato carte che costano +290% di token e −8pp di accuratezza rispetto a nessuna carta: con un modello vicino al soffitto e senza una traccia lunga da accorciare, le carte generiche sono puro overhead che può distrarre. Abilita le carte per carichi di lavoro a ragionamento lungo (matematica/codice con tracce estese) dove la matematica dei token si inverte, e misura sempre prima il tuo trade-off con un controllo di ground-truth:

uv run chimera skillcard-bench --tasks hard          # demo cards vs no cards
uv run chimera skillcard-bench --use-store --tasks hard   # bench your own learned cards
export CHIMERA_SKILL_CARDS=on CHIMERA_SKILL_CARDS_K=3      # enable, once it earns its place

Il bench riporta l'accuratezza con vs senza carte, il delta di token, il tasso di hit delle carte, e l'accuratezza suddivisa per hit/miss, con un verdetto PASS quando l'accuratezza con carte resta entro 1pp dalla baseline senza carte.

Schema di tool compatti (sperimentale)

Gli schema dei tool — specialmente quelli importati da server MCP o spec OpenAPI — portano rumore di annotazione (esempi, titoli, default, prosa di parametro multi-frase, corpi di richiesta annidati) che viene reinviato al modello a ogni passo ReAct. Con CHIMERA_COMPACT_SCHEMAS=on, quel rumore viene rimosso e le descrizioni dei parametri tagliate al momento della pubblicizzazione, senza toccare nulla che influisca su una chiamata (il nome e la descrizione della funzione, e ogni type / properties / required / enum dello schema sono preservati). Gli schema canonici restano intatti — solo la copia inviata al modello si riduce.

Il risparmio è maggiore su toolset MCP/OpenAPI verbosi e si accumula a ogni passo; i tool nativi sono già concisi, quindi la loro riduzione è piccola. Misura prima il tuo toolset (nessuna chiamata al modello — conta solo i token):

uv run chimera schema-bench --demo                   # synthetic verbose tools, to see the effect
uv run chimera schema-bench --openapi ./openapi.json # your real spec's tools

Disattivato per default. Poiché la compattazione rimuove solo rumore di annotazione (mai la struttura), l'unico rischio è che il modello abbia leggermente meno prosa per scegliere un tool — quindi resta conservativa, e dovresti confermare il comportamento di tool-calling sul tuo carico di lavoro prima di abilitarla.

`solve` — Tier-2 autonomo (piano + verifica-o-ripristina)

Pianifica il task, esegue con il loop dell'agente, poi verifica con un comando eseguibile. Se la verifica fallisce, ripristina il workspace e riprova con feedback. Il verificatore (exit code 0 = successo) è la verità di riferimento.

uv run chimera solve \
  "Create solution.py with add(a,b) and is_prime(n)." \
  --workspace ./work \
  --verify "python -c \"import solution; assert solution.is_prime(7)\""

Flag utili:

Flag	Significato
`--verify "<cmd>"`	comando che deve uscire con 0 (test, una build, un linter)
`--workspace`, `-w`	dove l'agente legge/scrive (default `.`)
`--max-attempts N`	budget di verifica-o-ripristina (default 3)
`--max-steps N`	passi di tool-calling per tentativo (default 8)
`--fuse`	produce il piano via fusione (ragionamento profondo)
`--guard`	regola ogni chiamata di tool attraverso il kernel di governance
`--no-plan` / `--no-manager`	salta la fase di pianificazione / review
`--no-thinking`	chiede al modello worker di rispondere senza una fase di ragionamento (opt-in; il comportamento predefinito non cambia)
`--rubric`	il Manager giudica tramite la rubrica a cascata (seguire l'istruzione → fattualità → razionalità)
`--no-remember`	non scrive automaticamente un fatto di memoria al successo
`--no-evolve-skills`	non propone automaticamente una skill appresa quando un task si ripete
`--isolate`	gira in un git worktree usa-e-getta; i file modificati vengono copiati indietro solo al successo
`--require-diff`	un tentativo che non ha modificato nessun file fallisce e viene riprovato — per un task di codice, una spiegazione non è una correzione
`--keep-workspace`	al fallimento, lascia su disco le modifiche dell'ultimo tentativo invece di ripristinare — per quando un valutatore esterno decide passa/fallisce
`--diff-feedback`	mostra a un tentativo fallito il proprio diff ripristinato, inquadrato come un percorso da non ripercorrere
`--stagnation-fuzzy`	fa corrispondere le firme di fallimento ripetuto in modo approssimativo, così il pivot anti-stallo scatta su fallimenti della stessa causa la cui formulazione differisce

Su --max-steps. Il default di 8 è calibrato per workspace piccoli. Su un repository grande è il vincolo determinante, non il modello: la run 1 di SWE-bench ha segnato uno 0,0pp esatto con 8 passi contro un checkout di 250 MB, e la stessa configurazione a 30 passi ha alzato il tasso di patch della baseline dal 47% al 74% (bench/swe_bench/RESULTS.md). Se l'agente esplora e poi finisce senza modificare nulla, alza prima questo.

--require-diff e --keep-workspace sono per la valutazione esterna. solve è verifica-o-ripristina: quando è lui a possedere la decisione passa/fallisce, ripristinare un tentativo fallito è corretto. Quando è qualcos'altro a possederla — un job CI, un harness di benchmark, un umano che rivede il diff — --keep-workspace impedisce che il lavoro dell'agente venga annullato prima che quel giudice lo veda mai, e --require-diff impedisce che una spiegazione sicura di sé venga valutata come una modifica completata. Entrambi sono disattivati per default.

solve impara tra le esecuzioni. Ogni esecuzione alimenta un ciclo comportamentale chiuso, tutto regolato da verifica-o-ripristina così che solo il lavoro verificato abbia effetto: (1) le lezioni rilevanti dai tentativi passati (i fallimenti sono favoriti) vengono incorporate nel piano/prompt, e il primo passo difettoso di un tentativo fallito viene localizzato e passato al nuovo tentativo; (2) a un successo verificato viene scritto un fatto di memoria deduplicato (richiamato più tardi da chat/crew); e (3) quando un pattern di task si ripete (≥ 2 successi precedenti), viene proposta una skill riutilizzabile — attraverso il panel di fusione e mantenuta per trasferibilità cross-model quando --fuse è attivo — e viene mantenuta solo se supera la validazione di governance e uno smoke test eseguibile.

`crew` — multi-agente Tier-3

Un team di agenti con ruoli collabora su un task e un supervisor sintetizza la risposta finale.

uv run chimera crew "Propose a minimal architecture for a URL shortener service."

`lifecycle` — crew SDLC (pianifica → costruisci → testa → rivedi)

Una pipeline di ciclo di vita del software pre-assemblata con verifica-o-ripristina nella fase di test: plan decompone il task, build lo implementa, test esegue il verificatore (ripristinando e riprovando la build al fallimento), e un revisore critica il risultato.

uv run chimera lifecycle "Add an add(a,b) function to solution.py" \
  --workspace ./scratch --verify "python -c \"import solution; assert solution.add(2,3)==5\""

Ogni fase stampa con un ✓/✗; l'esecuzione è success solo se il verificatore della fase di test è passato.

`meta` — agenti che costruiscono agenti

Progetta il blueprint di un agente specializzato (nome, tool, prompt di ruolo) per un task.

uv run chimera meta "an agent that triages GitHub issues and routes them to teams"

`guard` — verdetto di governance

Mostra la decisione del kernel di fiducia (allow / warn / review / block) per un'azione.

uv run chimera guard "rm -rf /"                       # BLOCK
uv run chimera guard "list the files in this folder"  # ALLOW

`decisions` — quale modello risponde a una decisione tipizzata

Una decisione tipizzata (sì/no, una scelta, un punteggio) riceve risposta da uno di tre backend: local_logprob (un modello piccolo tramite Ollama, il predefinito, gratuito), hosted_verbalized (il giudice della fusione) o openrouter_decisions (un modello System One su OpenRouter). In un'installazione predefinita viene interrogato da solo in un unico punto — le risposte verificate, sotto — e per il resto quando attivi la banda REVIEW della governance o la tool decide, o chiami chimera decide.

uv run chimera decisions models                                   # cosa elenca OpenRouter; * = attivo
uv run chimera decisions use openrouter_decisions typesafe/jev-1.13
uv run chimera decisions use local_logprob                        # torna al predefinito

La stessa scelta è la scheda System One nelle Impostazioni dell'app desktop. Si possono scegliere solo modelli che parlano il contratto di Jev (sì/no, scelta, punteggio); un modello di punteggio dei comportamenti o un alias mobile è elencato e rifiutato. Un modello senza mappa di calibrazione legge la sua confidenza grezza.

Risposte verificate

Una risposta scritta a partire da documenti che hai allegato (la graffetta nella schermata Code, /attach in chat e assist), in un turno che non ha chiamato nessuna tool, viene letta da quel backend prima di uscire: è supportata dai documenti, non supportata o un rifiuto? Supportata con una confidenza di 0,8 o più esce così com'è. Un rifiuto esce così com'è. Il resto va a un modello forte con i documenti e la domanda, viene riletto ed esce se passa; altrimenti esce "le fonti fornite non coprono questo", e la risposta trattenuta resta sulla ricevuta. Misurato nello studio 26 (bench/verified_cascade/RESULTS.md, 400 domande appaiate): le risposte sbagliate consegnate sono scese da 33 a 21 — 11 corrette, 0 peggiorate — a 1,87× il costo con il verificatore locale; il vecchio gate lessicale valeva quanto nessun gate.

Quale verificatore. Il backend scelto sopra. Con quello locale (il predefinito) e senza Ollama o senza qwen3:4b, ripiega su typesafe/jev-1.13 se è impostata una chiave OpenRouter, altrimenti sul vecchio gate lessicale; un backend scelto da te non ha ripiego. La ricevuta nomina il verificatore che ha girato e quelli saltati.
Solo domande. Un messaggio che chiede un'informazione contenuta nei documenti viene verificato. Uno che chiede un lavoro su di essi — riassumere, criticare, tradurre, riscrivere, estrarre, scrivere a partire da esso, valutarlo — passa direttamente, senza verifica e senza la nota di ancoraggio; lo stesso vale per ciò di cui il classificatore non è sicuro e per ogni lingua che non sia portoghese o inglese (chimera/fusion/grounded_question.py; regole e precisione/richiamo in bench/grounded_question_classifier/). Quanto spesso un vero compito verrebbe ancora rifiutato non è ancora misurato.
Il rifiuto parla la tua lingua: quella dell'identità dell'agente, altrimenti quella della domanda, altrimenti l'inglese.
Misurato con gpt-6-luna come redattore. Anche un altro modello viene verificato, ma il suo risultato non è misurato; la ricevuta nomina il redattore.
Dove non si applica. Un turno che ha usato una tool (un router davanti al loop dell'agente ha peggiorato tutti gli esecutori nel bench B4), la modifica del codice e solve, i fatti richiamati dalla memoria (arrivano a ogni turno, che la domanda li riguardi o no) e documenti più lunghi del più grande insieme letto dal bench (14.000 caratteri). La ricevuta dice quale di questi ha escluso il turno.
Se il verificatore fallisce, la risposta esce marcata come non verificata, con il motivo — mai trattenuta e mai mostrata come verificata.
Il modello di escalation è openrouter/openai/gpt-6-sol, quello misurato, quando una chiave OpenRouter lo raggiunge, altrimenti la cima della scala dei tier; CHIMERA_VERIFIED_ANSWERS_ESCALATE_MODEL lo sostituisce.
Spegnere: CHIMERA_VERIFIED_ANSWERS=false, o l'interruttore sulla scheda System One. CHIMERA_VERIFIED_ANSWERS_THRESHOLD (0,8, il valore registrato) sposta la soglia.

`bench` — benchmark di evoluzione continua

Misura se le prestazioni reggono lungo una catena di task (la prova anti-degradazione): tasso di successo complessivo, prima metà vs seconda metà, striscia più lunga.

uv run chimera bench --limit 6           # single-shot task set
uv run chimera bench --chain --limit 6   # stateful chain (error propagation)
uv run chimera bench --fuse              # use fusion as the solver

Il report porta anche una flag di degradazione statisticamente onesta: invece di fidarsi di una semplice sottrazione prima-meno-seconda-metà (su una catena corta un'oscillazione di 0,2 è di solito rumore), degraded_significant è 1.0 solo quando un intervallo di confidenza di Wilson sul calo esclude lo zero, -1.0 quando il campione è troppo piccolo per dirlo, e 0.0 altrimenti — più i limiti degradation_ci_low/high. Separatamente, CHIMERA_SKILL_ACCEPT_MODE=wilson condiziona la decisione di accettazione skill cross-model al limite di confidenza inferiore del tasso di trasferimento (così un 2-su-3 fortunato non conta più); il default point mantiene il tasso grezzo, dato che il limite di Wilson è rigoroso su panel minuscoli.

`sandbox-bench` — valutazione di stato + effetto collaterale

I bench testuali valutano la risposta del modello; questo valuta ciò che l'agente ha fatto. Ogni task gira in una directory sandbox isolata, e l'harness confronta lo stato finale dei file con l'obiettivo (qualsiasi percorso consentito, stile risultato) e separatamente conta gli effetti collaterali dannosi — mutazioni fuori dall'insieme consentito dichiarato per il task. Così un agente che produce il risultato giusto mentre distrugge un file non correlato viene beccato, non valutato come un successo pulito.

uv run chimera sandbox-bench            # runs the demo stateful tasks (real models + file tools)

Riporta pass_rate e side_effect_rate. Include la metodologia (uno StatefulTask con goal_check + insieme allowed di mutazione), non una grande suite di task — scrivi task per i tuoi stessi tool. I valutatori testuali esistenti restano corretti per lavoro puramente di domanda-risposta.

`memory` — memoria a lungo termine curata

uv run chimera memory add "Alex prefers TypeScript strict and absolute imports"
uv run chimera memory search "imports"
uv run chimera memory list
uv run chimera memory graph                 # entity-relation graph from memory
uv run chimera memory graph --entity PassaPro   # one entity's relations
uv run chimera memory prune --max 50        # keep the N highest-value memories (multi-factor)

Il richiamo passa attraverso un gate di ammissione (un confine di fiducia): una memoria richiamata entra nel prompt solo se è rilevante e priva di testo di override/injection (difesa da jailbreak basato sulla memoria). memory prune dimentica sotto un budget tramite un modello di valore multifattoriale (recenza, specificità, tipo, curatela, affidabilità) — non un singolo criterio.

Il livello a grafo estrae triple (fonte, relazione, target) dalle tue memorie (PassaPro uses Supabase, Alex prefers TypeScript), così i fatti possono essere richiamati per entità, non solo per parola chiave.

La cronologia delle conversazioni è un archivio a parte. Ogni turno di codice che termina nella schermata Code viene indicizzato — il messaggio, la risposta, i file letti o modificati, quando — in <home>/history.db (SQLite, FTS5 quando il tuo Python lo ha), e resta lì dopo che la trascrizione della conversazione ha tagliato i turni più vecchi. L'agente lo cerca con lo strumento recall_history ("cosa abbiamo deciso sulla funzione di login due settimane fa?"), limitato al progetto corrente salvo richiesta per tutti i progetti. Un turno eseguito su contenuto non attendibile viene etichettato al richiamo, una credenziale incollata viene oscurata prima della scrittura, ed eliminare una conversazione elimina le sue righe.

`cron` — job pianificati & SOP di evento

uv run chimera cron add daily-report "0 9 * * *" "generate the daily report"
uv run chimera cron list

`kanban` — bacheca dei task con corsie per worker

Una bacheca (backlog → doing → review → done) dove ogni card nomina una corsia che la dispaccia allo stack dell'agente: solve (autonomo Tier-2, verifica-o-ripristina) o crew (pipeline di ruoli Tier-3). La vista operativa del loop che l'agente già esegue.

uv run chimera kanban add "Fix the flaky test" -a "make test_login deterministic" \
  --lane solve --verify "pytest -q tests/test_login.py"
uv run chimera kanban add "Compare REST vs gRPC" --lane crew
uv run chimera kanban board                 # show the columns
uv run chimera kanban run -w ./scratch      # dispatch backlog cards through their lanes
uv run chimera kanban move <id> done        # manual move
uv run chimera kanban learn --min 3 --yes   # recurring tasks (experience) -> cards

run percorre ogni card backlog → doing → done (successo) oppure → review (richiede attenzione). learn riusa il rilevatore di ricorrenza del cron-learner per accodare i task che l'agente ripete (deduplicati contro la bacheca) — pianificalo per riempire automaticamente il backlog.

`workflow` — loop progettati (Loop Engineering)

Scrivi un loop autonomo come YAML invece di un prompt improvvisato. Ogni passo uses una capacità (run / shell / solve / crew / lifecycle), può essere condizionato al passo precedente (when: prev_succeeded | prev_failed), e può ripetersi (repeat, until: success).

# examples/workflow.yaml
name: build-and-report
steps:
  - name: build
    uses: solve
    with: { task: "Create greeting.py with greet(name)", verify: "python -c \"import greeting\"" }
    repeat: 2
    until: success
  - name: report
    uses: run
    when: prev_succeeded
    with: { prompt: "One-line changelog for greet()" }

uv run chimera workflow examples/workflow.yaml --workspace ./scratch

`drift` — gate di drift spec↔codice

Mantiene allineati una spec e il codice. Una spec è un piccolo YAML di requisiti (defines un simbolo / contains una regex / absent una regex / command esce con 0). Il gate esce con codice diverso da zero in caso di drift, quindi funge anche da verificatore.

uv run chimera drift examples/spec.yaml --workspace ./scratch
# as a verifier inside solve:
uv run chimera solve "..." --verify "chimera drift examples/spec.yaml -w ."

`migrate` — importare da un altro agente

Porta config + skill da Hermes o OpenClaw, e con --apply fa anche il merge della memoria a lungo termine (deduplicata, non distruttiva). Il default è un'anteprima dry-run.

uv run chimera migrate hermes /path/to/hermes/home          # preview
uv run chimera migrate hermes /path/to/hermes/home --apply  # write + merge memory
uv run chimera migrate openclaw /path/to/openclaw/home --apply

Il merge della memoria riporta i conteggi {ADD, UPDATE, NOOP} — i duplicati diventano NOOP, quindi rieseguire è sicuro.

`evolve` — evoluzione del modello opt-in (avanzato)

chimera solve --collect (attivo per default) registra ogni esecuzione come traiettoria. I comandi evolve la trasformano in dataset pronti per il training e una recipe LoRA eseguibile. Il training è esterno e opt-in — cambia i pesi del modello, quindi non avviene mai automaticamente; Chimera prepara i dati e uno script e si ferma.

chimera evolve status                          # is there enough signal to train?
chimera evolve export --format sft --out d.jsonl --min-steps 5 --diverse   # long-horizon, one example per task
chimera evolve export --format dpo --out d.jsonl   # preference pairs (success vs failure)
chimera evolve recipe --out ./recipe --format dpo  # train.py + README + requirements
chimera evolve tune --rounds 2                  # self-optimize the agent spec (no weights changed)

export accetta manopole di recipe: --min-steps N mantiene solo tracce a lungo orizzonte, --diverse mantiene al massimo un esempio per task (la diversità dei task è il collo di bottiglia della curatela), e --min-process P (SkillCoach) mantiene solo tracce il cui punteggio di aderenza al processo ≥ P — la frazione di passi di tool che ha prodotto un risultato riuscito e visibile — così un successo fortunato che si è dibattuto tra chiamate di tool fallite non entra nel training. Gli eventi per singolo passo dietro quel punteggio sono catturati automaticamente a ogni esecuzione di solve; il filtro è disattivato per default (CHIMERA_SFT_MIN_PROCESS imposta un default globale). evolve tune è diverso dal training — esegue una meta-ricerca sulla spec dell'agente (modello, prompt di sistema, budget di passi, panel, profondità di memoria), valutando ogni candidato sugli scenari giornalieri e mantenendo una modifica solo in caso di non-regressione. Chiama modelli ma non cambia mai i pesi, quindi è sicuro da eseguire in qualsiasi momento.

Poi, per addestrare davvero, su una GPU (o Colab): pip install chimera-agent[train] (o il requirements.txt della recipe) e python recipe/train.py. Punta CHIMERA_DEFAULT_MODEL verso il modello base + adapter quando servi.

`pet` — un compagno virtuale

Un piccolo compagno persistente le cui statistiche cambiano mentre sei via. Non serve alcuna chiave.

chimera pet new --name Chimi      # adopt one
chimera pet status                # check in (fullness / happiness / energy / mood)
chimera pet feed | play | rest    # interact

Consigli

Tool vs ragionamento. I turni di tool-calling usano sempre un singolo modello (la fusione non può chiamare tool); la fusione è riservata al ragionamento profondo senza tool.
Ispeziona cosa è successo. CHIMERA_LOG_LEVEL=DEBUG mostra i log di routing e di attivazione della fusione.
Mantieni i test onesti. Un buon comando --verify (una vera suite di test) rende solve affidabile — è la verità di riferimento eseguibile a cui l'agente è sottoposto.

Modifica questa pagina su GitHub