Hukommelse husker. Færdigheder nedfælder. Finjustering gentræner. Gateways router.
Duplex lukker sløjfen.
Det meste AI-infrastruktur løser én del af arbejdet. Duplex samler alle dele i én runtime-intelligens, der bliver ved med at blive bedre, mens den arbejder.
Sammenligningen er aktuel pr. 16. oktober 2026.
Hver løser én del.
Hukommelsesplatforme opbevarer information. Færdighedslæring gør erfaring til instruktioner. Finjustering ændrer modellens vægte. AI-gateways router forespørgsler og anvender guardrails. Duplex samler det hele og bliver ved med at forbedre sig.
Alle evner, side om side.
Vælg én at sætte ved siden af Duplex, eller se dem alle på én gang.
- Indbygget
- Bygget ind i kernen af, hvordan produktet fungerer.
- Ekstern
- Du leverer det, eller samler det, separat.
- Ikke indbygget
- Produktets dokumentation angiver det ikke som en indbygget funktion. En specialbygget løsning kan stadig være mulig.
| Evne | Duplex | Letta | CopilotKit CLiF | Deeplake Hivemind | HukommelsesplatformeMem0, Zep, AgentCore Memory og Supermemory | Finjustering og RFT | AI-gatewaysPortkey, LiteLLM og lignende |
|---|---|---|---|---|---|---|---|
| Hvad hver enkelt er | |||||||
| Hvad den er | En runtime-intelligens ved siden af din AI: den lærer og handler for dine agenter og assistenter, inden for dine regler | En platform til agenter med tilstand, bygget op om vedvarende hukommelse og læring i token-rummet | En full-stack-pipeline, der gør forløb til færdigheder, evalueringer og træningsdata | Delt agenthukommelse, der automatisk gør spor til færdigheder | Vedvarende kontekst, fakta, episoder og vidensgrafer | At tilpasse en model ved at træne den | Modelrouting, pålidelighed, guardrails og observerbarhed |
| Hvad den bringer videre | Kontekst, beslutninger, udfald, regler, opgaver, færdigheder og det, den har lært | Agenthukommelse, samtaler, filer og færdigheder | Tråde, forløb, indsigter, færdigheder og evalueringer | Sessioner, minder og færdigheder afgrænset til et arbejdsområde | Fakta, beskeder, resuméer, episoder og grafrelationer | Et nyt sæt modelvægte | Konfiguration, logge, routingpolitikker og caches |
| Hvad der bliver bedre med erfaring | Dens næste beslutninger: konfidens, routing, anbefalinger, værktøjsbrug og genbrugelig viden | Agentens fremtidige adfærd, gennem opdateret hukommelse og lærte færdigheder | Agentens instruktioner, gennem gennemgåede færdigheder hentet fra rigtige arbejdsgange | Den næste sessions adfærd, gennem destillerede færdigheder | Primært den kontekst, der gives til det næste modelkald | Den underliggende models svar | Routing af forespørgsler og pålidelighed, ikke hvad agenten har lært |
| At vide, hvad der skete, og lære af det | IndbyggetDen ved, hvad der skete, og lærer, hvad der skal ændres næste gang | Begge findes, primært gennem hukommelse og færdigheder i token-rummet | Læring genereres ud fra lagrede forløb | Delt hukommelse gøres til genbrugelige færdigheder | Primært hukommelse; hvor meget den lærer, varierer fra leverandør til leverandør | Læring uden varig operationel hukommelse | Operationel kontrol uden løbende læring |
| Læring | |||||||
| Kontinuerlig læring uden gentræning | IndbyggetDen bliver ved med at lære, uden for din models vægte | IndbyggetToken-rums- og færdighedslæring | IndbyggetFærdighedslæring; finjusteringsdata er valgfrie | IndbyggetLæring af færdigheder fra spor | Forbedring gennem kontekst; hvor dybt det går, varierer fra platform til platform | NejTræning er måden, den lærer på | Ikke indbygget |
| Tilpasning tur for tur | IndbyggetHvert nyt resultat kan ændre den næste beslutning med det samme | Agentstyret hukommelse kan ændre sig løbende; færdighedslæring følger efter afsluttet erfaring | Analysen køres manuelt eller efter en tidsplan | Færdigheder destilleres i baggrunden eller ved afslutningen af en session | Minder kan tilføjes løbende, men at hente dem frem er ikke at tilpasse sig | Venter, til et træningsjob er færdigt, og den nye model er udrullet | Routingen ændres med det samme, men ikke ud fra lærte udfald |
| Læring fra rettelser | IndbyggetEn rettelse ændrer, hvad Duplex gør næste gang | Rettelser kan opdatere hukommelsen eller indgå i lærte færdigheder | Brugerændringer og handlinger i appen indgår i dens læring | Rettelser og sessionsspor kan blive til færdigheder | Rettelser kan lagres og hentes frem som kontekst | Rettelser skal ind i et træningsdatasæt eller en belønningspipeline | Logges som regel; læring fra dem er ekstern |
| Læring fra udfald | IndbyggetSucces og fiasko føres direkte tilbage i det, den lærer | Muligt gennem refleksion over forløb og agentstyrede opdateringer | Udfald på tværs af stakken bliver til indsigter, færdigheder, evalueringer og træningsdata | Nye færdigheder udledes af afsluttede sessioner | Episoder kan hentes frem, men læring fra udfald er generelt ekstern | IndbyggetNår udfald kan omsættes til belønninger | Udfald dukker op i telemetrien; læring fra dem er ekstern |
| Læring fra belønninger | IndbyggetEn belønning styrker det, der virkede, og retter det, der ikke gjorde | Belønninger er ikke dens vigtigste måde at lære på | Kan producere finjusteringsdata ud fra evaluerede forløb | Belønninger er ikke dens vigtigste måde at lære på | Belønninger er ikke en almindelig hukommelsesfunktion | IndbyggetBelønninger optimerer modellens vægte | Ikke indbygget |
| Æren til trinnene bag et resultat | IndbyggetDen finder ud af, hvilke tidligere handlinger der førte til et senere resultat | Letta tilbyder ikke dette indbygget under kørsel | Analyse af forløb kan bringe nyttige mønstre i arbejdsgange frem | Analyse af spor kan finde genbrugelige procedurer | Ikke indbygget | Kan lære korrelationer fra træningseksempler, men kan ikke spore et resultat i drift tilbage til dets trin | Ikke indbygget |
| Hvordan handlinger flytter arbejdet | IndbyggetDen lærer, hvordan hver handling flytter arbejdet fra én tilstand til den næste | Agenten kan udlede dette fra konteksten | Kan gøre arbejdsgange til færdigheder | Kan fange vellykkede procedurer som færdigheder | Lagrede episoder kan tjene som eksempler | Kan optage disse mønstre under træning | Ikke indbygget |
| At forudsige, hvad en handling vil gøre | IndbyggetUd fra det, den observerer, forudsiger den, hvad en handling vil gøre, afprøver alternativer og planlægger | Modellen ræsonnerer over hukommelsen | EksternOverladt til agentframeworket | Ikke indbygget | Ikke indbygget | Implicit i den trænede model, hvor du ikke kan redigere det | Ikke indbygget |
| Bedre valg af handling | IndbyggetUdfald forbedrer, hvilken handling den vælger næste gang | Adfærden forbedres gennem hukommelse og færdigheder | Gennemgåede færdigheder forbedrer agentens næste instruktioner | Destillerede færdigheder forbedrer de næste procedurer | Genfundet kontekst kan forme adfærden indirekte | IndbyggetVed at optimere modellen | Routingpolitikker konfigureres, de læres ikke ud fra udfald |
| Genbrugelige færdigheder | IndbyggetErfaring bliver til færdigheder, der testes før brug, og som kan sættes på pause, hentes tilbage eller trækkes tilbage | IndbyggetForløb kan blive til varige færdigheder, der virker med enhver model | IndbyggetForløb bliver til gennemgåede færdigheder, underbygget af evidens | IndbyggetSessioner bliver til skill.md-filer til arbejdsområdet | Afhænger af leverandøren; generelt ikke det, kategorien er bygget op om | Viden optages i vægtene og pakkes ikke som flytbare færdigheder | Ikke indbygget |
| At teste og styre færdigheder | En færdighed testes, før man forlader sig på den, og kan sættes på pause, hentes tilbage, trækkes tilbage eller fjernes for altid | Færdigheder er filer, du kan inspicere, styre og versionere | Udgives efter menneskelig gennemgang og leveres i en fastlåst version | Færdigheder forbliver filer, du kan inspicere og redigere, koblet til de sessioner, de kom fra | Som regel en livscyklus pr. Post, ikke pr. Færdighed | Evaluering sker omkring træning og udrulning | Konfigurationsversioner, ikke en livscyklus for lærte færdigheder |
| Generalisering til beslægtede tilfælde | Den fører det, den har lært, videre til beslægtede tilfælde og nye formuleringer og ind i færdigheder, den kan genbruge | Færdigheder i token-rummet generaliserer procedurer på tværs af opgaver | Færdigheder fanger mønstre på tværs af mange produktionsforløb | Færdigheder fanger mønstre, der går igen på tværs af sessioner | Semantisk genfinding finder relateret information, hvilket ikke er det samme som at generalisere adfærd | Generaliserer gennem de trænede vægte | Semantiske caches matcher lignende forespørgsler, men lærer ikke, hvordan de skal handle |
| At beslutte og handle | |||||||
| At vide, hvor sikker den er | IndbyggetFør hver beslutning ved den, hvor velkendt sagen er, og hvor sikker den er | Primært modellens dømmekraft og hvor relevant hukommelsen er | Drevet af evaluering, ikke et løbende mål for vished | Hvor relevante genfinding og færdigheder er, ikke et mål for vished | Genfindingsscorer og relevanssignaler | Modellens konfidens skal måles separat | Udbydernes tilstand, routing og guardrail-scorer, ikke vished om opgaven |
| Svar, overdrag eller afvis | IndbyggetDuplex svarer selv, kalder din model, bruger et værktøj eller afviser, inden for dine regler | Agenten fortsætter som regel gennem modellens ræsonnement | EksternVærtsagenten afgør, hvordan der skal handles | EksternVærtsagenten afgør, hvordan der skal handles | EksternVærtsapplikationen afgør, hvordan der skal handles | Den trænede model kører stadig ved hver forespørgsel | Router, prøver igen, blokerer eller falder tilbage, uden at lære af udfald |
| At svare selv på velkendt arbejde | IndbyggetDen træffer selv velkendte beslutninger uden endnu et kald til en frontiermodel | Modellen fortolker stadig hukommelsen eller færdighederne | Modellen læser stadig den lærte færdighed | Modellen læser stadig den lærte færdighed | Modellen læser normalt den genfundne kontekst | Den tilpassede model kører stadig | En cache kan springe et modelkald over, men en cache lærer ikke af udfald |
| At overdrage det, der er nyt eller usikkert | Nyt, usikkert eller følsomt arbejde går til den rette model, det rette værktøj eller den rette person | Agenten og modellen afgør, hvornår der er brug for mere hjælp | EksternVærtsagentens opgave | EksternVærtsagentens opgave | EksternApplikationens opgave | EksternApplikationens opgave | Stærk routing og fallback mellem udbydere; vished om opgaven forbliver ekstern |
| Planlægning, simulering og anbefalinger | IndbyggetDen forudsiger, hvad der sker derefter, afprøver alternativer, bygger planer og anbefaler handlinger | Primært gennem modellens ræsonnement og agentens værktøjer | EksternVærtsagentens opgave | EksternVærtsagentens opgave | Hukommelsen leverer kontekst; planlægning forbliver ekstern | Modellen planlægger måske bedre, men arbejdets tilstand forbliver ekstern | Ikke indbygget |
| Mange agenter, der arbejder sammen | Den sender arbejdet til den rette agent, deler det op inden for dine regler, holder hver agent inden for dens område og samler resultaterne | Agenter, subagenter og delt hukommelse er tilgængelige | Fungerer på tværs af understøttede agentframeworks | Deler lærdomme på tværs af forbundne agenter | Delt hukommelse kan betjene flere agenter | Ikke indbygget | Nogle router til agenter og MCP-værktøjer, men lærer ikke, hvilket samarbejde der virkede |
| At lære, hvilke værktøjer der virker | Den lærer, hvilke værktøjer der virker, hvornår de skal bruges, og hvad hvert enkelt fører til | Færdigheder og hukommelse kan forbedre værktøjsbrug | Full-stack-forløb fanger værktøjs- og brugerhandlinger til nye færdigheder | Værktøjsspor kan blive til genbrugelige procedurer | Værktøjsresultater kan huskes | Værktøjsadfærd kan forbedres gennem træning | De eksponerer og router værktøjer, men lærer generelt ikke af deres udfald |
| Værktøjshandlinger inden for dine regler | Værktøjer kører kun gennem dine regler og tilladelser | Agenttilladelser og værktøjskonfiguration | Styres af værtens agentframework | Styres af værtens kodeagent | EksternOverladt til applikationen i systemer, der kun har hukommelse | Ekstern | Stærk routing og stærke guardrails; kontrol med agentens handlinger afhænger af integrationen |
| Streaming | Den streamer output fra model og værktøjer, med hvert trin stadig inden for dine regler | Tilgængelig gennem agent- og modelgrænseflader | Tilgængelig gennem understøttede agentframeworks | Afhænger af værtsagenten | Afhænger af leverandøren | Afhænger af modeludbyderen | IndbyggetStærk streaming |
| Arbejde, der fortsætter | |||||||
| Læring fra hvert trin, automatisk | Hvert trin, gennem MCP + hooks eller plugins, indgår i én fælles læringssløjfe | Lettas runtime lagrer agenternes samtaler og handlinger | AG-UI fanger agent- og brugerhandlinger som full-stack-forløb | Agentsessioner og værktøjsaktivitet fanges automatisk | Integrationer via SDK eller agentmiljø fanger beskeder og hændelser | Logge eller datasæt skal leveres til træningen | Forespørgsler, svar, omkostninger og latens logges |
| Kontekst på tværs af sessioner | IndbyggetArbejde, beslutninger, opgaver og den kontekst, der betyder noget, fortsætter på tværs af sessioner | IndbyggetVedvarende agenter bevarer hukommelsen på tværs af samtaler | Varige tråde bevarer interaktionerne i appen | IndbyggetDelt hukommelse lever længere end agentsessionerne | IndbyggetDet er netop det, kategorien er bygget op om | Ikke indbygget | EksternGenerelt |
| Langvarigt arbejde | IndbyggetLangt arbejde forbliver åbent på tværs af sessioner og agenter, med sikre punkter at vende tilbage til, indtil det er færdigt eller glemt | Vedvarende agenter kan føre arbejdet videre, med en livscyklus, som agenten og appen fastlægger | Varige tråde bevarer historikken over interaktioner | Sessionshukommelse hjælper med at tage arbejdet op igen | Kontekst kan hentes frem, men styring af opgavernes tilstand er ekstern | Ikke indbygget | Ikke indbygget |
| På tværs af modeller | IndbyggetDet, den lærer, og din kontekst forbliver uden for modellen og følger arbejdet på tværs af udbydere | Stærk: hukommelse og færdigheder i token-rummet kan overleve et modelskift | Stærk: færdigheder kan leveres på tværs af understøttede agentstakke | Stærk: færdigheder og hukommelse kan genbruges af forskellige kodeagenter | Generelt stærk, fordi hukommelsen ikke afhænger af modellen | Svag: en ny basismodel kræver som regel gentræning eller ny validering | Stærk til routing, men intet lært følger med |
| På tværs af apps og agenter | Det samme arbejde fortsætter på tværs af Claude, Codex, Cursor, Hermes og dine egne agenter | Agenter med tilstand kan nås via SDK’er og hostet MCP | Færdigheder kan leveres via understøttede framework-adaptere | Delt hukommelse forbinder Claude Code, Codex, Cursor og andre agenter | Muligt, når apps deler den samme hukommelsesidentitet | Ikke indbygget | Forespørgsler kan dele én gateway, men det, hver app ved, forbliver eksternt |
| At overdrage arbejde til en anden agent | En opgave og dens kontekst går videre til en anden agent, du tillader, klar til at fortsætte | Delte agenter og repositorier kan understøtte en overdragelse | Delte forløb og udgivne færdigheder holder adfærden ensartet | Færdigheder i arbejdsområdet giver lærdomme videre mellem agenter | En anden autoriseret agent kan hente den delte kontekst frem | Ikke indbygget | Routing til agenter og MCP kan være tilgængelig; hvad opgaven betyder, forbliver eksternt |
| At holde konteksten kompakt | Konteksten forbliver kompakt, fokuseret på de regler, opgaver og beslutninger, der betyder noget | Organisering af hukommelse, resuméer og filbaseret kontekststyring | Forløb destilleres til indsigter og færdigheder | Sessioner destilleres til kompakte færdigheder | Resuméer, udtrukne minder og episodiske optegnelser | Ikke indbygget | Afkortning eller caching af prompts, ikke et varigt resumé af det, der betyder noget |
| Læring fra billeder, lyd, video og PDF’er | Den lærer af billeder, lyd, video og PDF’er, ligesom den gør af tekst | Afhænger af den tilsluttede model og agentens værktøjer | Afhænger af de opfangede app-hændelser og agentstakken | Primært fokuseret på sessioner og værktøjsspor | Afhænger af leverandøren og modellen | Understøttet, når modellen og træningstjenesten accepterer formatet | Sender primært understøttede formater videre til udbyderne |
| På tværs af formater | Et spørgsmål i ord kan trække på det, der er lært fra billeder, lyd og video, og medier kan forme senere beslutninger | Afhænger af modellen og af, hvordan hukommelsen er bygget | Uden for CLiFs hovedfokus | Uden for Hiveminds hovedfokus | Tilgængelig i produkter, der indekserer mere end tekst | Indkodet i vægtene, når træningen understøtter det | Ikke indbygget |
| Mennesker, teams og deling | |||||||
| For hver person | IndbyggetHver person får sin egen private kontekst, sine præferencer og sin læring | Indbygget hukommelse pr. Agent og pr. Bruger | Muligt gennem app-tråde og læringscontainere | Tilgængelig med personligt omfang eller omfang pr. Arbejdsområde | Stærk hukommelse pr. Bruger eller pr. Aktør | Kræver som regel en separat trænet eller tilpasset model | Nøgler og budgetter pr. Bruger; personlig adfærd er ekstern |
| For hvert team | IndbyggetTeams deler godkendt læring, og privat arbejde forbliver privat | Delte hukommelsesrepositorier og færdigheder | Udgivne færdigheder spreder teamets læring | Delt hukommelse og færdigheder i arbejdsområdet | Tilgængelig gennem namespaces, grafer eller delte lagre | Kræver som regel delte træningsdata og en delt model | Konfiguration og budgetter pr. Team |
| På tværs af organisationen | IndbyggetDet, der virker, kan bevæge sig fra én person til teamet og organisationen, under dine regler | Færdigheder og hukommelse kan deles på tværs af organisationen | Gennemgåede færdigheder kan spredes på tværs af understøttede agenter | Lærdomme fra arbejdsområdet kan spredes på tværs af forbundne agenter | Delt organisationshukommelse er mulig | En tilpasset model kan indkode fælles adfærd for organisationen | Routing og guardrails på tværs af organisationen, uden læring fra udfald |
| Deling mellem mennesker, under kontrol | Du vælger, hvad der deles, og med hvem, og kan trække det tilbage; alt delt viser, hvem det kom fra | Delte repositorier og samarbejdstilladelser | Tilladelser til projekter og udrulninger | Adgangskontrol til arbejdsområdet | Leverandørspecifikke namespaces, IAM eller graftilladelser | Adgangskontrol til datasæt og modeller | Kontrol med nøgler, teams og roller |
| Beskyttelse af delt indhold | Det, nogen deler, ankommer som information, aldrig som instruktioner, så det ikke kan styre en anden persons agent | Afhænger af agentens kontekst og tilladelser | Udviklerpolitik og værktøjsbegrænsninger går forud for færdigheder | Afhænger af, hvordan færdigheder indlæses, og af tilliden til arbejdsområdet | Afhænger af appen og leverandøren | Træningsdata kræver deres egen kontrol før træning | Guardrails kan inspicere delte input, men tillid til, hvad de betyder, forbliver ekstern |
| Kontrol og tillid | |||||||
| Regler | Dine regler er en del af, hvordan Duplex fungerer: de tillader, afviser eller begrænser reelle handlinger | Instruktioner og tilladelser former agentens adfærd | Lærte færdigheder kan ikke tilsidesætte udviklerens sikkerhedsregler eller værktøjsbegrænsninger | Færdigheder vejleder agenten, men håndhæver intet på egen hånd | Kontekst kan informere adfærd, men autoriserer ikke handlinger | Adfærden formes af træning, ikke af regler i realtid | Stærke guardrails på input og output samt routingpolitikker |
| Regler anvendt før hver handling | IndbyggetHooks tjekker hver handling mod dine regler, før den kører | Afhænger af Lettas runtime, tilladelser og værktøjsværten | Ligger hos værtsappen og agentframeworket | Ligger hos værtsagenten | Hukommelsen leverer kontekst, men autoriserer ikke eksterne handlinger | Ekstern | Stærk for forespørgsler og svar, der går gennem gatewayen |
| Mennesker i processen | En person bekræfter de handlinger, du vælger, og det, Duplex lærer, kan gennemgås og fortrydes | Brugere kan inspicere og styre hukommelse og færdigheder | En grundig gennemgang, før lærte færdigheder udgives | Færdigheder kan inspiceres og redigeres før genbrug | Fastlagt af appen | Gennemgang af træningen, evaluering og godkendelse før udrulning | Godkendelsesforløb varierer fra gateway til gateway |
| En historik, du kan kontrollere | En historik over hver beslutning, hvor den kom fra, og hvad der kom ud af den, som ikke kan ændres i det stille | Vedvarende samtaler, hukommelse og agenttilstand | Indsigter underbygget af evidens og de forløb, de stammer fra | Færdigheder koblet til sessioner og lagrede spor | Historik, kildesporing og revisionskontroller varierer fra leverandør til leverandør | Træningsjob, datasæt, belønningsmålinger og modelversioner | Stærke logge over forespørgsler, svar, omkostninger og politik |
| Kvitteringer, du kan verificere | Beslutninger, færdigheder og sletninger kan komme med kvitteringer, du kan verificere | Versionerede minder og færdigheder | Links til evidens og præcise revisioner af færdigheder | Færdighedsfiler koblet til de sessioner, de stammer fra | Kildesporing varierer fra leverandør til leverandør | Modelevaluering og træningsrapporter | Logfiler og guardrail-resultater, ikke kvitteringer for det lærte |
| At fortryde det lærte, præcist | IndbyggetÉn lært ændring kan fortrydes præcist, uden at noget skal gentrænes | Færdigheder og minder kan redigeres eller rulles tilbage via versioner | Udgivne færdigheder kan revideres eller trækkes tilbage | Færdighedsfiler kan redigeres eller fjernes | Minder kan slettes, men den adfærd, der er bygget på dem, rulles ikke præcist tilbage | Rul en hel modelversion tilbage, eller gentræn uden eksemplet | Konfiguration og cacheposter kan fjernes; der er intet lært at rulle tilbage |
| Glemsel, der når alt, hvad der er bygget på det | At fjerne noget fjerner også det, der kom fra det: kontekst, alt delt fra det og relateret læring | Hukommelse og færdigheder ryddes op via filer og versioner | Betyder, at de berørte indsigter, færdigheder og afledte aktiver skal fjernes | Betyder, at de berørte sessioner og genererede færdigheder skal fjernes | Sletter som regel poster; afledte resuméer og kopier andre steder kræver særskilt håndtering | Kræver maskinel aflæring eller gentræning | Logge og caches følger deres egne opbevaringsregler |
| At holde kunder adskilt | Hver bruger, hvert team, hver organisation og hver kunde holdes adskilt, i hver integration og i alt, den deler | Tilladelser i cloud og ved selvhosting | Isolering pr. Projekt og udrulning | Hukommelse og færdigheder afgrænset til et arbejdsområde | Isolering efter bruger, aktør, namespace, graf eller IAM | Cloud-IAM og grænser for modeladgang | Moden isolering efter nøgle, team, budget og rolle |
| Hvor alt det lærte kom fra | For alt, den lærte, kan du se kilden, omfanget, og hvor langt man kan stole på det | Hukommelse og færdigheder forbliver til at inspicere | Indsigter og færdigheder forbliver koblet til de forløb, de kom fra | Færdigheder kan linke tilbage til de sessioner, de stammer fra | Stærk i produkter med temporale grafer; varierer andre steder | Datasættenes afstamning og træningsmetadata | Afstamning for forespørgsler og udbydere |
| Hvor den kører og forbinder | |||||||
| Enhver modeludbyder | Én intelligens på tværs af OpenAI, Anthropic, Google, AWS og kompatible modeller | Et agentmiljø, der virker med enhver model | Fungerer på tværs af understøttede agentframeworks og modeller | Fungerer på tværs af flere kodeagenter og deres modeller | Generelt uafhængig af modellen | Som regel bundet til den tilpassede model og træningsudbyderen | IndbyggetAbstraktion over udbydere er det, kategorien gør bedst |
| MCP | IndbyggetGennem MCP + hooks indgår Duplex i hvert trin, dine agenter tager | Hostet MCP lader andre agenter oprette Letta-agenter med tilstand og sende dem beskeder | Færdigheder kan nå agenter og MCP-servere via integrationer | Forbinder til de store kodeagenter; hvordan varierer fra klient til klient | Tilgængelig i flere produkter, herunder Supermemory og AgentCore | Ikke indbygget | I stigende grad indbygget |
| Hooks og plugins | IndbyggetPlugins til Claude, Codex, Cursor og Hermes og hooks, der henter Duplex ind ved hvert trin og tjekker følsomme værktøjshandlinger | Integration via SDK, CLI og agent-runtime | AG-UI og framework-adaptere | Automatisk opsamling af kodeagenters sessioner | Integrationer via SDK og MCP | Dataindsamling skal bygges separat | Integration via SDK og proxy, ikke hooks, der lærer af agentsessioner |
| Din cloud, eller selvhostet | Vareon cloud, din cloud eller ingen cloud: privat cloud, din egen konto, selvhostet eller air-gapped | Cloud og en selvhostet appserver | Cloudhostet og selvhostet intelligens | Lokal agentintegration; udrulningsmuligheder varierer | Leverandørspecifikt; der findes open source- og administrerede muligheder | Træning i cloud og hostet inferens | Hostede og selvhostede muligheder varierer fra gateway til gateway |
| Ingen cloud: air-gapped | Bygget til udrulninger, hvor intet må forlade stedet, med lokale modeller, lokale afhængigheder og din egen identitetsudbyder | Muligt med en selvhostet stak og lokale afhængigheder | Muligt med en selvhostet stak og lokale afhængigheder | Afhænger af den valgte udrulning og modeltjenesterne | Afhænger af platformen | Begrænset til tjenester, der understøtter offline træning og inferens | Tilgængelig med selvhostede gateways og lokale udbydere |
| Omkostning, hastighed og egnethed | |||||||
| Hvordan den sænker modelomkostningerne | Duplex besvarer selv velkendt arbejde uden gentagne kald til en frontiermodel | Bedre kontekst og færdigheder forbedrer resultaterne, men modellen kører stadig | Bedre færdigheder mindsker fejl og omarbejde, men modellen kører stadig | Bedre færdigheder mindsker gentagne fejl, men modellen kører stadig | Bedre kontekst mindsker gentagelser, men tilføjer genfinding og kalder stadig modellen | En mindre tilpasset model kan give den kvalitet, du har brug for | Caching, billigere modeller, batching og valg af udbyder |
| Hvordan den sænker latensen | Beslutninger, den er sikker på, kommer hurtigt tilbage; usikkert arbejde går stadig til din frontiermodel | Bedre organiseret kontekst kan mindske spildt ræsonnement | Færdigheder gør udførelsen mere direkte | Færdigheder forkorter gentagne opdagelser | Hurtigere genfinding og mindre kontekst | Afhænger af den tilpassede model | Caching, load balancing og valg af udbyder |
| Overlever en modelopgradering | JaLæring, kontekst, opgaver og regler forbliver uden for enhver enkelt model | JaHukommelse og færdigheder er bevidst uafhængige af modellen | JaFærdigheder og forløb forbliver uden for modellens vægte | JaFærdigheder overlever et skift af kodeagent eller model | JaLagret kontekst afhænger ikke af modellen | Tilpasningen hører til ét modelcheckpoint, så den følger ikke automatisk med | Routingkonfigurationen overlever, men ingen lært adfærd bevares |
| Kræver finjustering | NejFinjustering bliver et valgfrit ekstra trin | Nej | NejIkke for færdigheder; CLiF kan også producere finjusteringsdata | Nej | Nej | Ja | Nej |
| Bedst til | Organisationer, der har brug for, at deres AI-agenter lærer, handler inden for regler, fører arbejdet videre og bliver bedre på tværs af modeller, som ét system | Teams, der bygger vedvarende, selvforbedrende agenter op om hukommelse og færdigheder i token-rummet | Produktteams, der gør rigtige brugerarbejdsgange til gennemgåede færdigheder, evalueringer og træningsaktiver | Teams, der vil have kodeagenter til at dele sessioner og genbruge lærdomme automatisk | Apps, der primært har brug for varig, relevant bruger- eller forretningskontekst | Stabile opgaver i stor volumen, hvor selve modellen skal specialiseres | Teams, der primært har brug for abstraktion over udbydere, pålidelighed, guardrails og omkostningskontrol |
Én lukket sløjfe.
I Duplex bliver kontekst, læring, færdigheder og dine regler til én sløjfe, der kører, mens arbejdet foregår.
Duplex forstår den aktuelle opgave og henter den kontekst frem, der betyder noget.
Hvorfor det er vigtigt.
En AI-model kan være intelligent uden nogensinde at blive erfaren i dit arbejde.
Et hukommelsessystem viser modellen, hvad der skete før, men det afgør ikke, hvad der bør ændres. Et færdighedssystem pakker en lærdom, men modellen skal stadig læse den og følge den. Finjustering ændrer modellen gennem en langsommere træningscyklus, der er svær at fortryde. En gateway styrer trafikken, men lærer ikke, hvilken beslutning der førte til det bedste udfald.
Duplex gør erfaring til forbedring, mens den arbejder, inden for dine regler.
Det opbygger en anden slags aktiv. Hver bekræftet rettelse, vellykket arbejdsgang, nyttigt værktøjsresultat og afsluttet opgave styrker intelligensen omkring din model, og intet af det er låst inde hos én modelleverandør.
Konklusionen.
- HukommelseGiver en agent en fortid.
- FærdighederGiver en agent genbrugelige instruktioner.
- FinjusteringGiver en model andre vægte.
- GatewaysGiver en AI-stak kontrol over trafikken.
- DuplexGiver hele agentsystemet evnen til at føre erfaring videre, lære af resultater, handle inden for dine regler og blive bedre på tværs af modeller, over tid.
Blandt de gennemgåede produkter og kategorier er Duplex den eneste, der er bygget til at kombinere:
- Kontekst på tværs af sessioner
- Løbende læring fra udfald
- Læring fra rettelser og belønninger
- Æren til trinnene bag et resultat
- At lære, hvordan handlinger flytter arbejdet, og forudsige, hvad der kommer derefter
- Beslutninger, der ved, hvor sikre de er
- Overdragelse til den rette model, det rette værktøj eller den rette person
- Langt arbejde, der fortsætter
- Læring for hver person, hvert team og hver organisation
- Dine regler, anvendt før hver handling
- Værktøjshandlinger inden for dine regler
- Deling mellem mennesker, under kontrol
- At fortryde det lærte, præcist
- Glemsel, der når alt, hvad der er bygget på det
- Hvor alt det lærte kom fra, med kvitteringer
- MCP + hooks og plugins til de assistenter, du bruger
- Kontinuitet på tværs af modeller og apps
- Din cloud, selvhostet eller air-gapped
- Færre modelkald, fordi velkendt arbejde besvares direkte
Duplex gør dine AI-systemer bedre til arbejdet med hver erfaring.
Kilderne.
De produktsider og den dokumentation, som denne sammenligning bygger på.
- Letta: færdighedslæring →
- Letta: hostet MCP →
- CopilotKit: vi præsenterer CLiF →
- CopilotKit: automatisk læring →
- Deeplake Hivemind →
- Supermemory →
- Mem0: grafhukommelse →
- Zep: agenthukommelse →
- Amazon Bedrock AgentCore Memory →
- Forstærkningsbaseret finjustering i Amazon Bedrock →
- Portkeys AI-gateway →
- LiteLLMs AI-gateway →
Sammenligningen er aktuel pr. 16. oktober 2026.
Se Duplex på dit eget arbejde.
Sammenlign, hvor det tæller: et pilotprojekt sætter Duplex på dit eget arbejde, med målepunkterne aftalt, før det går i gang.