Identityguide
Identity security: phishing-resistant login, usable recovery and verified offboarding
An operating procedure for the accounts that control email, cloud infrastructure, source code and company recovery.
The field manual
Small controls.
Fewer bad days.
Operational security is the routine work between incidents: checking who can change DNS, rehearsing account recovery, and making sure yesterday’s backup actually restores. These guides turn that work into specific reviews and repeatable drills.
Using an agent for real work?
Check what it can actually do.
Review personal assistants, financial permissions, MCP integrations and unfamiliar code in a dedicated set of task-specific guides.
Open the agent field manual ↗Use a planning worksheet ↗Start with the dependency chain
01 / Regain access
Protect the roots.
Identity and email recovery determine who can regain control of almost everything else.
Identity & recovery ↗02 / Control changes
Protect what ships.
Review the path from a developer’s browser to the repository, build pipeline and production credentials.
Repositories & CI ↗03 / Rehearse recovery
Know how to stop.
Give the team a tested way to preserve evidence, suspend risky activity and restore a trusted system.
Run a tabletop ↗31 notes
Emailguide
Email security: protect the recovery inbox and control who can send as your domain
Separate mailbox compromise, domain spoofing and support impersonation into controls with observable tests.
Domains & DNSguide
Domain and DNS security: preserve control of the address your users trust
A runbook for registrar ownership, scoped DNS changes, renewal resilience and safe nameserver recovery.
Devicesguide
Developer device security: isolate experiments from production authority
A practical baseline for laptops that handle source code, external repositories, credentials and sensitive client material.
Browsersguide
Browser and extension security: reduce the code surrounding every privileged session
Inventory permissions, separate sensitive browsing and prepare for malicious extensions or stolen browser sessions.
GitHub & CI/CDguide
GitHub and CI/CD security: keep untrusted changes away from deployment authority
A review procedure for workflow triggers, action revisions, runner isolation and cloud deployment identity.
Packages & publishingguide
Package publishing security: control who can ship and what consumers execute
A practical process for registry access, trusted publishing, provenance, dependency review and compromised releases.
Cloud & secretsguide
Cloud IAM and secrets: reduce standing access and prove revocation
An operating model for human roles, workload identities, secret consumers and emergency cloud access.
Databases & backupsguide
Production data and backups: prove you can recover without giving attackers a second copy
A runbook for database access, backup isolation, retention, restoration and safe evidence during data incidents.
APIs & authorizationguide
API authorization: test the actor, object and action together
A practical review method for cross-tenant access, administrative functions, exports, background jobs and failure behavior.
Treasury & signingguide
Multisig treasury operations: verify the transaction and every path around the threshold
An operating runbook for signer independence, privileged transactions, modules, monitoring and recovery rehearsal.
Community & supportguide
Community and support security: protect announcements without becoming a recovery scam
Practical controls for moderators, bots, public links, support evidence and incident communications.
AI agents & MCPguide
AI agent and MCP security: constrain the tool, not just the prompt
A runbook for agent integrations, local servers, authorization, data access and realistic prompt-injection tests.
Incident responseguide
Incident evidence: preserve what happened without spreading the breach
A procedure for first-response records, log exports, file provenance, access restrictions and investigative handoff.
Incident readinessguide
Incident tabletop: rehearse decisions while the systems are still healthy
A repeatable exercise format for founders, engineering, security, support and the people authorized to stop operations.
Monitoringguide
Security monitoring: connect important events to an owner who can act
Build a small, testable detection system around identity changes, deployments, data access and treasury authority.
Frontend & third-party codeguide
Frontend security: review every script that can change what a user sees
A practical review of browser code, tag managers and content security policies, including the interactions a successful build can still break.
Security writingguide
Write a security finding someone else can verify
A review procedure for findings, incident narratives and technical articles: keep evidence, inference, recommendations and uncertainty separate.
Personal AI assistantsguide
Connect an AI assistant to email and calendars without delegating your entire identity
Decide what the assistant can read, draft, send and delete, then rehearse a malicious-message and disconnected-account scenario.
Financial agent operationsguide
Financial AI agents: separate research, transaction preparation and execution authority
Design payment and treasury workflows around verified destinations, transaction-bound approvals, limits and an independent stop control.
Research sandboxesguide
Run unfamiliar research repositories without lending them your laptop’s credentials
Inspect before executing, isolate dependencies and tests, constrain network and filesystem access, and verify disposal with dummy secrets.
Authorized security researchguide
AI-assisted bug bounty work: keep scope, execution and evidence under researcher control
Use agents for understanding and reproducible reporting while preserving program authorization, data boundaries and meaningful human validation.
MCP installation reviewguide
Before installing an MCP server: review the package, process and connected account separately
A preflight and change-review procedure for local and remote MCP integrations, from installation hooks to token revocation.
Agent credentials & recoveryguide
Agent credentials: issue the smallest useful secret and prove you can revoke it
An operating procedure for task-scoped identities, secret delivery, output review and recovery after unintended access or upload.
Browser agent sessionsguide
Browser agents and logged-in sessions: protect the account behind the tab
Review the authority inherited from cookies, browser profiles, connected sites and downloads before an agent uses an authenticated browser.
Memory & retrievalguide
Agent memory and RAG: prevent retrieved text from becoming persistent policy
Track source provenance, enforce current retrieval permissions and test whether poisoned content survives into later tasks.
Skills & pluginsguide
Review agent skills and plugins as instructions, dependencies and delegated authority
Inspect the whole instruction bundle, referenced resources and effective permissions before enabling a workflow extension or accepting its update.
Unattended automationguide
Unattended agents: bound schedules, retries, cumulative usage and stale approvals
Make repeated agent work stop predictably when permissions, timing, costs or external side effects no longer match the approved task.
Agent network isolationguide
Agents, localhost and internal networks: enforce what the executor can actually reach
Protect local bridges, development services, cloud metadata and internal APIs with explicit network and application boundaries.
Mobile assessment scopeguide
Scope a mobile security test: the app, the device and the API are separate boundaries
Prepare Android and iOS builds, device coverage, representative accounts and acceptance criteria so a mobile assessment answers a real release question.
Mobile links & platform entryguide
Mobile deep links: verify the destination without trusting the requested action
Review Android App Links, iOS universal links, custom schemes and exported entry points against account state, input validation and server authorization.
Research and guides are dated, curated publications. How we source and correct our work.