Since day one, our mission at GitGuardian has been clear: prevent accidental secret exposure and stand alongside developers as they build. We've helped thousands of teams secure their code repositories and other data sources, preventing credentials from leaking.
The risk has moved. Developer workstations have always carried more credential exposure than most teams realize: shell histories, config files, local caches accumulating credentials for years. AI coding agents are accelerating that risk. Tools like Cursor, GitHub Copilot, and other AI assistants are now running on thousands of developer machines with access to every credential and sensitive file on the laptop, creating accumulation paths that traditional security tools don't see.
Every developer laptop is a credential store. Infostealers and supply chain attackers treat it exactly that way. Credentials don't just live in Git. They end up in .env files, shell histories, AI agent configs, and local caches, sitting in plaintext outside your perimeter controls. A single compromised laptop can hand attackers the keys to your entire infrastructure. Our early access program data puts the average at 150 secrets per developer laptop, with some machines ranging into the thousands.
The partition between code-resident and endpoint-resident credentials no longer exists for attackers. And with AI coding agents now running on every developer machine, the surface is growing faster than most security stacks can track. That raises the question: how do we make sure companies can deploy AI safely?
What We've Built
Today we're releasing Developer Endpoint Protection: the ability to find every credential on every developer machine, built directly into ggshield, the GitGuardian CLI already in use across our customer base.
We rebuilt the scanning engine in Rust from scratch. In our latest tests, it scans 500,000 files in under one minute, then uses intelligent caching to complete subsequent scans in seconds. All scanning happens locally on the endpoint. Credentials are never sent to GitGuardian in clear text, and we never see the credentials.
Traditional endpoint tools chase binaries. Developer Endpoint Protection tracks the credentials and the AI tooling generating them. Each credential found maps back to the production systems it unlocks and every other place that same credential lives, building a continuous inventory you can monitor, alert on, and push into the tools you already use.
But scanning is only half the story. We also place honeytokens on developer machines. If an infostealer finds and uses one of those credentials, the honeytoken fires immediately, with attribution, before the attacker has used it. Instead of discovering a breach weeks later in a log review, you know the moment it happens and which machine was hit.
Why This Matters Now
1. Finding Credentials Beyond Repositories and Collaboration Tools
For years, we've been catching credentials leaking into code repositories and collaboration tools. Developer machines have always had the same problem: shell histories, config files, temp directories, and AI tool caches pile up credentials over time, invisible to the rest of your stack. Endpoint Protection takes that mission to the machine.
2. Closing the NHI Governance Blind Spot
Machine endpoints are a blind spot in NHI governance. Over-privileged service accounts, API keys, and machine credentials don't just live in vaults and cloud platforms. They're scattered across developer workstations. By surfacing endpoint findings in the GitGuardian dashboard, you can finally answer: "Where are our credentials actually living across our entire infrastructure?" and prioritize remediation based on what's sensitive and in active use.
3. Securing the Agentic AI Era
AI coding agents expand the attack surface. These agents operate with access to everything on a developer's machine: the credentials developers intentionally use and the ones that accumulate in shell histories, browser storage, and AI agent config files. In our analysis, around 40% of high and critical secrets surfaced in AI tool directories and log files, locations no traditional scanner looks at. Endpoint Protection gives you a full picture of that credential exposure as your AI footprint grows. We scan at three points in the AI workflow: prompt submission (before content reaches the model), pre-tool execution (before file reads or commands run), and post-tool output (after the agent responds). Each stage is an exposure path that traditional repository scanning never sees.
The platform also inventories which AI tools and MCP servers are running on each machine, surfacing unauthorized or potentially malicious MCPs before they can access or exfiltrate data.
Three Core Capabilities
Remediate at the source. Redact credentials from shell and command histories, migrate active credentials into vaults and local secrets managers, and prevent AI coding agents from spreading credentials across the machine through GitGuardian agent hooks. The goal is focused action, not endless triage.
Limit the blast radius. Continuously hunt plaintext credentials across the fleet, score each finding by severity and actual access scope, and route high-risk findings directly to your SOC, SIEM, and SOAR. When a breach lands, you can answer immediately: what was on this machine, what services does it reach, and what do we revoke first?
Detect live attacks. Honeytokens placed on developer machines fire the moment an infostealer validates a credential, confirming an attack before it's used against you. You get attribution-rich alerts in real time, not noise.
Because these signals are most powerful when correlated with your existing credential sources, endpoint findings feed directly into GitGuardian's NHI and Secrets Security platform, connecting your endpoint exposure to vaults, repos, and cloud environments in one place.
Designed for Real-World Enterprise Deployment
We know enterprise security teams need more than a cool demo. We're building for:
- Deployment at scale: MDM-based rollout (Windows/Intune, Jamf) with MDM-compatible authentication for large fleets
- Developer-friendly: minimal performance impact with intelligent caching, configurable exclusions, and CPU/memory limiting
- Privacy-first architecture: local scanning with no credential exfiltration; only structured metadata leaves the endpoint
- Integration with your existing stack: forward structured outputs to SIEM, pull data via API, correlate with vault and identity systems
- Cross-platform: Windows, Linux, macOS
Built on ggshield: One CLI, Expanded Mission
We deliberately built this as an extension of ggshield rather than introducing another tool. One CLI, expanded mission. If your team already uses ggshield for pre-commit hooks and CI/CD scanning, it slots into the same workflow your team already trusts.
We're already in conversations with Fortune 500 enterprises across financial services and technology where AI coding agent deployment has made endpoint credential visibility a real priority. The ask is consistent: give us endpoint credential visibility that fits our MDM rollout, our privacy requirements, and our SIEM.
Start Your Pilot
Developer Endpoint Protection finds credentials on developer machines and blocks them from moving into shared systems. It does not rotate credentials, manage vaults, or enforce remediation workflows; that's where Internal Secrets Monitoring and NHI Governance come in. Used together, the GitGuardian platform gives you coverage from endpoint to repository to identity.
Developer endpoints are the most unmonitored surface in secrets security. The organizations that know what credentials are on their machines recover faster from supply-chain incidents. The ones that don't find out during the breach.
We've extended our mission from the repo to the machines so that you can find every credential on every developer laptop before infostealers do.
Ready to see what's on your fleet? Contact your GitGuardian customer success team or book a demo.
