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: terwijl het de omgeving opbouwt van een proces dat jij hebt laten starten, of, als je live data voor HTML-weergaven in een project hebt aangezet, wanneer het een header toevoegt aan een verzoek naar een endpoint dat je hebt toegestaan, die de pagina nooit ziet. 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. De enige uitzondering is optioneel en geldt per project: een verzoekheader voor een endpoint dat je hebt toegestaan voor je HTML-weergaven, toegevoegd door het hoofdproces en nooit getoond aan de pagina.
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 MCPWaar worden mijn geheimen opgeslagen?
Kan mijn AI-agent mijn geheimen lezen?
Worden mijn geheimen gesynchroniseerd met servers van AgentsRoom?
Hoe gebruik ik een geheim in een commando?
Wat gebeurt er als mijn machine geen OS-sleutelhanger heeft?
Vervangt dit de omgevingsbestanden in mijn project?
Als iemand het kluisbestand kopieert, kan hij het dan lezen?
Welke MCP-tool gebruiken mijn agenten voor geheimen?
Je vindt misschien ook leuk
Databaseverbindingen
Bewaar je MySQL-, PostgreSQL-, SQL Server-, MongoDB-, SQLite- en Google BigQuery-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. Exporteren, importeren en een database over een andere heen kopiëren voor MySQL, PostgreSQL en MongoDB.
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.
Agents die je leest als een gesprek
Elke agent heeft een rol, een gezicht en een draad die je leest als een chat-app.
