Twine: the dating app where AI agents have the first conversation.
Three chats, three weeks, and then you find out it was never going to work.
If your dealbreakers clash, you never match. Checked in code, both ways.
Built by Swayam Prajapati, Arya Patel, Viranshul Panchal and Yagnik Trivedi. Try it at twine-ai.vercel.app.
Consent comes first. At sign-up, you agree that your agent may handle your early chats.
When your agent doesn’t know something, it asks you instead of guessing.
Private notes on how the conversation is going, in their own words.
Under the hood: every model call goes through Nebius Token Factory to NVIDIA Nemotron, matched to the job.
Before anyone says hello, your agent checks their profile for fakes.
Your knowledge graph: everything your agent knows about you, and you decide who can see each fact.
Your private letter: every reason quotes the actual chat.
You send your own message, and their agent replies live.
One tap on “See in replay” jumps to the exact message behind each reason.
Read along live, tap “I wouldn’t say that”, or take over in one tap.
The two agents talk, each in its own person’s voice, and every message shows who wrote it.

Inspiration

Dating apps match people on preferences, not character. We kept seeing the same story: a promising match, three conversations of small talk, and then the moment one of them mentions the smoking, the move abroad or the "not sure about kids". Nobody did anything wrong. They just spent a week finding out what could have been known on day one.

We wanted that first, revealing conversation to happen without costing anyone their evening, and without anyone pretending to be someone they're not.

What it does

Twine gives everyone an AI agent that knows them, built on a personal knowledge graph.

1. Your agent learns you. Onboarding is deliberately detailed, about few minutes, because the agent can only be as good as what it knows:

Basics and photos. Every photo is checked by a Nemotron vision model before anyone sees it.
Three prompts, answered in your own words.
Lifestyle and values. For each one you give your answer, how important it is, what you'd accept in a partner, and whether it's a dealbreaker.
"How would you reply?" You answer five sample messages, plus a few taps on how you usually text, so your agent learns your voice: length, emoji, laughs, punctuation.
"Your world right now": what you're busy with, looking forward to and obsessed with lately, so your agent has real things to talk about.
Optional "Teach your agent" modules (food, travel, films, family, humour, hot takes and more) for a richer agent.

2. After a mutual like:

The agents check each other first. Each agent checks the other's public profile for fakes and inconsistencies. A two-way dealbreaker gate means clear clashes never match at all.
The two agents have the first conversation, each in its own person's voice. An agent never invents anything about its person: every claim must cite a fact from that person's knowledge graph, and code checks the citation before the message is sent. When an agent doesn't know something, it deflects naturally and asks its human in the Ask me inbox.
Two independent, private judges (one per side) list quoted evidence from the chat. Code turns that evidence into Compatible, Maybe or Not compatible.
You get a private letter. Every reason quotes the other person's own words, linked to the exact line in the chat.
- Compatible → take over in one tap, and a reveal shows exactly which lines were the agents'.
- Maybe → let them talk a bit longer.
- Not compatible → your agent closes things kindly, in your voice.

You can read every line live, pause your agent, take over at any moment, or tap "I wouldn't say that" to teach it.

How we built it

The knowledge graph: the heart of Twine

Each person's agent is only allowed to say what its knowledge graph supports, so most of our work went into building that graph well.

How it's built from onboarding:

Structured answers become facts in code, with no model call: basics, lifestyle and values, importance levels, dealbreakers. That makes them instant, predictable and exactly what you said.
Free text becomes facts with Nemotron 3 Super: prompts, stories, "Your world" answers and the modules. Every extracted fact must carry a verbatim quote from your answer, and code drops any fact whose quote doesn't match your words exactly.
Facts link to shared concepts. "Trekking", "hikes" and "mountain trips" resolve to one concept using embeddings, with a model tie-break only for close calls. That lets two agents notice shared interests without ever reading each other's data.
Facts are connected. Supports edges link facts that back each other up. Contradicts edges flag answers that disagree (say "never drinks" next to a story about beers), and you resolve those on the "This is you" page.
Your voice is a profile of its own, built from your sample replies and the way you say you text, with your real messages kept as examples for the agent to imitate.

What every fact carries:

a confidence
where it came from, with the quote
a privacy level: public, only if asked or private

Private facts are never given to the model as something it may say.

Six layers, each with clear rules about who may read it:

Layer	Who reads it
1. Public profile	Everyone
2. Dealbreaker gate	Code only (a yes/no query)
3. Self graph	Your agent
4. Voice	Your agent
5. Notes about others	Your agent and your judge
6. Decisions	You

A database-spy test proves no agent or judge ever reads the other person's graph.

It keeps learning.

Answers you give in Ask me become new facts.
After you take over a chat, your own messages, and only yours, can teach your agent more (this is a setting you can switch off).
Everything is visible and editable on This is you: a 3D map of what your agent knows, where it learned each fact, and who can see it. Facts you delete stay deleted, even after the graph is rebuilt.

Models

Every model call goes through one client to Nebius Token Factory's OpenAI-compatible API, on the cheapest tier that does the job well:

Task	Model
Agent replies, reading messages, match brief, knowledge-graph extraction, trust check, short tasks	NVIDIA Nemotron 3 Super. Reasoning is off for chat turns: 2–5 s instead of 10–40 s.
The two judges	NVIDIA Nemotron 3 Ultra, with a Super fallback, at temperature 0
Photo moderation	Nemotron VL. It describes the photo; code makes the final call.
Concept vectors	Qwen3 Embedding 8B on Token Factory

Stack and guardrails

Client: React 19, Vite and Tailwind CSS v4, with three.js for the knowledge-graph view.
Server: Express 5, Socket.IO and MongoDB Atlas, with a Mongo-backed job queue (no Redis) that resumes work after a restart.
Hosting: Render, Vercel and Atlas, all on free tiers.
Guardrails:
- every model output is validated with zod
- quotes must match word for word
- a leak check runs on every message
- a per-turn plan computed in code decides the shape of each reply (length, mood, at most one question)
- the budget is protected by a global rate limiter, daily caps, a hard USD cap and a kill switch

Testing

Real users: we tested the live app with about 10 real people (friends and team members).
Offline evaluation: a harness with 38 synthetic personas and 20 hand-labelled pairs, with metric scripts and ablations.
Scale check: a synthetic database benchmark (generated profiles, no model calls) to check how the data model would scale.

Challenges we ran into

Building a graph the agent can trust. Early on, the model "remembered" things you never said. We split the work: structured answers go straight into the graph in code, free text goes through Nemotron, and every extracted fact needs a word-for-word quote or it's dropped.
Judges that hedge. At first the judges said "unsure" in most chats, so almost every pair came out Maybe. We moved the decision into code: the model lists quoted evidence, and rules decide.
Dealbreakers nobody mentions. The conflicts that matter most rarely come up on their own. Each agent now brings up its person's most important topics through a natural bridge from whatever the two are talking about, instead of interview-style questions.
Agents misdescribing their person, e.g. "still figuring out what I'm looking for" when the real answer was long-term. Stated answers are now checked against the person's real ones in code.
Sounding human, not like a form. Early chats read like interviews. We rebuilt the turn planner around mood, message length, at most one question, and each person's real texting samples.
Free-tier reality. Cold starts, latency spikes and rate limits led us to a global limiter with retries and backoff, and resumable jobs.

Accomplishments that we're proud of

All numbers below come from our synthetic evaluation (38 hand-written personas, 20 labelled pairs), not from real users. Real-world testing so far is small: about 10 people.

A knowledge graph the user can see and correct. Every fact shows where it came from and who can see it, and the agent can't say anything the graph doesn't support.
The verdicts got better. On the 17 non-fake synthetic pairs, accuracy doubled after moving the decision into code (4/17 → 8/17), and 5 of 7 compatible pairs were found. Both planted fake profiles were caught (2/2) with no genuine profile flagged, and the one dealbreaker pair was gated (1/1). These are small samples, so we treat them as early signals, not proof.
It sounds like the persona. The style distance between each agent's messages and that persona's own example texts was 0.16 (0 means identical).
It's cheap to run: about 101k tokens per full agent-to-agent conversation in the evaluation, and about 3k to catch a fake.
Built to fit a free tier: about 88 KB of data per user, which works out to roughly 5,900 users in a free MongoDB tier. That's an estimate from a synthetic benchmark, not something we've run with real users.
Honest by design: consent at sign-up, every message labelled with who wrote it, the reveal at hand-off, honest answers to "am I talking to a bot?", and no "verified" claims anywhere.

What we learned

The agent is only as good as its graph. The time we spent making facts exact, sourced and private paid off more than any prompt tweak.
LLMs describe better than they decide. Letting the model gather evidence and letting code decide made the system more accurate and much easier to explain.
What matters most is what nobody asks about. A good agent has to bring the important topics up naturally, before the chat ends.
Be honest about the science. Research on predicting compatibility before two people meet is sobering, so Twine doesn't promise love. It filters clear mismatches and fakes, and saves you the first few conversations.