La memoria ricorda. Le competenze codificano. Il fine-tuning riaddestra. I gateway smistano.
Duplex chiude il ciclo.
La maggior parte dell’infrastruttura di IA risolve una parte del lavoro. Duplex riunisce ogni parte in un’unica intelligenza a runtime che continua a migliorare mentre lavora.
Confronto aggiornato al 16 ottobre 2026.
Ognuno risolve una parte.
Le piattaforme di memoria conservano informazioni. L’apprendimento di competenze trasforma l’esperienza in istruzioni. Il fine-tuning cambia i pesi del modello. I gateway di IA instradano le richieste e applicano guardrail. Duplex riunisce tutto, e continua a migliorare.
Passaggio 1 su 5: Memoria
Tutte le capacità, fianco a fianco.
Scegline uno da affiancare a Duplex, o vedili tutti insieme.
- Nativo
- Integrato nel funzionamento di base del prodotto.
- Esterno
- Lo fornisci tu, o lo assembli, a parte.
- Non nativo
- La documentazione del prodotto non lo elenca come funzionalità integrata. Una soluzione su misura potrebbe comunque essere possibile.
Affianca a Duplex:
| Capacità | Duplex | Letta | CopilotKit CLiF | Deeplake Hivemind | Piattaforme di memoriaMem0, Zep, AgentCore Memory e Supermemory | Fine-tuning e RFT | Gateway di IAPortkey, LiteLLM e simili |
|---|---|---|---|---|---|---|---|
| Cosa è ciascuno | |||||||
| Cos’è | Un’intelligenza a runtime accanto alla tua IA: impara e agisce per i tuoi agenti e assistenti, entro le tue regole | Una piattaforma di agenti con stato, costruita su memoria persistente e apprendimento nello spazio dei token | Una pipeline full-stack che trasforma le traiettorie in competenze, valutazioni e dati di addestramento | Memoria condivisa per agenti che trasforma automaticamente le tracce in competenze | Contesto persistente, fatti, episodi e grafi di conoscenza | Adattare un modello addestrandolo | Instradamento dei modelli, affidabilità, guardrail e osservabilità |
| Ciò che porta avanti | Contesto, decisioni, esiti, regole, compiti, competenze e ciò che ha imparato | Memoria degli agenti, conversazioni, file e competenze | Thread, traiettorie, insight, competenze e valutazioni | Sessioni, ricordi e competenze, limitati a un’area di lavoro | Fatti, messaggi, riassunti, episodi e relazioni del grafo | Un nuovo insieme di pesi del modello | Configurazione, log, policy di instradamento e cache |
| Cosa migliora con l’esperienza | Le sue prossime decisioni: certezza, instradamento, raccomandazioni, uso degli strumenti e conoscenza riutilizzabile | Il comportamento futuro dell’agente, tramite memoria aggiornata e competenze apprese | Le istruzioni dell’agente, tramite competenze revisionate tratte da flussi di lavoro reali | Il comportamento della sessione successiva, tramite competenze distillate | Soprattutto il contesto dato alla prossima chiamata al modello | Le risposte del modello sottostante | Instradamento e affidabilità delle richieste, non ciò che l’agente ha imparato |
| Sapere cosa è successo, e imparare da questo | NativoSa cosa è successo, e impara cosa cambiare dopo | Ci sono entrambi, soprattutto tramite memoria e competenze nello spazio dei token | L’apprendimento è generato da traiettorie archiviate | La memoria condivisa diventa competenze riutilizzabili | Soprattutto memoria; quanto impara varia secondo il fornitore | Apprendimento senza una memoria operativa duratura | Controllo operativo senza apprendimento continuo |
| Apprendimento | |||||||
| Apprendimento continuo senza riaddestramento | NativoContinua a imparare, fuori dai pesi del tuo modello | NativoApprendimento nello spazio dei token e di competenze | NativoApprendimento di competenze; i dati per il fine-tuning sono facoltativi | NativoApprendimento di competenze dalle tracce | Miglioramento tramite il contesto; la profondità varia secondo la piattaforma | NoImpara attraverso l’addestramento | Non nativo |
| Adattamento turno per turno | NativoOgni nuovo risultato può cambiare subito la decisione successiva | La memoria gestita dall’agente può cambiare di continuo; l’apprendimento di competenze segue l’esperienza conclusa | L’analisi si avvia a mano o su pianificazione | Le competenze vengono distillate in background o a fine sessione | I ricordi si possono aggiungere di continuo, ma recuperarli non è adattarsi | Aspetta che un addestramento finisca e che il nuovo modello sia rilasciato | L’instradamento cambia subito, ma non in base a esiti appresi |
| Imparare dalle correzioni | NativoUna correzione cambia ciò che Duplex fa dopo | Le correzioni possono aggiornare la memoria o alimentare competenze apprese | Le modifiche degli utenti e le azioni nell’app alimentano il suo apprendimento | Correzioni e tracce di sessione possono diventare competenze | Le correzioni possono essere archiviate e recuperate come contesto | Le correzioni devono entrare in un dataset di addestramento o in una pipeline di ricompensa | Di solito registrate nei log; imparare da esse è esterno |
| Imparare dagli esiti | NativoSuccessi e fallimenti tornano dritti in ciò che impara | Possibile tramite riflessione sulle traiettorie e aggiornamenti gestiti dall’agente | Gli esiti di tutto lo stack diventano insight, competenze, valutazioni e dati di addestramento | Le nuove competenze vengono ricavate dalle sessioni concluse | Gli episodi si possono richiamare, ma imparare dagli esiti è in genere esterno | NativoQuando gli esiti si possono trasformare in ricompense | Gli esiti compaiono nella telemetria; imparare da essi è esterno |
| Imparare dalle ricompense | NativoUna ricompensa rafforza ciò che ha funzionato e corregge ciò che non ha funzionato | Le ricompense non sono il suo modo principale di imparare | Può produrre dati per il fine-tuning da traiettorie valutate | Le ricompense non sono il suo modo principale di imparare | Le ricompense non sono una funzionalità standard della memoria | NativoLe ricompense ottimizzano i pesi del modello | Non nativo |
| Il merito dei passaggi che portano a un risultato | NativoCapisce quali azioni precedenti hanno portato a un risultato successivo | Letta non lo offre in modo nativo a runtime | L’analisi delle traiettorie può far emergere schemi utili nei flussi di lavoro | L’analisi delle tracce può trovare procedure riutilizzabili | Non nativo | Può imparare correlazioni dagli esempi di addestramento, ma non può ricondurre un risultato in produzione ai suoi passaggi | Non nativo |
| Come le azioni fanno avanzare il lavoro | NativoImpara come ogni azione porta il lavoro da uno stato al successivo | L’agente può dedurlo dal contesto | Può trasformare i flussi di lavoro in competenze | Può catturare procedure riuscite come competenze | Gli episodi archiviati possono servire da esempi | Può assorbire questi schemi durante l’addestramento | Non nativo |
| Prevedere cosa farà un’azione | NativoDa ciò che osserva, prevede cosa farà un’azione, prova alternative e pianifica | Il modello ragiona sulla memoria | EsternoLasciato al framework degli agenti | Non nativo | Non nativo | Implicito nel modello addestrato, dove non puoi modificarlo | Non nativo |
| Scelte d’azione migliori | NativoGli esiti migliorano l’azione che sceglie dopo | Il comportamento migliora tramite memoria e competenze | Competenze revisionate migliorano le prossime istruzioni dell’agente | Competenze distillate migliorano le procedure successive | Il contesto recuperato può influenzare il comportamento in modo indiretto | NativoOttimizzando il modello | Le policy di instradamento si configurano, non si apprendono dagli esiti |
| Competenze riutilizzabili | NativoL’esperienza diventa competenze testate prima dell’uso, che si possono sospendere, ripristinare o ritirare | NativoLe traiettorie possono diventare competenze durature che funzionano con qualsiasi modello | NativoLe traiettorie diventano competenze revisionate, supportate da evidenze | NativoLe sessioni diventano file skill.md per l’area di lavoro | Dipende dal fornitore; in genere non è ciò attorno a cui è costruita la categoria | La conoscenza viene assorbita nei pesi, non confezionata come competenze portabili | Non nativo |
| Testare e gestire le competenze | Una competenza viene testata prima di farci affidamento, e si può sospendere, ripristinare, ritirare o rimuovere per sempre | Le competenze sono file che puoi ispezionare, gestire e versionare | Pubblicate dopo una revisione umana, distribuite in una versione fissata | Le competenze restano file che puoi ispezionare e modificare, collegati alle sessioni da cui provengono | Di solito un ciclo di vita per record, non per competenza | La valutazione avviene attorno ad addestramento e rilascio | Versioni della configurazione, non un ciclo di vita per competenze apprese |
| Generalizzare a casi affini | Porta ciò che ha imparato a casi affini e a nuove formulazioni, e in competenze che può riutilizzare | Le competenze nello spazio dei token generalizzano procedure tra compiti diversi | Le competenze catturano schemi su molte traiettorie di produzione | Le competenze catturano schemi ricorrenti tra le sessioni | Il recupero semantico trova informazioni affini, il che non equivale a generalizzare un comportamento | Generalizza tramite i pesi addestrati | Le cache semantiche riconoscono richieste simili, ma non imparano come agire |
| Decidere e agire | |||||||
| Sapere quanto è sicuro | NativoPrima di ogni decisione, sa quanto il caso è noto e quanto è sicuro | Soprattutto il giudizio del modello e quanto è pertinente la memoria | Guidato dalla valutazione, non una misura in tempo reale della certezza | Quanto sono pertinenti recupero e competenze, non una misura della certezza | Punteggi di recupero e segnali di pertinenza | La fiducia del modello va misurata a parte | Salute dei fornitori, instradamento e punteggi dei guardrail, non certezza sul compito |
| Rispondere, passare la mano o rifiutare | NativoDuplex risponde da sé, chiama il tuo modello, usa uno strumento o rifiuta, entro le tue regole | L’agente di solito prosegue tramite il ragionamento del modello | EsternoL’agente host decide come agire | EsternoL’agente host decide come agire | EsternoL’applicazione host decide come agire | Il modello addestrato gira comunque a ogni richiesta | Instradare, ritentare, bloccare o ripiegare, senza imparare dagli esiti |
| Rispondere da sé al lavoro noto | NativoPrende da solo le decisioni note, senza un’altra chiamata a un modello di frontiera | Il modello interpreta comunque memoria o competenze | Il modello legge comunque la competenza appresa | Il modello legge comunque la competenza appresa | Il modello di norma legge il contesto recuperato | Il modello adattato gira comunque | Una cache può saltare una chiamata al modello, ma una cache non impara dagli esiti |
| Passare la mano su ciò che è nuovo o incerto | Il lavoro nuovo, incerto o sensibile va al modello, allo strumento o alla persona giusti | L’agente e il modello decidono quando serve più aiuto | EsternoIl compito dell’agente host | EsternoIl compito dell’agente host | EsternoIl compito dell’applicazione | EsternoIl compito dell’applicazione | Instradamento e fallback solidi tra fornitori; la certezza sul compito resta esterna |
| Pianificazione, simulazione e raccomandazioni | NativoPrevede cosa succede dopo, prova alternative, costruisce piani e raccomanda azioni | Soprattutto tramite il ragionamento del modello e gli strumenti dell’agente | EsternoIl compito dell’agente host | EsternoIl compito dell’agente host | La memoria fornisce il contesto; la pianificazione resta esterna | Il modello forse pianifica meglio, ma lo stato del lavoro resta esterno | Non nativo |
| Molti agenti, al lavoro insieme | Manda il lavoro all’agente giusto, lo suddivide entro le tue regole, tiene ogni agente nel suo ambito e riunisce i risultati | Agenti, subagenti e memoria condivisa sono disponibili | Funziona con i framework di agenti supportati | Condivide le lezioni tra agenti collegati | La memoria condivisa può servire più agenti | Non nativo | Alcuni instradano verso agenti e strumenti MCP, ma non imparano quale collaborazione ha funzionato |
| Imparare quali strumenti funzionano | Impara quali strumenti funzionano, quando usarli e a cosa porta ciascuno | Competenze e memoria possono migliorare l’uso degli strumenti | Le traiettorie full-stack catturano le azioni di strumenti e utenti per nuove competenze | Le tracce degli strumenti possono diventare procedure riutilizzabili | I risultati degli strumenti si possono ricordare | Il comportamento degli strumenti può migliorare con l’addestramento | Espongono e instradano gli strumenti, ma in genere non imparano dai loro esiti |
| Azioni degli strumenti entro le tue regole | Gli strumenti girano solo attraverso le tue regole e i tuoi permessi | Permessi degli agenti e configurazione degli strumenti | Controllato dal framework dell’agente host | Controllato dall’agente di coding host | EsternoLasciato all’applicazione nei sistemi di sola memoria | Esterno | Instradamento e guardrail solidi; il controllo delle azioni degli agenti dipende dall’integrazione |
| Streaming | Trasmette in streaming l’output del modello e degli strumenti, con ogni passaggio sempre entro le tue regole | Disponibile tramite le interfacce di agenti e modelli | Disponibile tramite i framework di agenti supportati | Dipende dall’agente host | Dipende dal fornitore | Dipende dal fornitore del modello | NativoStreaming solido |
| Lavoro che prosegue | |||||||
| Imparare da ogni passaggio, automaticamente | Ogni passaggio, tramite MCP + hooks o i plugin, alimenta un unico ciclo di apprendimento condiviso | Il runtime di Letta archivia conversazioni e azioni degli agenti | AG-UI cattura le azioni di agenti e utenti come traiettorie full-stack | Sessioni degli agenti e attività degli strumenti vengono catturate automaticamente | Le integrazioni SDK o harness catturano messaggi ed eventi | Per l’addestramento vanno forniti log o dataset | Richieste, risposte, costi e latenza vengono registrati |
| Contesto tra sessioni | NativoLavoro, decisioni, compiti e il contesto che conta proseguono tra una sessione e l’altra | NativoGli agenti persistenti mantengono la memoria tra le conversazioni | Thread durevoli conservano le interazioni dell’app | NativoLa memoria condivisa sopravvive alle sessioni degli agenti | NativoÈ proprio ciò attorno a cui è costruita la categoria | Non nativo | EsternoIn genere |
| Lavoro di lunga durata | NativoIl lavoro lungo resta aperto tra sessioni e agenti, con punti di ripristino a cui tornare, finché non è finito o dimenticato | Gli agenti persistenti possono portare avanti il lavoro, con un ciclo di vita stabilito dall’agente e dall’app | Thread durevoli conservano la cronologia delle interazioni | La memoria di sessione aiuta a riprendere il lavoro | Il contesto si può recuperare, ma gestire lo stato dei compiti è esterno | Non nativo | Non nativo |
| Tra modelli | NativoCiò che impara e il tuo contesto restano fuori dal modello, e seguono il lavoro tra fornitori | Solido: memoria e competenze nello spazio dei token possono sopravvivere a un cambio di modello | Solido: le competenze possono essere distribuite su stack di agenti supportati | Solido: competenze e memoria possono essere riusate da diversi agenti di coding | In genere solido, perché la memoria non dipende dal modello | Debole: un nuovo modello di base di solito richiede riaddestramento o una nuova validazione | Solido per l’instradamento, ma nulla di appreso si trasferisce |
| Tra app e agenti | Lo stesso lavoro prosegue in Claude, Codex, Cursor, Hermes e nei tuoi agenti | Gli agenti con stato sono raggiungibili tramite SDK e MCP ospitato | Le competenze possono essere distribuite tramite gli adattatori dei framework supportati | La memoria condivisa collega Claude Code, Codex, Cursor e altri agenti | Possibile quando le app condividono la stessa identità di memoria | Non nativo | Le richieste possono condividere un gateway, ma ciò che ogni app sa resta esterno |
| Passare il lavoro a un altro agente | Un compito e il suo contesto passano a un altro agente che autorizzi, pronti a proseguire | Agenti e repository condivisi possono supportare un passaggio di consegne | Traiettorie condivise e competenze pubblicate mantengono coerente il comportamento | Le competenze dell’area di lavoro passano lezioni tra agenti | Un altro agente autorizzato può recuperare il contesto condiviso | Non nativo | Può esserci instradamento verso agenti e MCP; il significato del compito resta esterno |
| Mantenere compatto il contesto | Il contesto resta compatto, concentrato su regole, compiti e decisioni che contano | Organizzazione della memoria, riassunti e gestione del contesto in stile file | Le traiettorie vengono distillate in insight e competenze | Le sessioni vengono distillate in competenze compatte | Riassunti, ricordi estratti e registrazioni episodiche | Non nativo | Troncamento o caching dei prompt, non un riassunto duraturo di ciò che conta |
| Imparare da immagini, audio, video e PDF | Impara da immagini, audio, video e PDF, come dal testo | Dipende dal modello collegato e dagli strumenti dell’agente | Dipende dagli eventi dell’app catturati e dallo stack dell’agente | Concentrato soprattutto su sessioni e tracce degli strumenti | Dipende dal fornitore e dal modello | Supportato quando il modello e il servizio di addestramento accettano il formato | Passa soprattutto i media supportati ai fornitori |
| Tra media diversi | Una domanda a parole può attingere a ciò che è stato appreso da immagini, audio e video, e i media possono orientare decisioni successive | Dipende dal modello e da come è costruita la memoria | Fuori dal focus principale di CLiF | Fuori dal focus principale di Hivemind | Disponibile nei prodotti che indicizzano più del testo | Codificato nei pesi quando l’addestramento lo supporta | Non nativo |
| Persone, team e condivisione | |||||||
| Per ogni persona | NativoOgni persona ha il proprio contesto privato, le proprie preferenze e il proprio apprendimento | Memoria nativa per agente e per utente | Possibile tramite thread dell’app e contenitori di apprendimento | Disponibile a livello personale o di area di lavoro | Memoria solida per utente o per attore | Di solito richiede un modello addestrato o adattato a parte | Chiavi e budget per utente; il comportamento personale è esterno |
| Per ogni team | NativoI team condividono l’apprendimento approvato, e il lavoro privato resta privato | Repository di memoria condivisi e competenze | Le competenze pubblicate diffondono l’apprendimento del team | Memoria e competenze condivise dell’area di lavoro | Disponibile tramite namespace, grafi o archivi condivisi | Di solito richiede dati di addestramento condivisi e un modello condiviso | Configurazione e budget per team |
| In tutta l’organizzazione | NativoCiò che funziona può passare da una persona al team e all’organizzazione, secondo le tue regole | Competenze e memoria si possono condividere in tutta l’organizzazione | Le competenze revisionate si possono diffondere tra gli agenti supportati | Le lezioni dell’area di lavoro possono diffondersi tra agenti collegati | È possibile una memoria organizzativa condivisa | Un modello su misura può codificare un comportamento comune per l’organizzazione | Instradamento e guardrail in tutta l’organizzazione, senza imparare dagli esiti |
| Condivisione tra persone, sotto controllo | Scegli cosa condividere e con chi, e puoi ritirarlo; tutto ciò che è condiviso mostra da chi viene | Repository condivisi e permessi di collaborazione | Permessi per progetto e implementazione | Controlli di accesso dell’area di lavoro | Namespace specifici del fornitore, IAM o permessi sul grafo | Controlli di accesso per dataset e modelli | Controlli per chiave, team e ruolo |
| Protezione dei contenuti condivisi | Ciò che qualcuno condivide arriva come informazione, mai come istruzione, quindi non può guidare l’agente di un’altra persona | Si basa sul contesto e sui permessi dell’agente | La policy dello sviluppatore e le restrizioni degli strumenti prevalgono sulle competenze | Si basa su come si caricano le competenze, e sulla fiducia nell’area di lavoro | Dipende dall’app e dal fornitore | I dati di addestramento richiedono controlli propri prima dell’addestramento | I guardrail possono ispezionare gli input condivisi, ma la fiducia in ciò che significano resta esterna |
| Controllo e fiducia | |||||||
| Le regole | Le tue regole fanno parte di come funziona Duplex: consentono, rifiutano o limitano azioni reali | Istruzioni e permessi plasmano il comportamento degli agenti | Le competenze apprese non possono scavalcare le regole di sicurezza dello sviluppatore né le restrizioni degli strumenti | Le competenze guidano l’agente, ma da sole non impongono nulla | Il contesto può orientare il comportamento, ma non autorizza azioni | Il comportamento è plasmato dall’addestramento, non da regole in tempo reale | Guardrail solidi su input e output, e policy di instradamento |
| Regole applicate prima di ogni azione | NativoGli hook controllano ogni azione rispetto alle tue regole prima che venga eseguita | Dipende dal runtime di Letta, dai permessi e dall’host degli strumenti | Resta all’app host e al framework degli agenti | Resta all’agente host | La memoria fornisce contesto, ma non autorizza azioni esterne | Esterno | Solido per richieste e risposte che passano dal gateway |
| Persone nel ciclo | Una persona conferma le azioni che scegli, e ciò che Duplex impara si può revisionare e annullare | Gli utenti possono ispezionare e gestire memoria e competenze | Una revisione solida prima che le competenze apprese vengano pubblicate | Le competenze si possono ispezionare e modificare prima del riuso | Stabilito dall’app | Revisione dell’addestramento, valutazione e approvazione prima del rilascio | I flussi di approvazione variano secondo il gateway |
| Uno storico che puoi verificare | Una cronologia di ogni decisione, da dove viene e cosa ne è derivato, che non si può modificare di nascosto | Conversazioni persistenti, memoria e stato degli agenti | Insight supportati da evidenze, e le traiettorie da cui provengono | Competenze collegate alle sessioni, e tracce archiviate | Cronologia, tracciamento delle fonti e controlli di audit variano secondo il fornitore | Job di addestramento, dataset, metriche di ricompensa e versioni del modello | Log solidi di richieste, risposte, costi e policy |
| Ricevute verificabili | Decisioni, competenze e cancellazioni possono avere ricevute verificabili | Ricordi e competenze con versioni | Link alle evidenze e revisioni esatte delle competenze | File di competenze collegati alle sessioni di origine | Il tracciamento delle fonti varia secondo il fornitore | Valutazione del modello e report di addestramento | Log ed esiti dei guardrail, non ricevute di ciò che è stato appreso |
| Annullare con esattezza ciò che ha appreso | NativoUna singola modifica appresa si può annullare con esattezza, senza riaddestrare nulla | Competenze e ricordi si possono modificare o riportare indietro tramite le versioni | Le competenze pubblicate si possono rivedere o ritirare | I file di competenze si possono modificare o rimuovere | I ricordi si possono cancellare, ma il comportamento costruito su di essi non viene invertito con esattezza | Tornare indietro di un’intera versione del modello, o riaddestrare senza il campione | Configurazione e voci di cache si possono rimuovere; non c’è nulla di appreso da invertire |
| Un oblio che raggiunge tutto ciò che vi è costruito sopra | Rimuovere qualcosa rimuove anche ciò che ne deriva: contesto, tutto ciò che ne è stato condiviso e l’apprendimento collegato | Memoria e competenze si ripuliscono tramite file e versioni | Significa rimuovere gli insight, le competenze e gli asset derivati interessati | Significa rimuovere le sessioni e le competenze generate interessate | Di solito cancella i record; riassunti derivati e copie altrove vanno gestiti a parte | Richiede machine unlearning o riaddestramento | Log e cache seguono la propria conservazione |
| Tenere separati i clienti | Ogni utente, team, organizzazione e cliente resta separato, in ogni integrazione e in tutto ciò che condivide | Permessi nel cloud e in self-hosting | Isolamento per progetto e implementazione | Memoria e competenze limitate a un’area di lavoro | Isolamento per utente, attore, namespace, grafo o IAM | IAM del cloud e confini di accesso ai modelli | Isolamento maturo per chiave, team, budget e ruolo |
| Da dove viene tutto ciò che ha appreso | Per tutto ciò che ha appreso, puoi vedere la fonte, l’ambito e quanto ci si può fidare | Memoria e competenze restano ispezionabili | Insight e competenze restano collegati alle traiettorie da cui provengono | Le competenze possono rimandare alle sessioni di origine | Solido nei prodotti con grafo temporale; altrove varia | Tracciabilità dei dataset e metadati di addestramento | Tracciabilità di richieste e fornitori |
| Dove gira e si collega | |||||||
| Qualsiasi fornitore di modelli | Un’unica intelligenza per OpenAI, Anthropic, Google, AWS e modelli compatibili | Un harness per agenti che funziona con qualsiasi modello | Funziona con i framework di agenti e i modelli supportati | Funziona con diversi agenti di coding e i loro modelli | In genere indipendente dal modello | Di solito legato al modello adattato e al fornitore dell’addestramento | NativoL’astrazione dei fornitori è ciò che la categoria fa meglio |
| MCP | NativoTramite MCP + hooks, Duplex partecipa a ogni passaggio dei tuoi agenti | Con MCP ospitato, altri agenti possono creare agenti Letta con stato e inviare loro messaggi | Le competenze possono raggiungere agenti e server MCP tramite integrazioni | Si collega ai principali agenti di coding; il modo varia secondo il client | Disponibile in diversi prodotti, tra cui Supermemory e AgentCore | Non nativo | Sempre più nativo |
| Hook e plugin | NativoPlugin per Claude, Codex, Cursor e Hermes, e hook che coinvolgono Duplex a ogni passaggio e controllano le azioni sensibili degli strumenti | Integrazione tramite SDK, CLI e runtime degli agenti | AG-UI e adattatori per framework | Cattura automatica delle sessioni degli agenti di coding | Integrazioni SDK e MCP | La raccolta dei dati va costruita a parte | Integrazione tramite SDK e proxy, non hook che imparano dalle sessioni degli agenti |
| Il tuo cloud, o self-hosted | Vareon cloud, il tuo cloud o senza cloud: cloud privato, il tuo account, self-hosted o air-gapped | Cloud, e un app server self-hosted | Intelligenza ospitata nel cloud e self-hosted | Integrazione locale con l’agente; le opzioni di implementazione variano | Specifico del fornitore; esistono opzioni open source e gestite | Addestramento nel cloud e inferenza ospitata | Le opzioni ospitate e self-hosted variano secondo il gateway |
| Senza cloud: air-gapped | Pensato per implementazioni da cui nulla può uscire, con modelli locali, dipendenze locali e il tuo provider di identità | Possibile con uno stack self-hosted e dipendenze locali | Possibile con uno stack self-hosted e dipendenze locali | Dipende dall’implementazione scelta e dai servizi dei modelli | Dipende dalla piattaforma | Limitato ai servizi che supportano addestramento e inferenza offline | Disponibile con gateway self-hosted e fornitori locali |
| Costo, velocità e idoneità | |||||||
| Come riduce il costo dei modelli | Duplex risponde da solo al lavoro noto, senza ripetere la chiamata a un modello di frontiera | Contesto e competenze migliori danno risultati migliori, ma il modello gira comunque | Competenze migliori riducono errori e rilavorazioni, ma il modello gira comunque | Competenze migliori riducono gli errori ripetuti, ma il modello gira comunque | Un contesto migliore riduce le ripetizioni, ma aggiunge recupero e chiama comunque il modello | Un modello adattato più piccolo può dare la qualità che ti serve | Caching, modelli più economici, batching e scelta del fornitore |
| Come riduce la latenza | Le decisioni di cui è sicuro tornano in fretta; il lavoro incerto va comunque al tuo modello di frontiera | Un contesto meglio organizzato può ridurre il ragionamento sprecato | Le competenze rendono l’esecuzione più diretta | Le competenze accorciano le scoperte ripetute | Recupero più veloce e contesto più piccolo | Dipende dal modello adattato | Caching, bilanciamento del carico e scelta del fornitore |
| Sopravvive a un aggiornamento del modello | SìApprendimento, contesto, compiti e regole restano fuori da ogni singolo modello | SìMemoria e competenze sono volutamente indipendenti dal modello | SìCompetenze e traiettorie restano fuori dai pesi del modello | SìLe competenze sopravvivono a un cambio di agente di coding o di modello | SìIl contesto archiviato non dipende dal modello | L’adattamento appartiene a un solo checkpoint del modello, quindi non si trasferisce automaticamente | La configurazione dell’instradamento sopravvive, ma non si conserva alcun comportamento appreso |
| Fine-tuning necessario | NoIl fine-tuning diventa un passo in più facoltativo | No | NoNon per le competenze; CLiF può anche produrre dati per il fine-tuning | No | No | Sì | No |
| Ideale per | Organizzazioni che hanno bisogno che i loro agenti di IA imparino, agiscano entro regole, portino avanti il lavoro e migliorino tra modelli diversi, come un unico sistema | Team che costruiscono agenti persistenti che migliorano da soli, basati su memoria e competenze nello spazio dei token | Team di prodotto che trasformano flussi di lavoro reali degli utenti in competenze revisionate, valutazioni e materiale di addestramento | Team che vogliono che gli agenti di coding condividano le sessioni e riusino le lezioni automaticamente | App che hanno soprattutto bisogno di un contesto utente o aziendale durevole e pertinente | Compiti stabili e ad alto volume in cui il modello stesso deve essere specializzato | Team che hanno soprattutto bisogno di astrazione dei fornitori, affidabilità, guardrail e controllo dei costi |
Un unico ciclo chiuso.
In Duplex contesto, apprendimento, competenze e le tue regole diventano un unico ciclo, che gira mentre il lavoro avviene.
Duplex capisce il compito da svolgere e riporta il contesto che conta.
Passaggio 1 su 8: Il compito
Perché è importante.
Un modello di IA può essere intelligente senza mai fare esperienza del tuo lavoro.
Un sistema di memoria mostra al modello cosa è successo prima, ma non decide cosa deve cambiare. Un sistema di competenze impacchetta una lezione, ma il modello deve comunque leggerla e seguirla. Il fine-tuning cambia il modello, con un ciclo di addestramento più lento e difficile da annullare. Un gateway controlla il traffico, ma non impara quale decisione ha portato all’esito migliore.
Duplex trasforma l’esperienza in miglioramento mentre lavora, entro le tue regole.
Così si costruisce un patrimonio di altro tipo. Ogni correzione confermata, ogni flusso di lavoro riuscito, ogni risultato utile di uno strumento e ogni compito concluso rafforza l’intelligenza attorno al tuo modello, e nulla di tutto ciò resta chiuso dentro un solo fornitore di modelli.
In sintesi.
- MemoriaDà un passato a un agente.
- CompetenzeDanno a un agente istruzioni riutilizzabili.
- Fine-tuningDà a un modello pesi diversi.
- GatewayDanno a uno stack di IA il controllo del traffico.
- DuplexDà all’intero sistema di agenti la capacità di portare avanti l’esperienza, imparare dai risultati, agire entro le tue regole e migliorare tra modelli diversi, nel tempo.
Tra i prodotti e le categorie esaminati, Duplex è l’unico costruito per unire:
- Contesto tra sessioni
- Apprendimento continuo dagli esiti
- Apprendimento da correzioni e ricompense
- Il merito dei passaggi che portano a un risultato
- Imparare come le azioni fanno avanzare il lavoro, e prevedere cosa viene dopo
- Decisioni che sanno quanto sono sicure
- Passare la mano al modello, allo strumento o alla persona giusti
- Lavoro lungo che prosegue
- Apprendimento per ogni persona, team e organizzazione
- Le tue regole, applicate prima di ogni azione
- Azioni degli strumenti entro le tue regole
- Condivisione tra persone, sotto controllo
- Annullare con esattezza ciò che ha appreso
- Un oblio che raggiunge tutto ciò che vi è costruito sopra
- Da dove viene tutto ciò che ha appreso, con ricevute
- MCP + hooks, e plugin per gli assistenti che usi
- Continuità tra modelli e app
- Il tuo cloud, self-hosted o air-gapped
- Meno chiamate al modello, perché il lavoro noto riceve risposta diretta
Duplex rende i tuoi sistemi di IA più bravi nel lavoro a ogni esperienza.
Le fonti.
Le pagine dei prodotti e la documentazione su cui si basa questo confronto.
- Letta: apprendimento di competenze →
- Letta: MCP ospitato →
- CopilotKit: presentazione di CLiF →
- CopilotKit: imparare in automatico →
- Deeplake Hivemind →
- Supermemory →
- Mem0: memoria a grafo →
- Zep: memoria per agenti →
- Amazon Bedrock AgentCore Memory →
- Reinforcement fine-tuning su Amazon Bedrock →
- Gateway di IA Portkey →
- Gateway di IA LiteLLM →
Confronto aggiornato al 16 ottobre 2026.
Vedi Duplex all’opera sul tuo lavoro.
Confrontalo dove conta: un progetto pilota applica Duplex al tuo lavoro, con metriche concordate prima di partire.