Arachne

A self-audit of your digital footprint, woven by Arachne and her spiders.

Comment

Inspiration

01 // meet arachne: The weaver from Greek myth, drawn live in ASCII. She runs your audit.

  • Every account, post and sign-up you leave online is a thread. Together they weave a web anyone can read.
  • The individual threads can look harmless: a 2014 forum account, a reused handle, an email in a 2021 breach, a résumé PDF with your phone number, an archived "About" page. The danger is when a bad actor starts putting the puzzle pieces together.
  • People who want to clean up can't, because they can't see the whole web. The tools that can see it (people-search sites, OSINT kits) are built to look up other people. In the age of AI, it is becoming increasingly easy to scour the internet and find personal information about people who are powerless to know how exposed they are.
  • We wanted the opposite: a tool that investigates exactly one person, you, shows you the evidence, and tells you how to unpick each thread.
  • The name: in Greek myth, Arachne out-wove the goddess Athena, who turned her into a spider, the first weaver of webs. Now she reads your web and shows you how to unpick it.

What it does

Arachne is a privacy self-audit web app at arachnes.net.

1. Prove it's you

02 // prove it’s you: A code from your own inbox, then what’s yours, then your consent.

  • Step 1, "Who comes to the weaver?": give your email. Step 2: enter the 6-digit one-time code sent to that inbox (no passwords). The code proves the email is yours.
  • Step 3, "What else should she know?": type anything else that's yours in one box (usernames, full name, phones, websites, your city, school or work), and start a line with not me: for a look-alike page.

2. Arachne's case file

  • Arachne keeps one case file: everything known about you so far. Confirmed identifiers, leads to chase, findings by site, coverage gaps, budget and time left, and what each earlier lead turned up.
  • Every spider takes its orders from her and writes what it finds back into the file. It has a version number that bumps on every change, and each line can start new work.

3. Round 0: the sweep

  • First, a team of spiders hits 40+ public sources at once (up to 8 at a time, with a fair queue per source): breaches for your exact email (XposedOrNot), your username across hundreds of sites (Maigret, user-scanner), GitHub, Gravatar, Keybase, Mastodon, Reddit and Reddit archives, web search and public documents (Bright Data SERP), Wayback Machine snapshots, your domain's RDAP/WHOIS/DNS/certificate logs, and available public records.
  • Likely username variants (top 5) are checked too, as candidates only.

4. The pivot

05 // the pivot: One new handle, confirmed by code, opens a new branch of the search.

  • Example: a spider brings back your GitHub profile showing the handle alexd.codes next to your email.
  • The reader quotes the exact text as evidence. Code rules (not AI) check it: a username match alone is only "possible", but the same page showing your verified email makes it confirmed.
  • The new handle goes into the case file, a new sweep on it starts right away (up to 12 pivots, 3 hops deep), and Arachne can send a new team after it in her next round.

5. Rounds of teams

04 // how it works: Plan, check, search, read, rule: every round, back into her case file.

  • Every round, Arachne reads the case file and decides what to chase next, writing leads like "find hackathon pages that name you with your handle" or "check archived versions of your domain".
  • Each lead passes 7 code checks before anything runs: subject, references, tools, third party, novelty, budget and limits. Anything about someone else (a relative, a coworker, another name) is refused.
  • Admitted leads become teams: in the demo profile, up to 10 teams per round with up to 4 worker spiders each, every one using a different search strategy and a few narrow tools (search the public web, fetch a page, check a username, read an archive snapshot, check a people-search site).
  • Results go back through the reader and rules into the case file, and the next round begins. Runs stop on time, budget, max rounds, or when new leads stop producing new findings.

6. The investigation, live

03 // the investigation: Every agent is a spider. Each finding is caught in the web as it lands.

  • You watch it happen: Arachne hangs over her web and every agent is a spider on it, animated by the tool it's using. Each finding is caught in the web as it lands, tagged with its risk and source.
  • A status card says in plain words what she's doing now and what's next (mapping, following leads, checking, writing up), with live counts of findings, accounts and breaches.

7. Arachne's verdict

06 // arachne’s verdict: A grade, a plain-English summary, and where to start cutting threads.

  • Arachne responds with her verdict: a grade and score, the worst thread, and where to start cutting.
  • Below it, "the heap": every finding as a thread, by risk. Point at one and she explains it: what it is, where it was found, how sure she is, and step-by-step how to cut it.
  • The report is written while slow sources are still collecting.

8. You decide what's yours

07 // you decide: Not proven yet? You claim it or cut it loose. Each thread shows how to cut it.

  • Possible matches appear under "Is this you?" Cut it loose ("not me") and everything that depended on it is withdrawn.
  • Same handle, different name on the page? Arachne flags it as probably not you and sets it aside, still yours to accept.

9. Safety

08 // safety: Built to look at one person: the one who can open that inbox.

  • Sign-in needs a one-time code from your own inbox. If someone types another person's email, the code goes to that person's inbox. No code, no sign-in.
  • 7 code checks refuse any lead about another person (third party): a relative, a coworker, another name.
  • The reader drops claims about anyone else.
  • Pages you mark "not me" are excluded for the rest of the audit.
  • Rate limits per IP and address.
  • Delete my data removes the audit, everything it collected and its recording from the engine.

How we built it

  • Arachne is the agent that plans every round. She reads a compact case file built from the identity graph in the database and returns new leads as strict JSON. In production she runs on GPT-6 Astra (OpenAI), falling back to Claude Sonnet 5.5 if it refuses, errors or is unavailable.
  • Her spiders (workers): Claude Haiku 5.5, small bounded tool loops (6 model turns / 6 tool calls each in the demo profile). Each sees only its own task and gets 2–4 narrow tools, never free internet access.
  • Reader: Claude Sonnet 5.5 with no network access. It reads page text (title, meta, JSON-LD, body, not raw HTML), must quote evidence verbatim, and drops claims about anyone but the subject.
  • Match check: Sonnet 5.5 reads each still-possible account page and reports the name it shows, with a quote; code compares it with your names to flag "probably not you". Only the verdict is kept.
  • Report writer: Sonnet 5.5 writes the narrative, and every statement is checked in code against the findings. Grade and score are computed in code.
  • Gateway: every collector call and worker tool call goes through one enforcement point for scope, destination policy, request/byte/cost limits, and evidence storage.
  • Budget ledger: four protected buckets (sweep, planning, workers, reader), reservations in integer micro-USD, a global free-scan pool, and per-provider concurrency slots so many agents queue for Bright Data instead of flooding it.
  • Engine: Python 3.12, FastAPI, Pydantic, SQLAlchemy (async) on SQLite (WAL), one process on Railway with a volume; durable via checkpoints, so an unfinished audit resumes after a restart. Live progress streams to the browser over server-sent events.
  • Collectors: 40+ sources built on Bright Data (SERP + Web Unlocker), XposedOrNot, Maigret, user-scanner, the Wayback Machine, crt.sh, RDAP/WHOIS/DNS, CourtListener, SEC EDGAR, OpenCorporates and more; pdfplumber, Tesseract OCR and ExifTool for documents and image metadata.
  • Sign-in: passwordless email codes sent through Resend.
  • Record and replay: every live run is recorded and can be replayed through the real engine in ~45 s with no network calls and $0 cost.
  • Website: a static page (vanilla JS + canvas, no build step) on Netlify. The scene is drawn live in ASCII.
  • Contracts: JSON Schema and TypeScript types generated from the engine's Pydantic models, a plain ES module client, and fictional fixtures (a 168-event example audit) so the front end could be built offline.
  • Process: spec + ADRs + glossary first, then one PR per layer (sweep, workers, reader, coordinator), merges gated on hundreds of pytest tests and Ruff.

Challenges we ran into

  • Keeping the tool aimed only at you. A free, public OSINT tool is dangerous by default. We had to enforce "subject only" in code at every layer: sign-in by a code from your own inbox, 7 admission checks on every lead (third parties refused), every worker query must contain one of your own identifiers, the reader drops claims about anyone else, and "not me" pages are excluded.
  • Models must not decide identity. Early on, name matches and "looks like you" guesses crept in. We moved all attribution into explicit code rules (R1–R15) and made the reader quote evidence verbatim; name matches never confirm.
  • False positives. Maigret's username hits and same-handle-different-person pages flooded results. We added the reader on real page text, the "probably not you" match check, and owner review that withdraws everything built on a rejected match.
  • Making the swarm actually search. Workers at first planned more than they searched; we reworked tools so they pivot on newly found handles and start early while slow sources are still collecting.
  • Rate limits and cost. Dozens of agents hitting Bright Data at once; solved with per-provider slots, per-source concurrency, a fair round-robin queue, queue time that doesn't count against timeouts, and a hard per-run ceiling.
  • Planning model limits. The planner's output kept hitting the output-token limit mid-plan; we had to fix that and add a fallback model.
  • Readable ASCII art. Text over a moving ASCII web is hard to read; the canvas clears soft dark patches around every line of UI text.

Accomplishments that we're proud of

  • A real multi-agent system where the agents are visible: every spider on screen is a real task with a parent, a role and a status.
  • A strict separation: models read and plan, code decides what's yours, and you have the final say.
  • Site design: we're happy with how the site turned out.

What we learned

  • The hardest part of agentic OSINT isn't finding things, it's knowing whose they are. Evidence quotes + deterministic rules beat model judgment.
  • Give agents narrow tools and a shared, versioned case file instead of free internet access and long chat histories.
  • Budgets, queues and timeouts are product features when dozens of agents share paid APIs.
  • Privacy tools have to be designed against their own misuse from day one.

Built With

Share this project:

Updates

Submission history