spectre — zsh — it

whoami

Spectre — un runtime OTP-native per agenti che restano comprensibili, governabili e recuperabili. Questo sito ci gira sopra.

cat manifesto.md

Costruisci un solo agente Elixir. Dagli solo i poteri che gli servono.

Spectre affida a un solo agente supervisionato il proprio stato e ciclo di vita. Le librerie spectre_* opzionali aggiungono capacità come memoria, pianificazione, scelta del modello, canali o browser: sono poteri dello stesso agente, non agenti diversi.

01 / propose

Il modello non esegue mai

Può proporre un lavoro; policy deterministiche e la tua applicazione decidono cosa è permesso e quando eseguire un effetto collaterale.

02 / compose

Capacità, non altri agenti

Installa solo i poteri che servono a un agente. Ogni pacchetto ha un compito e non diventa mai un secondo agente nascosto.

03 / evolve

Il miglioramento resta governato

L'agente può imparare dall'esperienza e proporre una definizione più sicura; valutazione, revisione, approvazione, attivazione e rollback restano espliciti.

ls -1 posts/ | wc -l 13 github.com/elchemista/ex_blog

$

man spectre

La filosofia di Spectre

spectre/README.md

Un agente è un sistema supervisionato, non un prompt né un modello travestito. Spectre dà a ogni agente un solo proprietario canonico dello stato, messaggi espliciti a ogni confine e un recupero progettato fin dall'inizio — come OTP tratta tutto il resto.

Il modello propone

Non può saltare una policy, inventarsi autorità o eseguire da solo un effetto collaterale.

Il routing è una manopola

Scegli regex, evidenza semantica o un modello; dopo quella scelta il ciclo di vita resta deterministico.

Il comportamento durevole è fatto di dati

Skill e proposte create a runtime possono riferirsi solo a operazioni già registrate dall'host; i dati non diventano mai codice eseguibile.

cat POLICY.md

Tutto ciò che è protetto passa da un solo confine:

  • modelli e route possono proporre lavoro
  • il lavoro protetto deve passare da una policy deterministica
  • l'approvazione cambia lo stato ma non esegue il lavoro
  • l'esecuzione avviene solo tramite una chiamata esplicita dell'host
  • ogni esito finale viene restituito come dato

Un agente Spectre deve leggersi come una mappa, non come un trucco di magia.

support_agent.ex elixir

L'agente sta tutto in un modulo: il modello, il router, un'azione protetta e la policy che la sorveglia.

defmodule MyApp.SupportAgent do
  use Spectre.Agent

  model(MyApp.LLM, purpose: :smart)
  router(via: [:regex, :embedding, :llm_classifier])

  actions MyApp.SupportActions do
    protect(:delete_account, with: :delete_account_confirmation)
  end

  policy :delete_account_confirmation do
    request(:confirm_delete_account)
    accept(:confirmed_delete, regex: ~r/^yes, delete it$/i)
    reject(:cancel_delete, regex: ~r/^(no|cancel)$/i)
    attempts(3, then: :cancel_pending)
  end

  interrupt :HELP, regex: ~r/^(help|menu)$/i do
    reply(:help)
  end
end
$ spectre trace --this-site

Ogni articolo qui sotto è passato da questo percorso.

one blog agent — una sola identità · un solo ciclo di vita
├── spectre_beam — capacità canale
├── spectre_prism — capacità di scelta del modello
├── spectre_kinetic — capacità di pianificazione
├── spectre_lens — capacità browser
├── skills — reader · editorial · operations
└── spectre core — routing · stato · policy · effetti
└── writer → git → ets — la pagina che stai leggendo
$ why --like-this

Il routing è una manopola, non un dogma: regex, un dataset o un classificatore LLM completo. Quello che succede dopo la decisione resta deterministico.

Preso in prestito dai router di Phoenix, dagli schema Ecto, dai worker Oban e dagli alberi di supervisione OTP. Non un framework in cui sparire.

Niente SQL. I contenuti stanno su GitHub, Phoenix serve una proiezione ETS e l'agente chiede prima di scrivere.

github.com/elchemista/ex_blog — questo sito, open source

$ spectre reflect --propose

man spectre-morph

Come un agente può migliorarsi

Spectre 0.3.2 può registrare esperienza esplicitamente abilitata e ripulita dai dati sensibili, ispezionare la definizione attiva dell'agente e proporre modifiche circoscritte a skill o configurazione. La proposta è un dato inerte: non può pubblicare, approvare né attivare sé stessa.

  1. 01 / observe

    Esperienza

    L'host sceglie esplicitamente di registrare evidenza limitata, oscurando i valori sensibili.

  2. 02 / reflect

    Riflessione

    Spectre confronta ciò che è stato dichiarato, ciò che è attivo e ciò che è stato osservato.

  3. 03 / propose

    Proposta

    Forge può suggerire una modifica circoscritta, ma quella proposta non ha alcuna autorità propria.

  4. 04 / govern

    Valutazione e attivazione

    Test protetti, revisione, approvazione, attivazione e rollback sorvegliano ogni modifica.

Migliorarsi non significa auto-autorizzarsi: valutazione, revisione umana quando richiesta, attivazione e rollback restano fuori dal modello.

ls -1 spectre*

Un solo core, poteri opzionali

10 librerie

cat STACK.md

Restano un solo agente, una sola identità e un solo ciclo di vita. I pacchetti spectre_* qui sotto sono librerie specializzate installabili come capacità — memoria, pianificazione, percezione via browser, scelta del modello, canali o protocolli. Non creano una squadra di agenti specialisti.

Installare un pacchetto rende soltanto disponibile una capacità. Un Flow, Work, Skill o una policy deve comunque collegarla in modo esplicito, mentre l'host conserva autorizzazione ed effetti collaterali.

spectre base · runtime

Il core OTP-native: un solo proprietario dello stato, ciclo di vita e governance espliciti. Ogni potere opzionale si collega a questa base.

github.com/elchemista/spectre

spectre_mnemonic capacità · memory

Motore di memoria semantica: memoria di lavoro in ETS, richiamo durevole, osservazioni tipizzate e modelli mentali.

github.com/elchemista/spectre_mnemonic

spectre_ledger capacità · checkpoints

Checkpoint durevoli in sola aggiunta per gli agenti Spectre: lo stato sopravvive a un crash.

github.com/elchemista/spectre_ledger

spectre_kinetic capacità · planning

Toolkit di pianificazione Elixir-first: entra Action Language, escono chiamate validate. Nessuno schema JSON nel prompt.

github.com/elchemista/spectre_kinetic

spectre_pulse capacità · protocol

Protocollo indipendente dal trasporto per agenti che parlano con altri agenti.

github.com/elchemista/spectre_pulse

spectre_directive capacità · missions

Un mission loop incorporabile per agenti Elixir.

github.com/elchemista/spectre_directive

spectre_lens capacità · browser

Lente browser pensata per gli agenti, su Lightpanda: l'agente può leggere quello che ha pubblicato.

github.com/elchemista/spectre_lens

spectre_prism capacità · models

Sceglie il modello per ogni richiesta tra OpenAI, OpenRouter, Ollama e Gemini, applicando i limiti di privacy, contesto, costo e latenza prima della chiamata.

github.com/elchemista/spectre_prism

spectre_beam capacità · channels

Il confine con i canali esterni: normalizza gli eventi dei provider e consegna i messaggi in modo idempotente.

github.com/elchemista/spectre_beam

spectre_lab capacità · debugging

Esegui il debug degli agenti Spectre con il replay dei checkpoint e strumenti di test isolati, lontano dalla produzione.

github.com/elchemista/spectre_lab

$ spectre status --ecosystem

curl -s spectre_ecosystem/status.json

Compatibilità con il core attuale

Ogni libreria satellite viene ricompilata e testata contro il commit su cui è oggi il core di Spectre. La tabella è il risultato pubblicato di quella esecuzione, non una promessa: questa pagina la rilegge una volta al giorno e mostra esattamente ciò che è tornato.

10 librerie verificate 10 passate

elchemista.github.io/spectre_ecosystem — il report completo, aggiornato dalla sua esecuzione pianificata

Sotto questo sito girano anche: vettore, ex_fastembed, ex_gram.

ls -lat posts/

Ultime pubblicazioni

Appunti scritti costruendo tutto quello che sta qui sopra.

13 file
posts/it/il-tuo-agent-ai-e-pronto-per-il-gdpr.md

cat posts/it/il-tuo-agent-ai-e-pronto-per-il-gdpr.md

Il tuo Agent AI è davvero pronto per il GDPR?

La risposta più facile arriva in pochi secondi. Il provider è sicuro, i dati non vengono usati per addestrare il modello e sul sito esiste una privacy policy. Sembra rassicurante, almeno fino a quando il DPO fa una doman

#AI Governance 10 min it apri
posts/it/beam-vm-elixir-agenti-ai-seri.md

cat posts/it/beam-vm-elixir-agenti-ai-seri.md

BEAM non è nata per l'AI, ma sembra fatta apposta per gli agenti seri

Quando ho iniziato a costruire Spectre, scegliere Elixir per un progetto legato all'intelligenza artificiale sembrava quasi una provocazione. Nel mondo AI il percorso più comune è già tracciato. Si parte da Python, si ar

#Sviluppo software 10 min it apri
posts/it/skill-non-e-file-markdown-come-e-nato-spectre.md

cat posts/it/skill-non-e-file-markdown-come-e-nato-spectre.md

Una skill non è un file Markdown: il ragionamento che mi ha portato a Spectre

Quando ho iniziato a pensare alla costruzione di un Agent, le skill esistevano già. Strumenti come Codex, Claude e altri sistemi agentici utilizzavano skill costruite intorno a istruzioni in Markdown, a volte accompagnat

#Sviluppo software 12 min it apri
posts/it/agent-enterprise-spectre-controllo-sicurezza.md

cat posts/it/agent-enterprise-spectre-controllo-sicurezza.md

Un Agent enterprise non è un chatbot con le credenziali di produzione

Un chatbot che sbaglia una risposta crea una conversazione imbarazzante. Un Agent con credenziali di produzione che sbaglia crea un incidente. È in quella distanza che nasce il problema enterprise. Non quando aggiungiamo

#Software Development 14 min it apri
posts/it/deepseek-harness-vs-spectre-plugin-o-kernel.md

cat posts/it/deepseek-harness-vs-spectre-plugin-o-kernel.md

Quando anche le leggi della fisica sono plugin: DeepSeek Harness vs Spectre

"Everything is a plugin" è una frase irresistibile per uno sviluppatore. Promette libertà. Cambia il modello, cambia il registry dei tool, cambia il database, cambia il loop. Se una scelta non ti piace, la sostituisci da

#Software Development 14 min it apri
posts/it/umani-governano-loop-spectre-streaming-0-3-2.md

cat posts/it/umani-governano-loop-spectre-streaming-0-3-2.md

Gli umani devono governare il loop, non eseguirlo

Abbiamo costruito Agent capaci di lavorare per ore. Poi abbiamo assunto un umano per premere "Continue" ogni trenta secondi. Complimenti. Abbiamo automatizzato il lavoro creando un nuovo lavoro. Una collection di daily.d

#Sviluppo software 12 min it apri
posts/it/non-fidarti-del-modello-testare-agenti-spectre-come-software.md

cat posts/it/non-fidarti-del-modello-testare-agenti-spectre-come-software.md

Non fidarti del modello: testare un agente Spectre come software

Un agente ha prodotto la risposta corretta. Il test passa. Ma ha chiamato il modello tre volte quando non serviva? Ha preparato un'azione distruttiva prima dell'approvazione? Ha eseguito due volte la stessa operazione do

#Sviluppo software 15 min it apri
posts/it/spectre-morph-creare-un-agente-che-evolve.md

cat posts/it/spectre-morph-creare-un-agente-che-evolve.md

Spectre Morph: creare un agente che evolve senza riscriversi

«Un agente che si modifica da solo» fa venire in mente quasi sempre l'immagine sbagliata. Sembra un modello che apre i propri file sorgente, riscrive un prompt, aggiunge un tool e si riavvia con più potere di quello che

#Sviluppo software 18 min it apri
posts/it/agente-spectre-news-lens-kinetic-action-language.md

cat posts/it/agente-spectre-news-lens-kinetic-action-language.md

Costruire un agente Spectre utile con Lens, Kinetic e Action Language

Molte demo di agenti terminano quando il modello chiama una funzione. È sufficiente per dimostrare che il tool calling funziona, ma non basta per spiegare perché serva il runtime di un agente. I problemi interessanti ini

#Sviluppo software 15 min it apri
posts/it/un-turn-non-e-una-chiamata-al-modello-spectre-otp-policy.md

cat posts/it/un-turn-non-e-una-chiamata-al-modello-spectre-otp-policy.md

Un Turn non è una chiamata al modello: come Spectre governa gli agenti con OTP

In molti framework per agenti, un turno inizia quando l'input raggiunge un modello e termina quando il modello ha finito di chiamare tool e ha prodotto una risposta. Io ho iniziato Spectre partendo da una domanda diversa

#Sviluppo software 13 min it apri
posts/it/l-agente-dovrebbe-esistere-nel-codice-non-nel-prompt.md

cat posts/it/l-agente-dovrebbe-esistere-nel-codice-non-nel-prompt.md

L’agente dovrebbe esistere nel codice, non nel prompt

La maggior parte degli agenti esiste principalmente dentro un prompt. L'applicazione che li circonda può essere scritta in Python, TypeScript o Elixir, ma l'agente stesso è spesso un lungo messaggio di sistema: chi è, co

#Sviluppo software 11 min it apri
posts/it/iniziare-con-spectre.md

cat posts/it/iniziare-con-spectre.md

Iniziare con Spectre: il tuo primo agente non è un loop

La maggior parte dei tutorial sugli agenti inizia con una chiamata a un modello. Invii un prompt, descrivi due strumenti, stampi la risposta e la demo funziona. Spectre ti chiede di iniziare da un altro punto. Prima di s

#Sviluppo software 14 min it apri
posts/it/costruire-un-agente-per-un-blog-con-spectre.md

cat posts/it/costruire-un-agente-per-un-blog-con-spectre.md

Costruire un agente per un blog con Spectre, non attorno a un loop magico

Non ho costruito Spectre perché fosse difficile chiamare un LLM da Elixir. Quella parte è facile. Invii una richiesta, passi alcuni messaggi, descrivi qualche funzione e aspetti che il modello restituisca una tool call.

#Sviluppo software 11 min it apri