Inspiration
Companies usually learn about a leak from someone else: a reporter asking for comment, or a customer sending a link. By then an internal memo has been quoted in the press, or an API key has sat in a public paste for weeks.
Checking by hand doesn't scale, and most tools that could help need a copy of the company's private files on a vendor's servers. Security teams at banks, hospitals and government contractors can't do that.
We built Tracefold so that an enterprise security team can catch, fix and prevent leaks of company data privately, with everything running on their own devices or in their own VPC. Your documents and code are never sent to Exa, Tavily or any other service. The only thing search providers see is your company's name.
Who it's for:
- Buyer: the CISO or head of information security, at companies in financial services, healthcare, government and retail.
- Approvers: senior security leaders (VP, director or manager of security) with authority to approve takedowns and key shut-offs.
- Scanners: engineers and coding assistants, who scan and fix but can't approve.
What it does
- Catch. Searches the web for the company's name using Exa or Tavily, downloads the returned pages, and compares them with your files on your own machine. It also scans files for secrets (API keys, tokens), plus regulated data chosen by industry: card numbers, IBANs and routing numbers for financial services; medical record numbers and provider NPIs for healthcare; CUI markings for government.
- Fix. Drafts a takedown request to the site hosting the copy, addressed to that site's abuse or legal contact, and emails it once approved. Turns off a leaked AWS key through AWS IAM, or revokes a GitHub token through GitHub's revocation API. Every action needs one-click approval from a senior security lead.
- Prevent. Runs as an MCP server. Claude Code can scan uncommitted changes, fix a hardcoded secret and recheck it. Assistants can scan and fix but cannot approve takedowns or key changes.
- Keep checking. Scans can run on a schedule, at an exact interval from a start time.
Privacy (Privacy-first track):
- What Exa and Tavily see: only your company name, as the search query. They never see your files, file names, matched text or findings.
- How the name is found: the local model reads the company name out of your files on your machine, or the name comes from Settings.
- How pages are compared: Tracefold downloads each page Exa or Tavily returns straight from that site. It compares the page with your files on your machine, never on the search provider's servers.
- What leaves the device: search queries (company name only) and downloads of public pages. Nothing else, unless you turn on email or AWS fixes.
- Who can read your data: only your own deployment. Files, the database and the model stay on your machine or in your VPC.
- Proof:
- Outbound log: every scan lists each outbound request with its destination and purpose, so you can check that no search query contains file text.
- Hard rule: the engine refuses to send file text to any model that isn't on localhost.
- Wi-Fi off: in the demo, with Wi-Fi off, matching and model review still finish. Public search is reported as not finished instead of clean.
- Not kept: uploaded files stay in memory only. A scheduled scan keeps a private local copy of its files, and deleting the schedule deletes that copy.
- Disclosed limit: Claude Code is a cloud assistant, so findings it reads go to Anthropic.
Search (Surge track):
- Exa and Tavily are the core of public detection, and they never receive your data. They get a company name and return pages. Tracefold does the comparison locally, so search finds the candidate pages without seeing what you're protecting.
- Accurate: results are confirmed locally against the file's actual text before anything is reported.
- Citations hold up: each finding links the live URL and highlights the matching passage on both sides.
How we built it
- Engine: Python, FastAPI, SQLite. One outbound gateway enforces an allowlist of destinations and logs every request's purpose. Each scan lists exactly what left the machine.
- Exact matching: word shingles, confirmed token by token; a match needs at least 12 identical words in a row.
- Edited-copy matching: the share of a paragraph's three-word phrases that also appear on the page:
$$C(p)=\frac{|S_3(p)\cap S_3(\text{page})|}{|S_3(p)|},\qquad \text{flag if } C(p)\ge 0.4$$
- Local model: Ollama (qwen2.5:7b-instruct) on the same machine. It reviews flagged text and reads the company name out of files.
- Page memory: a file scanned again within 24 hours rechecks its known pages directly instead of searching again.
- Fixes: AWS keys are turned off with requests we sign ourselves (AWS's SigV4 scheme) and send through the gateway. GitHub tokens go to GitHub's public revocation API, which needs no setup.
- Checksums against false positives: Luhn for card numbers, mod-97 for IBANs and the ABA checksum for routing numbers.
- MCP adapter: exposes scan, read and recheck tools to coding assistants, using a token without the approve capability.
- Web app: Next.js. It shows a site count and a timeline, with matched passages highlighted side by side.
- Deployment: Docker images plus a Compose file for the web app, the engine and Ollama inside your VPC.
Challenges we ran into
- Searching for copies without sharing the original: the obvious way to find copied text is to search for the text itself, but that would send private content to a search provider. Instead we search for the company name only, then download the results and compare them locally.
- Edited copies vs. false alarms: exact matching misses paraphrased or trimmed copies, but loose matching flags every document on the same topic. We tuned the 0.4 containment threshold against unrelated real documents.
- Search cost: rescanning the same files kept paying for the same searches, until we added page memory.
- Small local models: they sometimes return unusable output, so we retry once and fall back to the saved company name.
- Honest results: a failed search must not look like a clean result. Scans say which checks didn't finish.
Accomplishments that we're proud of
- No file text reaches a search provider or a cloud model. This is enforced in code and shown in each scan's outbound log.
- Edited-copy detection that separates cleanly: edited copies scored 0.47 to 0.53, while unrelated security policies and same-topic text scored at most 0.07.
- Page memory: a repeat scan went from 12 search API calls to 0, with the same 4 findings.
- Real fixes, not just alerts: leaked AWS keys turned off through IAM and GitHub tokens revoked, each behind a human approval.
- Agent-safe by design: Claude Code found a hardcoded AWS key over MCP, moved it to an environment variable and rechecked, all without the power to approve anything.
- Runs in a VPC: the whole stack comes up with Docker Compose, and only the web app's port is published.
- Tests: 226 engine tests and 8 MCP adapter tests.
What's real vs. not built:
- Real, shown live: file scans, Exa and Tavily search, local exact and edited-copy matching, Ollama review, industry checks, scheduled checks, MCP scan, fix and recheck, AWS key disable, GitHub token revoke, VPC Docker deployment.
What we learned
- Privacy comes from what you leave out: not storing uploads, not sending text to search, and logging every outbound request.
- In security tools, wording matters. "Text from your files appears here" is accurate; "breach" is a claim.
- Approval only protects you if the right role holds it. Agents get scan and fix, but never approve.
What's next for Tracefold
- Talk to security teams: we haven't validated demand yet. First targets are regulated mid-size companies that need leak monitoring but can't send data to SaaS tools.
- Business model: a per-workspace license for self-hosted deployments, priced against the cost of one leaked credential or one leaked document.
- Takedowns for search-found pages: today drafts are only created for pages from registered page lists.
- Sending takedowns: email sending through the customer's own mail provider, turned on by default.
- Enterprise deployment: SSO login for the web app, and Postgres so more than one engine can run.
- Fully local coding assistant: so code findings never leave the network either.
- More fixes: revoking keys for more cloud and SaaS providers, beyond AWS and GitHub.
Built With
- aws-iam
- claude-code
- docker
- docker-compose
- exa
- fastapi
- github-api
- mcp
- next.js
- ollama
- python
- qwen
- react
- sqlite
- tailwindcss
- tavily
- typescript