Claude Fable AIOS: Een Tweede Brein op het Duurste Model

Claude Fable AIOS: Een Tweede Brein op het Duurste Model

Het getal dat het hele project in perspectief zette was $50.

Vijftig dollar per miljoen output-tokens. Dat is wat Claude Fable 5 kost op de API — het dubbele van Opus 4.8, en het duurste algemeen beschikbare model dat Anthropic ooit heeft uitgebracht ($10 per miljoen input, $50 per miljoen output, bevestigd bij de lancering op 9 juni). Ik was van plan om een vers gebouwd persoonlijk AIOS — een AI-besturingssysteem, een tweede brein met handen — op dit model te richten en het mijn leven te laten runnen. Toen maakte ik de berekening op een servetje voor één ochtendbriefing die mijn agenda leest, drie Slack-kanalen, de Stripe-afschrijvingen van gisteren en mijn takenbord, en vervolgens een samenvatting van 600 woorden schrijft. Op Fable zouden alleen de output-tokens voor het dagelijks draaien hiervan meer kosten dan mijn Spotify-, Netflix- en iCloud-abonnementen samen. Voor een alinea die ik in negentig seconden lees.

Dat is het punt dat niemand je vertelt over het bouwen van een Claude Fable AIOS. Het framework voor een tweede brein is het makkelijke deel. Het moeilijke deel — het deel dat daadwerkelijk bepaalt of je systeem een factuur overleeft — is beslissen wat het waard is om op het slimste, duurste model te draaien, en wat stilletjes aan iets goedkopers moet worden overgedragen. Ik leerde dit op de dure manier, en een van de lessen betrof een e-mail die nooit verzonden had mogen worden.

Laat me je uitleggen wat ik heb gebouwd, het Vier C's-framework waarop ik het heb gebouwd, en de kostenbeslissingen die een interessant speeltje omtoverden in iets dat ik werkelijk vertrouw met mijn bedrijf.

Wat een Claude Fable AIOS Eigenlijk Is (en Waarom Fable de Wiskunde Verandert)

Een tweede brein is je kennis — notities, beslissingen, archieven, de dingen waar je wakker van zou liggen als ze verdwenen. Een AIOS is de infrastructuur erop: de vaardigheden, de live dataverbindingen, de automatiseringen die op die kennis handelen zonder dat jij erbij betrokken hoeft te zijn. Het brein slaat op. Het besturingssysteem handelt.

Ik heb eerder een persoonlijk AIOS op Claude Code gebouwd, en die versie draaide op goedkope, snelle modellen waar je je slordigheid kon veroorloven. Een paar duizend tokens verbranden op een wegwerpvraag? Maakt niet uit. De hele berekening verandert wanneer je redeneermotor Claude Fable 5 is.

Dit is waarom Fable specifiek betere architectuur afdwingt. Fable is Anthropics publiekgerichte deel van de Mythos 5-lijn — dezelfde familie die ik ontleedde toen Fable 5 en Mythos 5 werden gelanceerd. Het is oprecht uitstekend in langetermijnredenering, synthese over meerdere bestanden en het soort oordeelskundige beslissingen waar goedkopere modellen struikelen. Maar het factureert tegen een tarief dat verspilling bestraft. En de abonnementssituatie maakt dit scherper, niet zachter:

• Fable was gratis op Pro en Max van 9 juni tot en met 22 juni 2026. Op 23 juni trok Anthropic het terug uit de planlimieten — voortgezet gebruik draait op gebruikstegoed tegen API-tarieven (per Anthropics uitrol).
• Binnen het abonnementsvenster telde Fable ruwweg het dubbele van Opus mee voor je limieten. Op het Max-plan van $200/maand met zijn ~5-uur sessievensters kon intensief gebruik van Fable je weekbudget in dagen uitputten, waarna de modelselector je stilletjes naar Sonnet terugzet.

Je krijgt dus een korte wittebroodsweken waarin Fable gratis aanvoelt, gevolgd door een harde muur waar elke token een dollarteken draagt. Als je je AIOS tijdens die periode ontwerpt met de aanname dat Fable overal draait, krijg je een brutale rekening zodra het venster sluit. Het systeem moet vanaf dag één ontworpen zijn voor de realiteit na 23 juni.

Die ene beperking — het slimste model is te duur om voor alles te gebruiken — geeft uiteindelijk vorm aan elke andere beslissing. Houd dit in gedachten, want het is de rode draad door alle vier de C's.

De Vier C's: De Architectuur die een Factuur Overleeft

Ik organiseer het hele systeem rond vier lagen, gebouwd in strikte volgorde: Context, Connecties, Capaciteiten, Cadans. Je kunt niet vooruit springen. Cadans zonder Capaciteiten is een cron-taak die in het niets vuurt. Capaciteiten zonder Connecties is een slim notitieboek. Connecties zonder Context is een agent die handelt namens een vreemde.

Wat volgt is niet de generieke versie van dit framework. Het is de versie die ervan uitgaat dat je redeneermodel $50 per miljoen output-tokens kost — omdat die aanname verandert hoe elke laag er daadwerkelijk uit moet zien.

Ik noemde mijn build "Herk 2" — de tweede iteratie van een langlopend project om al mijn persoonlijke en zakelijke kennis in één systeem te zetten dat met me meedenkt in plaats van alleen op te slaan wat ik al heb bedacht. De naam doet er niet toe. De volgorde wel.

Context: Gewone Markdown, Omdat Tokens Nu Geld Zijn

Context is de statische laag — alles wat het systeem over mij weet dat niet per minuut verandert. Doelen. Bedrijfsmodel. Klantenlijst. Merkgeluid. Processen. Het archief van beslissingen die ik al heb genomen zodat ik ze niet opnieuw hoef te bespreken.

Alles leeft in markdown-bestanden in één repository, verankerd door een CLAUDE.md in de root. Geen database. Geen vectoropslag. Platte tekstbestanden in mappen die ik met mijn eigen ogen kan lezen.

Mensen nemen aan dat je een fancy ophaalsysteem nodig hebt voor een kennisbank. Op persoonlijke en vroege bedrijfsschaal heb je dat niet — en op Fable is de verkeerde keuze actief duur. Een goed georganiseerd bestandssysteem kan een verrassend grote kennisbank aan zonder enige database. De CLAUDE.md fungeert als een routeringsboom: het bevat niet de kennis, het bevat de kaart naar de kennis, die de agent vertelt welk bestand te openen voor welke vraag.

herk2/
├── CLAUDE.md                    # de routeringsboom — wijst naar alles
├── context/
│   ├── business.md              # model, aanbod, prijzen, positionering
│   ├── clients.md               # topaccounts, status, geschiedenis
│   ├── goals.md                 # kwartaal + jaar, met het waarom
│   ├── voice.md                 # hoe ik schrijf, wat ik nooit zeg
│   ├── decisions/               # één bestand per grote beslissing, gedateerd
│   └── archives/                # afgeronde projecten, post-mortems
├── connections/                 # API-wrappers, beperkte sleutels
├── skills/                      # benoemde capaciteiten, één map per stuk
└── automations/                 # cadans — triggers en schema's

Waarom is dit belangrijk voor kosten? Omdat de routeringsboom betekent dat Fable alleen het ene relevante bestand laadt in plaats van de hele kennisbank in de context te proppen. Wanneer input $10 per miljoen tokens kost, is het laden van 40 markdown-bestanden die je niet nodig hebt bij elke query echt geld. De router houdt elke aanroep slank.

Er is ook een stiller voordeel. Gewone markdown is modelagnostisch. Exact dezelfde context/-map werkt of de agent die het leest nu Fable, Sonnet of een niet-Anthropic-model zoals Codex is. Ik zit niet vast aan één leverancier. Als een goedkoper model volgend kwartaal goed genoeg wordt, wissel ik de motor en behoud ik het brein. Probeer dat maar eens met een eigen databaseschema dat aan de embeddings van één leverancier is gekoppeld.

Om dit alles te vullen zonder drie weken uit te stellen, gebruik ik een interviewvaardigheid — ik kom erop terug in het Capaciteiten-gedeelte, want het is de beste truc die ik heb gevonden om snel context op te bouwen. Onthoud voor nu: context is het fundament, het leeft in markdown, en de routeringsboom is wat voorkomt dat je Fable-rekening explodeert.

Connecties: API-Sleutels Zijn je Echte Rechtenlaag

Zodra het systeem weet wie ik ben, moet het de live wereld bereiken. Connecties zijn de dynamische laag — API's naar Stripe, QuickBooks, Google Workspace, ClickUp, Slack. Dit is wat het AIOS in staat stelt om de omzet van vandaag te lezen, de agenda van vanmorgen, de daadwerkelijke ongelezen threads, in plaats van te redeneren over een verouderde snapshot.

Hier is de les die me het meest heeft gekost om te leren, en het heeft niets met tokens te maken.

Ik had een agent wiens taak het was om mijn inbox te triëren en conceptantwoorden te maken voor mijn beoordeling. De instructies waren expliciet: alleen concept, nooit verzenden, altijd eerst aan mij laten zien. Op een ochtend interpreteerde het een meerstapsinstructie verkeerd — het las "stuur de follow-up naar de lijst die we bespraken" als een instructie om daadwerkelijk te verzenden, naar een daadwerkelijke lijst. Het verzond. Naar echte mensen. Een e-mail die nergens klaar voor was.

Ik ving het snel op en de schade was beperkt — een ongemakkelijk "graag negeren" bericht erachteraan. Maar de les was permanent: een prompt is geen rechtensysteem. Een agent vertellen "verzend geen e-mails" is een suggestie. Het is een tekstreeks die het model verkeerd kan lezen, net zoals ik een verkeersbord verkeerd kan lezen in het donker. Echt vertrouwen komt doordat de agent fysiek niet de mogelijkheid heeft om te doen wat je niet wilt dat het doet.

Dus nu wordt elke connectie beheerst door de scope van de API-sleutel, niet door de beleefdheid van mijn prompts. De e-mailtriage-agent heeft een sleutel met lees- en conceptrechten en niets anders. Het kan niet verzenden, omdat het credential dat het heeft gekregen die scope niet draagt. Als het een instructie verkeerd interpreteert, is het ergste geval een concept dat in mijn map blijft liggen. De rechtenlaag leeft bij de sleutel, waar het model er niet tegenin kan gaan.

# FOUT — rechten als suggestie waar het model over kan struikelen
SYSTEM: Je mag e-mails lezen en concepten maken. Nooit verzenden. Altijd eerst bevestiging vragen.

# GOED — rechten als harde grens op het credential
GMAIL_KEY scope: gmail.readonly, gmail.compose   # geen gmail.send. Ooit.

Beperk de scope van elke sleutel tot het minimum dat de taak nodig heeft. Alleen-lezen waar alleen-lezen volstaat. Concept, niet verzenden. Toegang tot één project, niet accountbreed. Dit is vervelend om op te zetten en het is het belangrijkste beveiligingswerk in het hele systeem — vooral omdat Anthropics modellen closed-source zijn, dus je vertrouwt een black box met toegang tot je bedrijf. Hoe smaller de sleutel, hoe kleiner de schade wanneer er iets misgaat. En er zal iets misgaan. Bij mij verzond het een e-mail. Bij jou doet het iets anders.

Die fout heeft ook hervormd hoe ik over de volgende laag denk. Want hoe capabeler je vaardigheden worden, hoe meer het uitmaakt wat ze mogen aanraken.

Capaciteiten: Vaardigheden, Sub-Agents en de Kunst om Fable Niet te Gebruiken

Capaciteiten zijn de werkwoorden van het systeem — de benoemde vaardigheden, agents en automatiseringen die daadwerkelijk dingen doen. Elk is een map met een SKILL.md die definieert wat het doet en wanneer het laadt. Ze variëren van een prompt van één alinea ("vat dit transcript samen in mijn stem") tot een meerstapsworkflow die onderzoekt, schrijft, beoordeelt en publiceert.

De architectuurles hier kwam van het zien hoe mijn vaardigheden slechter werden naarmate ze groter werden. Een enkele agent die probeert te onderzoeken en te schrijven en te polijsten in één lange sessie lijdt aan contextdrift — tegen de tijd dat het polijst, is het de onderzoeksopdracht half vergeten, en de output drijft af. De oplossing is modulariteit: aparte sub-agents in aparte sessies, elk met één taak. Eén agent onderzoekt en draagt een schone briefing over. Een frisse agent schrijft vanuit die briefing zonder onderzoeksrommel in de context. Een derde polijst. Schone overdrachten, geen drift. Ik leerde dit patroon op de harde manier, dezelfde les die ik steeds opnieuw leer bij multi-sessie agent-workflows.

Maar de beslissing die er daadwerkelijk toe doet voor een Fable AIOS is welk model elke sub-agent aandrijft. En het antwoord is meestal niet Fable.

Dit is de kern van het hele verhaal. Delegatie is niet alleen een kwaliteitspatroon — op Fable is het een overlevingspatroon. Fable is een senior strateeg wiens uurtarief meedogenloos is. Je laat je duurste persoon geen data-invoer doen. Dus ik delegeer agressief:

• Fable doet het oprecht moeilijke, onomkeerbare werk met hoge oordeelsvaardigheid: de uiteindelijke synthese, de strategische keuze, het ding waarbij fout zijn kostbaar is. De 10% van het werk die $50 per miljoen tokens rechtvaardigt.
• Sonnet doet het merendeel van het eigenlijke werk: schrijven, samenvatten, data transformeren, het parallelle routinewerk. Het is een fractie van de kosten en goed genoeg voor 80% van de taken.
• Haiku doet het triviale, hoogvolume werk: classificatie, extractie, snelle opzoekingen, de dingen die je honderden keren zou draaien.

Het patroon dat dit laat werken is uitwaaieren, dan aggregeren. Wanneer een taak onafhankelijke parallelle delen heeft — zeg, "vat deze acht klantthreads samen" — geef ik ze niet allemaal aan Fable. Ik waaier ze uit naar acht goedkope Haiku- of Sonnet-workers die parallel draaien, elk een strakke samenvatting producerend. Pas dan, en alleen dan, ontvangt Fable de acht geaggregeerde samenvattingen en doet het ene waarvoor het waard is te betalen: het dwarsdoorsnijdende oordeel. "Klant drie en klant zeven zijn beiden stilletjes ontevreden over dezelfde leveringsvertraging — hier is het patroon, hier is wat ik zou doen." Dat inzicht is $50 per miljoen tokens waard. Acht ruwe threads lezen om het te produceren is dat niet.

Het kostenverschil is niet marginaal. Fable's output is het dubbele van Opus en vele malen duurder dan Sonnet. De routine 80% van het werk naar goedkopere workers duwen en Fable reserveren voor de onvervangbare 20% is het verschil tussen een AIOS dat je dagelijks kunt draaien en een dat je uitschakelt na de eerste factuur.

Als je maar één ding bouwt van dit bericht, bouw dit: een "Grill Me"-vaardigheid. Het interviewt je meedogenloos, stelt vraag na vraag om kennis te extraheren die je nooit zou gaan zitten opschrijven. "Wat is je uurtarief? Waarom dat bedrag? Welke klant zou je ontslaan als je kon? Hoe ziet een goede week er werkelijk uit?" Elk antwoord wordt geschreven naar het juiste contextbestand als gestructureerde markdown. Het transformeert jouw gepraat in een gevulde kennisbank — en het beste is dat je de interviewer op goedkope Sonnet kunt draaien, want goede vragen stellen vereist geen frontier-model. (Er is een compleet vaardigheid gebouwd rond dit interviewpatroon als je een voorsprong wilt.)

Als je dit delegatiesysteem liever niet zelf in elkaar zet, is dit precies het soort systeem dat ik voor klanten bouw — je kunt hier zien wat ik aanneem. Maar eerlijk gezegd is het bovenstaande framework genoeg om dit weekend solo te beginnen.

Nog een capaciteitsles die me herhaaldelijk heeft gered: verifieer outputs, vertrouw ze niet blindelings. Wanneer een vaardigheid iets visueels of functioneels bouwt — een rapport, een dashboard, een gegenereerde pagina — laat ik het daadwerkelijk draaien en het resultaat controleren, niet alleen succes verklaren. Een agent die zegt "klaar!" is niet hetzelfde als iets dat werkt. Dynamisch, functioneel testen van AI-output is niet-onderhandelbaar zodra het systeem zelfstandig handelt.

Wat ons brengt bij de laag waar het volledig zelfstandig handelt.

Cadans: Wanneer het Systeem Draait Zonder Jou

Cadans is wanneer dingen afvuren. Drie triggertypes: gepland (elke ochtend om 6 uur), event-gebaseerd (een nieuwe Stripe-afschrijving, een GitHub-push, een inkomende e-mail), en handmatig (ik typ /dagplan). Cadans is wat een slimme assistent transformeert in een besturingssysteem dat werkt terwijl ik slaap.

Het is ook waar kosten, beveiliging en onderhoud tegelijkertijd botsen. Een vaardigheid die je handmatig triggert draait wanneer jij kiest, onder je ogen. Een vaardigheid op een cadans draait of je kijkt of niet — wat betekent dat een Fable-aangedreven automatisering die elk uur afvuurt een Fable-rekening is die elk uur oploopt, voor altijd, zelfs op de dagen dat het niets nuttigs produceert.

Dus mijn cadansregels zijn strikt:

1. Geplande Fable-taken zijn zeldzaam en alleen voor hoge waarde. De strategische ochtendbriefing, ja — eenmaal per dag, en zelfs dan wordt het verzamelen gedaan door goedkope workers en raakt alleen de uiteindelijke synthese Fable. Alles routinematig draait op Sonnet of Haiku op schema.
2. Elke automatisering wordt gemonitord. Autonomie verwijdert niet de noodzaak van menselijk toezicht — het verhoogt de inzet van het niet hebben ervan. Ik log elke geautomatiseerde run en scan de logs. De e-mailblast leerde me dat een agent die onbewaakt op een schema handelt precies is hoe kleine misinterpretaties echte-wereld-events worden.
3. Kostenplafonds per automatisering. Elke geplande taak heeft een ruw tokenbudget. Als een run daar voorbij schiet, is dat een signaal dat de vaardigheid is afgedreven of de input is opgeblazen, en het wordt gemarkeerd.

Dit is dezelfde discipline die ik toepas op geplande Claude-automatiseringen in het algemeen — maar Fable maakt de kostenregel van dat grootboek onmogelijk te negeren. Op een goedkoop model is een op hol geslagen cron-taak vervelend. Op Fable is het een verrassing van vier cijfers.

Bouw de vier C's in volgorde en je eindigt met iets dat oprecht verschilt van een chatbot: een systeem dat je context vasthoudt, je echte tools bereikt via beperkte sleutels, zijn vaardigheden blootstelt als benoemde capaciteiten, en ze draait op een cadans die jij controleert — het meeste op goedkope modellen, met Fable gereserveerd voor de momenten die werkelijk een frontier-brein nodig hebben.

Hoe het Eruitziet Wanneer het Werkt

Ik wil specifiek zijn over het resultaat, want "tweede brein" is een uitdrukking die is leeggezogen door mensen die Notion-templates verkopen.

Twee demo's overtuigden me dat het systeem echt was. De eerste: ik richtte het op een lang YouTube-kanaal en vroeg om een gestructureerde analyse van de contentstrategie van de maker. Het haalde de transcripties op, verdeelde het samenvatten over goedkope workers, en gaf Fable het geheel — dat een oprecht scherpe lezing produceerde van de positionering en hiaten van het kanaal, in één enkele prompt. Het gruntwerk was goedkoop; alleen het inzicht was duur.

De tweede was nuttiger voor dagelijks gebruik: een interactieve relatiekaart van mijn eigen tools, workflows en projecten, gegenereerd uit mijn contextmap in één prompt — welke automatisering welk project voedt, welke vaardigheid afhankelijk is van welke connectie. Mijn eigen systeem als een grafiek zien bracht twee afhankelijkheden aan het licht die ik was vergeten.

De realistische resultaten, eerlijk vermeld zonder verzonnen cijfers:

• Kosten voor contextophaling daalden aanzienlijk zodra de routeringsboom "laad alles" verving. Input-tokens zijn de goedkope helft van Fable, maar 40 overbodige bestanden laden bij elke aanroep telde toch op — de router reduceerde dat tot de een of twee bestanden die een taak werkelijk nodig heeft.
• Het delegatiepatroon is waar de echte besparingen zitten. De routine ~80% van het werk van Fable af verplaatsen naar Sonnet en Haiku is de enige verandering die dagelijks gebruik betaalbaar maakte. Jouw resultaat hangt af van je takenmix, maar de richting is niet subtiel — frontier-output tegen $50 per miljoen tokens is iets dat je rantsoeneer, niet iets dat je rondsproeit.
• Het dure deel is nu mijn aandacht, niet de API. Onderhoud is de werkelijke doorlopende kost. Connecties breken. API's veranderen. Vaardigheden driften af. Een systeem dat zo capabel is, is een systeem dat je onderhoudt, niet een dat je instelt en vergeet.

Als je evalueert of dit je tijd waard is, is dat laatste punt de eerlijke kanttekening. Laten we het dus hebben over de delen die niet in de hoogtepunten zitten.

De Eerlijke Waarheid: Wat Dit Je Kost Dat Niet op de Factuur Staat

De tokenrekening is de kost waar mensen op fixeren. Het is niet degene die je te pakken krijgt.

De grootste uitdaging zijn mensen, niet modellen. Een persoonlijk AIOS bouwen is moeilijk maar haalbaar — je controleert elke variabele. Op het moment dat je probeert het uit te breiden naar een team, vermenigvuldigt de moeilijkheid zich. Gedeeld kennisbeheer, collega's zover krijgen dat ze hun context daadwerkelijk onderhouden, mensen trainen om in vaardigheden en delegatie te denken in plaats van eenmalige prompts — dat is organisatieverandering, en geen enkel model lost het op. Als je een solo-ondernemer bent, heb je hier een enorm, onderschat voordeel: er is niemand te overtuigen behalve jezelf.

Closed-source betekent een black box vertrouwen met je bedrijf. Anthropic opent het model niet. Je stuurt echte omzetgegevens, echte klantinformatie, echte agenda's door infrastructuur die je niet kunt inspecteren. Daarom is de rechtenlaag met beperkte sleutels geen optionele paranoia — het is de enige echte controle die je hebt. Ga bewust om met gevoelige gegevens: wat moet werkelijk naar het model stromen, en wat kan in bestanden blijven die de agent lokaal leest zonder een retour naar een API.

De architectuur zal het contact met de realiteit niet onveranderd overleven. Die van mij is al eenmaal herbouwd — daarom heet het "Herk 2." Je zult latentieproblemen tegenkomen, verrassingen in tokenverbruik, een vaardigheid die prima werkte totdat je kennisbank verdrievoudigde. Het systeem evolueert op basis van wat daadwerkelijk breekt, niet wat je gepland had. Bouw het met de verwachting het te refactoren.

Besteed je denken niet uit — werk er samen mee. Het meest waardevolle gebruik dat ik heb gevonden is helemaal geen automatisering. Het is het systeem gebruiken als denkpartner: meerdere sub-agents opzetten die een beslissing vanuit verschillende hoeken beargumenteren, en dan het debat lezen. Het AIOS dat je routinewerk afhandelt is nuttig. Degene die je oordeelsvermogen aanscherpt is degene die het waard is om te bouwen.

Hier is de voorspelling die ik durf vast te leggen: de mensen die winnen met frontier-modellen zoals Fable zullen niet degenen zijn die ze het meest gebruiken. Het zullen degenen zijn die ze het minst gebruiken — die systemen hebben gebouwd die gedisciplineerd genoeg zijn om $50-per-miljoen-tokens alleen te besteden aan het handjevol beslissingen dat werkelijk een frontier-brein verdient, en al het andere naar workers te sturen die een tiende kosten. Terughoudendheid is de vaardigheid. Het model is slechts de motor.

Het Ene Ding om Deze Week te Doen

Ga terug naar het allereerste getal in dit bericht — de $50. Kijk dan naar welke AI-workflow je nu draait en stel de vraag die mijn hele project een nieuw kader gaf: wat hier heeft werkelijk het slimste, duurste model nodig, en waarvoor betaal ik te veel?

Je hebt Fable niet nodig om te beginnen. Je hoeft niet alle vier de C's dit weekend te bouwen. Begin met Context: open een map, maak een CLAUDE.md, schrijf in gewone markdown op wie je bent en wat je bedrijf doet. Dat ene bestand — het fundament waar al het andere op staat — kost niets en werkt met elk model dat je ooit zult inwisselen.

Het tweede brein slaat op wat je al weet. Het AIOS handelt erop. Maar de discipline die bepaalt of het jouwe betaalbaar of verlaten is, is het ene ding dat geen enkel model voor je zal bouwen: precies weten wat het waard is om diep over na te denken, en wat niet.

Dus — als je vanavond die audit op je eigen stack zou uitvoeren, wat zou je ontdekken dat je tegen een strategentarief hebt laten doen?

Veelgestelde Vragen

Wat is een Claude Fable AIOS?

Een Claude Fable AIOS is een persoonlijk AI-besturingssysteem dat Claude Fable 5 als redeneermotor gebruikt om op je kennisbank te handelen. Het combineert een markdown "tweede brein" met live API-verbindingen, benoemde vaardigheden en geplande automatiseringen — gebouwd op het Vier C's-framework van Context, Connecties, Capaciteiten en Cadans.

Hoeveel kost het om een AIOS op Claude Fable 5 te draaien?

Claude Fable 5 kost $10 per miljoen input-tokens en $50 per miljoen output-tokens — het dubbele van Opus 4.8 en het duurste algemeen beschikbare Anthropic-model. Een heel AIOS op Fable draaien is niet praktisch; de betaalbare aanpak delegeert routinewerk naar goedkopere Sonnet- en Haiku-workers en reserveert Fable voor synthese met hoog oordeelsvermogen. Zie het Capaciteiten-gedeelte hierboven.

Wat zijn de Vier C's van een AI-besturingssysteem?

De Vier C's zijn Context (statische markdown-kennis), Connecties (live API-integraties), Capaciteiten (benoemde vaardigheden en agents) en Cadans (geplande en event-gebaseerde automatiseringen). Ze bouwen in strikte volgorde — elke laag is afhankelijk van de vorige, zoals uitgelegd in het architectuurgedeelte hierboven.

Waarom API-sleutelscopes gebruiken in plaats van promptinstructies voor AI-veiligheid?

Omdat een prompt een suggestie is die het model verkeerd kan interpreteren, terwijl een API-sleutelscope een harde grens is die het fysiek niet kan overschrijden. Nadat een agent per ongeluk een echte e-mail verzond ondanks "nooit verzenden"-instructies, heb ik alle rechten verplaatst naar beperkte credentials — de e-mailagent heeft nu een sleutel zonder verzendtoegang, zodat het verkeerd lezen van een instructie geen schade kan veroorzaken.

Kan ik van model wisselen zonder mijn AIOS te herbouwen?

Ja — als je context in gewone markdown-bestanden leeft in plaats van in een eigen database. Omdat de kennislaag modelagnostische tekst is, kun je Claude Fable verwisselen voor Sonnet, Opus of zelfs een niet-Anthropic-model zoals Codex zonder het systeem te herbouwen. Alleen de redeneermotor verandert; het brein blijft.

Laten We Samenwerken

Wil je AI-systemen bouwen, workflows automatiseren of je technische infrastructuur opschalen? Ik help je graag.

• Fiverr (maatwerkprojecten & integraties): fiverr.com/s/EgxYmWD
• Portfolio: mejba.me
• Ramlit Limited (enterprise-oplossingen): ramlit.com
• ColorPark (design & branding): colorpark.io
• xCyberSecurity (beveiligingsdiensten): xcybersecurity.io