Je geheimen staan in de OS-sleutelhanger,
Niet in een prompt en niet in je repo
AgentsRoom bewaart API-sleutels, tokens en databasewachtwoorden in een kluis die je machine niet verlaat, versleuteld via de sleutelhanger van je besturingssysteem. Je verwijst ernaar op naam, en de app vult de waarde in wanneer een commando of een agent start.
Stop met het plakken van een token in een prompt omdat dat de snelste manier was om een agent los te trekken. Geef het geheim één keer een naam, gebruik overal elders {{secret:NAME}}, en laat de waarde staan waar die hoort.
Hoe AgentsRoom een geheim bruikbaar houdt voor je commando's en onleesbaar voor de agent die erom vraagt.
Elk project houdt uiteindelijk een handvol waarden over die niet gedeeld mogen worden: een betaalsleutel, een databasewachtwoord, een deploy-token, een API-sleutel voor de stagingomgeving. Zodra AI-coderingsagenten in beeld komen, gaan die waarden zich op de slechtst denkbare manier verplaatsen. Ze worden in een prompt geplakt om een agent los te trekken, hardcoded in een script dat de agent zelf schreef, of gedropt in een bestand dat drie commits later wordt meegenomen.
Het geheimenbeheer van AgentsRoom geeft ze één plek om te wonen. Een geheim is een naam en een waarde: je voegt het één keer toe, en AgentsRoom versleutelt het via de sleutelhanger van je besturingssysteem voordat het ooit de schijf raakt. De hele kluis is één bestand in je thuismap, geschreven met rechten die alleen de eigenaar toegang geven, en het verlaat nooit de machine waarop het is aangemaakt.
Vanaf dat moment raak je de waarde nooit meer aan. Je schrijft {{secret:NAME}} in een dev-commando of in de omgeving van een agent, en AgentsRoom zet de echte waarde ervoor in de plaats wanneer dat commando of die agent start. Je agenten kunnen de namen opsommen en vragen om er een te laten injecteren, wat genoeg is om hun werk te doen, en de waarde zelf krijgen ze nooit.
Een kluis gebouwd voor een machine vol AI-agenten
Versleuteld door het besturingssysteem, aangeroepen op naam, ingevuld op het laatst mogelijke moment.
Versleuteld door je OS-sleutelhanger
Elke waarde wordt versleuteld via Electron safeStorage, wat betekent dat de versleutelingssleutel bij de sleutelhanger van je besturingssysteem ligt en niet bij AgentsRoom. De app bewaart versleutelde data en vraagt het systeem om die te ontsleutelen, precies zoals de andere applicaties waaraan je nu al inloggegevens toevertrouwt.
Eén kluisbestand, alleen voor de eigenaar
Al je geheimen staan in één kluis op ~/.agentsroom/secrets.json, geschreven met rechten die alleen de eigenaar toegang geven (0600) en bij elke wijziging atomair vervangen. Geen half geschreven bestand na een crash, en geen enkel ander gebruikersaccount op de machine kan hem openen.
Verwijs op naam, nooit op waarde
Een opgeslagen geheim gebruik je als {{secret:NAME}}: op de commandoregel van een dev-terminal, in de omgeving die een agent meekrijgt, overal waar je anders de inloggegevens had ingetypt. Wat je op je scherm leest, en wat je aan een teamgenoot zou kunnen laten zien, is de naam.
Ingevuld bij het starten, in het hoofdproces
De vervanging gebeurt wanneer het proces start, binnen het Electron-hoofdproces. De ingevulde waarde gaat naar de omgeving van het commando dat wordt gestart en nergens anders heen: niet naar een log, niet naar de interface, niet naar een bestand op schijf.
Agenten zien namen, geen waarden
Een AI-agent kan de namen van je geheimen opsommen en vragen om er een te injecteren in iets dat hij op het punt staat uit te voeren. Er is geen enkel codepad dat een waarde teruggeeft aan een agent, aan de interfacelaag of via MCP. De agent werkt met de verwijzing, de app werkt met het geheim.
Geen sleutelhanger, geen opslag
Kan de machine geen werkende OS-sleutelhanger bieden, dan weigert AgentsRoom het geheim op te slaan in plaats van terug te vallen op platte tekst. Een kluis die stilletjes verwordt tot een gewoon bestand is erger dan geen kluis, dus die terugval bestaat simpelweg niet.
Op je machine door ontwerp, niet door een standaardinstelling
Je geheimen worden nooit naar servers van AgentsRoom gestuurd. Er is geen synchronisatieschakelaar om te controleren, geen cloudkluis om af te wijzen, en geen back-up van je sleutels ergens anders dan op je eigen schijf. De kluis wordt op de machine aangemaakt, versleuteld met een sleutel die de sleutelhanger van het besturingssysteem voor die machine bewaart, en daar blijft hij. Een kopie van het bestand op zichzelf is niets dat een andere machine kan openen.
Het verschil tussen een geheim gebruiken en een geheim lezen is in code afgedwongen, niet met een instructie in een prompt. De interfacelaag, de MCP-tools en elke agent praten over geheimen op naam. Alleen het Electron-hoofdproces maakt van een verwijzing een waarde, en alleen terwijl het de omgeving opbouwt van een proces dat jij hebt laten starten. Een agent vragen om voorzichtig te zijn met inloggegevens is een hoop. Geen functie hebben die de inloggegevens teruggeeft is een garantie.
Dat is wat het redelijk maakt om een agent tegen een betaalde API of een echte database te laten werken. De agent weet dat er een geheim met de naam STRIPE_SECRET_KEY bestaat en kan vragen om het te injecteren in het commando dat hij wil uitvoeren. Hij kan het niet afdrukken, niet kopiëren naar een bestand dat hij schrijft, en niet laten weglekken in een gesprek dat ergens anders wordt bewaard.
Van een geplakt token naar een geheim met een naam
Drie stappen, en de waarde komt nooit meer in beeld.
Voeg het geheim één keer toe
Geef het een naam en plak de waarde een laatste keer. AgentsRoom versleutelt hem via de OS-sleutelhanger en schrijft hem in de kluis op ~/.agentsroom/secrets.json, alleen voor de eigenaar en atomair. Heeft de machine geen bruikbare sleutelhanger, dan zegt de app dat en weigert, in plaats van platte tekst weg te schrijven.
Verwijs ernaar met {{secret:NAME}}
Gebruik de verwijzing overal waar de waarde stond: in het commando dat je dev-server start, of in de omgeving van een agent die een API-token nodig heeft. Wat in je instellingen wordt bewaard is de verwijzing, en daar mag iedereen naar kijken.
Laat AgentsRoom hem invullen bij het starten
Wanneer het commando of de agent start, ruilt het hoofdproces de verwijzing om voor de echte waarde in de omgeving van dat proces. Je tooling krijgt wat ze nodig heeft, en de agent die eraan stuurt kende nog steeds alleen de naam.
Wanneer geheimenbeheer geen optie meer is
De situaties waarin geplakte inloggegevens uitmonden in een echt incident.
Dev-servers die echte sleutels nodig hebben
Je dev-server start niet zonder een betaalsleutel en een databasewachtwoord. Zet {{secret:NAME}} in het startcommando in plaats van de inloggegevens, en dat commando wordt iets dat je tijdens een call gerust in beeld kunt laten staan, zonder een moment van paniek.
Agenten die een betaalde API aanroepen
Een agent heeft tijdens zijn werk een token nodig om een externe API te bereiken. Voeg het geheim op naam toe aan zijn omgeving: de agent krijgt een werkende omgeving, en het token staat niet in de prompt, niet in het gesprek en niet in wat de agent daarna schrijft.
Sleutels die niet meer in de repo belanden
Het klassieke ongeluk zijn inloggegevens die in een configuratiebestand terechtkomen dat een latere commit meeneemt. Op naam naar geheimen verwijzen betekent dat het bestand in de repository een naam bevat, dus er valt niets te lekken wanneer de branch wordt gepusht.
Eén machine, veel projecten
Eén kluis, beschermd door je OS-sleutelhanger en alleen leesbaar voor je eigen gebruikersaccount, bedient elk project dat je opent. Elk project verwijst naar de namen die het nodig heeft, en geen van hen houdt er een eigen verspreide kopie van inloggegevens op na.
Hoe kan een agent een geheim gebruiken dat hij niet kan lezen?
Omdat inloggegevens gebruiken en inloggegevens lezen twee verschillende handelingen zijn, en AgentsRoom voor agenten alleen de eerste implementeert. De kluis wordt via MCP door precies één tool blootgesteld, secrets_list, en die geeft namen terug. Vanaf daar schrijft de agent {{secret:NAME}} in het commando of de omgeving die hij nodig heeft, en de vervanging wordt uitgevoerd door de app, niet door de agent.
Wat bewust ontbreekt is de andere richting. Geen enkele MCP-tool geeft een geheime waarde terug, de interfacelaag krijgt er nooit een, en niets toont er een terug in een gesprek. Een verwijzing omzetten in een echte waarde gebeurt binnen het Electron-hoofdproces, op het moment dat een proces wordt gestart, en het resultaat gaat naar de omgeving van dat proces en nergens anders heen.
Het praktische effect is dat een agent je testsuite tegen een echte database kan draaien, een betaalde API kan aanroepen of naar staging kan deployen zonder dat er ook maar één inloggegeven in zijn context belandt. Achteraf niets te redigeren, want er is nooit iets blootgesteld.
Ontdek AgentsRoom MCPFAQ
Waar worden mijn geheimen opgeslagen?
In één kluisbestand op ~/.agentsroom/secrets.json in je thuismap. Elke waarde wordt versleuteld via Electron safeStorage, dus de versleutelingssleutel ligt bij de sleutelhanger van je besturingssysteem. Het bestand wordt geschreven met rechten die alleen de eigenaar toegang geven (0600) en atomair vervangen, zodat een crash het nooit halfgeschreven achterlaat.
Kan mijn AI-agent mijn geheimen lezen?
Nee. Een agent kan de namen van je geheimen opsommen en vragen om er een te laten injecteren in een commando of een omgeving, en dat is alles wat hij nodig heeft om werk te verzetten. Er is geen enkel codepad dat een waarde teruggeeft aan een agent, aan de interfacelaag of via MCP. Het invullen gebeurt alleen in het Electron-hoofdproces.
Worden mijn geheimen gesynchroniseerd met servers van AgentsRoom?
Nooit. De kluis blijft door ontwerp op je machine. Geheimen worden niet naar servers van AgentsRoom gestuurd, niet in een cloud geback-upt en niet doorgestuurd naar de mobiele app. Ze worden op jouw machine aangemaakt, voor jouw machine versleuteld, en daar blijven ze.
Hoe gebruik ik een geheim in een commando?
Schrijf {{secret:NAME}} waar de waarde had gestaan: in een commando in een dev-terminal, of in de omgeving van een agent. AgentsRoom zet de echte waarde ervoor in de plaats wanneer dat proces wordt gestart, en de verwijzing is wat er in je instellingen blijft staan.
Wat gebeurt er als mijn machine geen OS-sleutelhanger heeft?
Dan weigert AgentsRoom het geheim op te slaan. Er is bewust geen terugval die de waarde in platte tekst op schijf schrijft, want een kluis die stilletjes verwordt tot een gewoon bestand geeft je het vertrouwen van versleuteling zonder de versleuteling.
Vervangt dit de omgevingsbestanden in mijn project?
Het lost het deel van het probleem op dat pijn gaat doen zodra AI-agenten meedoen: de inloggegevens uit de bestanden, de prompts en de gesprekken houden. Je project houdt wat het tijdens runtime nodig heeft, en de waarde zelf staat in de kluis en wordt bij het starten geïnjecteerd, in plaats van in een bestand te blijven staan dat een agent kan lezen en een commit kan meenemen.
Als iemand het kluisbestand kopieert, kan hij het dan lezen?
Niet op een andere machine. De waarden zijn versleuteld met een sleutel die de sleutelhanger van je besturingssysteem bewaart, dus het bestand op zichzelf is versleutelde data. Daar bovenop wordt de kluis geschreven met rechten die alleen de eigenaar toegang geven, dus ook een ander gebruikersaccount op dezelfde machine kan hem niet openen.
Welke MCP-tool gebruiken mijn agenten voor geheimen?
secrets_list, en dat is de enige. Die geeft de namen terug van de geheimen die op deze machine zijn opgeslagen, zodat een agent kan ontdekken wat er bestaat en er vervolgens met {{secret:NAME}} naar kan verwijzen in een dev-commando of in de omgeving van een proces dat hij start. Geen enkele tool geeft een waarde terug, dus er is niets voor een agent om af te drukken, te kopiëren naar een bestand dat hij schrijft of te laten weglekken in een gesprek. Ontbreekt een geheim dat hij nodig heeft, dan vraagt hij jou om het in de app toe te voegen in plaats van je te vragen het in de chat te plakken.
Je vindt misschien ook leuk
Databaseverbindingen
Bewaar je MySQL- en MariaDB-verbindingen, bereik een database in een privaat subnet via een SSH-tunnel of een AWS SSM-sessie, en laat je AI-agenten er via MCP query's op uitvoeren. Standaard alleen-lezen, één statement per aanroep, begrensde resultaatsets, en het wachtwoord bereikt de agent nooit.
SSH-verbindingen
Bewaar je SSH-verbindingen, open een ingebouwde terminal via SSH, en voer Claude Code, Codex of Antigravity CLI direct uit op je externe server of VPS. SSH-sleutel of wachtwoordauthenticatie, verbindingprofielen per project, geen aparte SSH-client nodig.
Dev Terminals
Terminalmanager en processtarter per project. Start backend, frontend en workers met één klik, met je geheimen geïnjecteerd bij het starten in plaats van ingetypt.
AgentsRoom MCP
De MCP-server waarmee je agenten AgentsRoom zelf besturen: projecten, terminals, backlog en verbindingen, met de veiligheidsmaatregelen die erbij horen.
Geef je agenten toegang, niet je sleutels
Download AgentsRoom, verplaats je API-sleutels en wachtwoorden naar een kluis die versleuteld is door je OS-sleutelhanger, en verwijs er overal elders op naam naar.
Companion-app: houd je agents onderweg in de gaten
Breng je eigen: Claude, Codex, Antigravity CLI of andere AI-provider.
Stuur bugs en verzoeken direct naar je openbare backlog.
Een glimp van AgentsRoom in actie.