Inspiration
Everyone on our team has a parent or grandparent who has been targeted by a phone scam. Scam calling works as a numbers game: dial enough people and someone picks up, believes the story, and pays.
We wanted to disrupt that before another real person is on the line. What if the number a scammer dials belongs to a fictional identity with no personal information and no assets to expose, and every call becomes a record of how that number leaked? What if thousands of those numbers were added to the phishing sites and call lists scammers pull from? Every victim would be a needle in a haystack.
That idea led to Phoney: fictional profiles planted by the thousand where scammers collect contact information, each connected to an AI voice persona that answers, holds the conversation, and preserves it for review.
What it does
Phoney connects dedicated phone numbers to fictional AI personas with distinct voices, backgrounds, and conversational styles. These personas answer incoming calls, ask relevant follow-up questions, and sustain the conversation without exposing a real person's information.
Upstream of the call, browser agents discover callback forms and submit fictional profiles to them, increasing the share of fake AI personas in a caller's pool. Each profile is unique to one form, so when a caller later says that name on the phone, the system can associate the call with the form that leaked it.
Every call is preserved with a transcript and an evidence status. A live observation during the call is only a possible association. A verified association requires the signed post-call transcript to show the caller said the planted name before our persona did.
Our hackathon demonstration runs this workflow against an owned test website, fictional profiles, and volunteer callers. It does not contact real websites or real people.
How we built it
Phoney has three layers: browser automation, shared state and coordination, and AI phone conversations.
Shared state and coordination. SpacetimeDB is the system of record and the coordinator. Two Playwright worker processes, Mara and Otis, each connect under their own database identity and subscribe to identity-checked views over private tables. The rules live in reducers: worker identity binding, site deduplication, job leases, and the requirement that an accepted form receipt exists before the database schedules the other agent's submission. The delays are not in our code. A scheduled reducer inside the module releases each job after a randomized interval and recovers expired leases. Node renders pages and drives browsers. Shared state never passes through it.
Browser automation. An agent inspects the callback form on our fictional banking site, submits a profile, and verifies the receipt before the form instructions are shared. The other agent receives those instructions through its subscription and submits after the database releases its job. Model mode uses a text model to read page content and form labels. Rehearsal mode uses fixed rules so the run is repeatable. Both perform real browser submissions. Both workers run on one host.
Voice. Each persona has a voice-capable Photon 2.0 number. Inbound calls route over SIP with TLS directly into that persona's ElevenLabs conversational agent. Mid-call, an authenticated observation tool can record a provisional match. After the call, the signed transcript webhook reaches a Cloudflare Worker, which verifies the signature, checks the caller's words, and submits the result through a reducer. A volunteer places each test call. Submitting a form never initiates a call.
Challenges we ran into
We found it challenging to maintain natural, consistent conversations. Repeated misunderstandings or generic responses make a persona unconvincing quickly. We focused on distinct conversational styles, relevant follow-up questions, and stable fictional details, and we made the persona never volunteer the planted name.
Another challenge was reliably coordinating browser workers. Identifying a form does not mean a submission succeeded. The first agent must verify its receipt before the other reuses its instructions, and shared state must distinguish scheduled, claimed, and completed work. Moving those checks into reducers made the workers simpler, because a refused transaction is a clearer signal than a prompt instruction.
Accomplishments that we're proud of
We were able to build a system of two independent agents coordinating entirely through database rules, with no coordinator process, and database timers doing the scheduling.
We got a real phone call working on a Photon number, answered by an ElevenLabs persona, whose transcript is verified by signature and associated with the specific form that leaked the number.
We were able to build a secure, controlled environment (using a domain one of our teammates already had) that let us test the concept without involving real victims or submitting anything to third-party websites.
What we learned
A good voice persona is more than a detailed prompt and requires specific voice selection, response timing, consistency, and relevant follow-up questions.
We also learned that coordinated automation at scale depends on verifiable progress from each individual worker. Each worker in a system needs a shared, authoritative record of what was discovered, attempted, and confirmed. And the rules about who may do what next belong in the database, not in each worker.
What's next for Phoney
Our immediate next goal is to grow the agent fleet. Every worker, on any machine, is just another identity subscribing to the same module, so the next step is more personas, more forms, and a claim-based site frontier instead of two fixed agents.
We also want to accommodate to other scam attack vectors. Certain scams continue the conversation over text. So after a call, we would like to expand our system to use the same Photon number and message the operator with follow up information on the scam.
We want to implement transcript analysis that identifies recurring scripts and payment requests across calls and links each finding to its evidence.
How we used SpacetimeDB
The module is a SpacetimeDB 2.14 TypeScript module published to Maincloud. Raw tables are private. Each worker reads through backend_* views that check the caller's identity, so a worker's subscription only ever contains rows it is allowed to see. Writes go through reducers. The dispatch reducer runs the state machine in logic.ts: it binds a worker's first-seen identity to its agent slot, restricts configure, start, stop, and reset to the publishing identity, deduplicates discovered sites, and treats a job as claimable only after its due time and only while no other lease is live. A submission completes only with a receipt whose details match the worker's own profile, and the second agent's job is created only after the first agent's receipt has been accepted.
Timing is handled by the database. When a receipt is accepted, the reducer inserts a row into a schedule table with a randomized ScheduleAt time. The release_job_timer scheduled reducer fires on that row, moves the job to pending, and reclaims any lease that has expired. If every worker process is killed, the schedule table still fires and the jobs are waiting when a worker reconnects.
Clients are the two Playwright workers, the Node bridge that holds the owner identity, and a Cloudflare Worker that submits verified call events. Each connects with the TypeScript SDK, subscribes, and calls reducers. Files: spacetimedb/src/index.ts, spacetimedb/src/logic.ts, docs/SPACETIME.md.
How we used Photon
Each persona has a voice-capable number on the Photon 2.0 beta. A voice profile on that number routes inbound calls over SIP with TLS and auto media encryption to sip.rtc.elevenlabs.io, where the persona's ElevenLabs conversational agent answers. The route is configured through the Photon API by scripts/configure-photon.ts, which only edits existing lines, uses idempotency keys, and never purchases numbers or places calls. Calls are inbound only.
During a call, the ElevenLabs agent can invoke a bearer-authenticated server tool that reports what the caller said. That produces a provisional observation. After the call, ElevenLabs posts a signed post-call transcription webhook to cloud/worker.ts, which verifies the HMAC signature, parses the transcript, and submits the result through a reducer. The reducer keeps an association between the call and a form only when the transcript shows the caller said the planted name before the persona did and that name maps to exactly one known form. A late provisional write cannot overwrite a verified result.
The personas are written to be reactive. They answer, ask who is calling, confirm their own name only when asked, and wait for the caller to introduce the topic. They never introduce an offer and never say the planted name first. Files: scripts/configure-photon.ts, scripts/configure-elevenlabs.ts, cloud/worker.ts, server/calls.ts.
How this relates to consumer protection
Phone scams target older adults disproportionately, and the calls work from purchased contact lists. Phoney puts fictional identities into those lists. Each identity is unique to one form, so a call to its number carries information about where the list came from. Over many calls that becomes a record of active scripts tied to their lead sources. The demonstration runs against an owned test site with fictional profiles and volunteer callers, two workers on one host, and does not integrate with any carrier or measure prevented fraud.
Built With
- anti-phishing
- elevenlabs
- phone-scams
- photon
- qwen
- spacetimedb
- t-mobile
- vultr