Doubles · Agentic coordination · Starting with padel
Turn individual intent into complete groups.
Padel can’t be played until four people agree on one court and one time. Doubles is building the coordination layer that gets them there, starting with padel in Delhi NCR.
Early stage. Padel games in Delhi NCR are arranged by hand over WhatsApp today. The agentic coordination layer is in development.
- The problem
- A standard padel game needs exactly four players, on one court, at one time.
- Why padel first
- The four-player rule is structural, so coordination is never optional.
- Claude’s job
- Read messy intent, reason about soft constraints, choose which tool to request.
- Deterministic software’s job
- Decide what is true: availability, capacity, bookings and payments.
01The coordination problem
Booking software starts after the hard part is over.
Court-booking tools assume four people already agree on what they want. They handle the transaction. They don’t handle what comes before it: finding the other three, and fitting a group’s schedules, locations and skill levels into one slot.
What has to be true before one game can happen:
- Four players, no more and no fewer.
- A time every one of them can make.
- A venue every one of them will travel to.
- Skill levels close enough for the game to be worth playing.
- A court that is actually free.
- No cancellation afterwards, or a replacement who fits.
Each condition is easy alone. Together they are a constraint problem over people who answer on their own schedules, in their own words.
02Player intent
People don’t fill in forms. They say what they can do.
Player request: “I can play Saturday evening around Gurgaon. I’m somewhere between beginner and intermediate and don’t mind new people.”
{
"activity": "padel",
"preferred_areas": [
"Gurgaon"
],
"availability": [
{
"day": "saturday",
"daypart": "evening",
"earliest": null,
"latest": null,
"quote": "Saturday evening"
}
],
"skill_band": "beginner_intermediate",
"party_size": 1,
"social_flexibility": "open_to_new_people",
"hard_constraints": [],
"soft_preferences": [
"Somewhere around Gurgaon rather than one exact venue"
],
"ambiguities": [
"\"Evening\" has no start or end time.",
"\"Around Gurgaon\" does not say how far the player will travel."
]
}Claude’s job is to turn the sentence into the object. Notice what the object keeps: the vague word “evening” is recorded as an ambiguity instead of being guessed into a time, and hard constraints are stored apart from soft preferences. How Claude is used.
03The system
One loop, two kinds of authority.
- Model reasoning (probabilistic)
- Deterministic state (authoritative)
- 01
Intent
Today (Operating now, by hand or in production.)Model reasoning
Model reasoning: Reads the player’s own words, however they are phrased: “Saturday after 6, somewhere around Gurgaon, intermediate, fine with new people.”
Deterministic state
Deterministic state: Assigns a request ID and attaches it to a player ID. Keeps free text only as long as needed. Today this intake is a WhatsApp conversation handled by a person.
- 02
Understand
Prototype (Built in the repository. Not used with real players.)Model reasoning
Model reasoning: Extracts time windows, areas, skill band, flexibility and party size. Separates hard constraints from soft preferences. Lists what is ambiguous.
Deterministic state
Deterministic state: Validates the extraction against a strict schema. Discards anything malformed. Resolves vague words (such as “evening”) with a written policy, not model whim.
- 03
Coordinate
Research (A question we are working on. No result is claimed.)Model reasoning
Model reasoning: Proposes candidate groups across the player pool. Reasons about incomplete groups, uncertain skill, past pairings and soft preferences. Decides whether to ask a question.
Deterministic state
Deterministic state: Supplies the pool and the facts. Runs rule-based search wherever the problem can be enumerated. Records every proposal as data.
- 04
Validate
Prototype (Built in the repository. Not used with real players.)Model reasoning
Model reasoning: Not involved. A proposal is data, not authority.
Deterministic state
Deterministic state: Checks exactly four players, every availability window, venue area, skill spread, court inventory, booking state and payment state. Any failed check rejects the proposal.
- 05
Act
Planned (Intended. Not built.)Model reasoning
Model reasoning: Requests a scoped tool by name and drafts the message a player will read.
Deterministic state
Deterministic state: Executes only validated requests through tools with narrow permissions. Uses idempotency keys. Routes irreversible or uncertain actions to a human.
- 06
Recover
Research (A question we are working on. No result is claimed.)Model reasoning
Model reasoning: When a player cancels or a tool fails, decides what to try: replace, re-time, ask, or stop.
Deterministic state
Deterministic state: Re-runs validation on whatever is proposed. Keeps the audit trail. Escalates to a human when confidence or authority runs out.
The full architecture, with failure modes, is on Technology. A deterministic worked example, with rejected proposals, is at the worked example.
04Why padel
We start with padel because the constraint is unusually clean.
Padel is played as doubles. A standard game needs four players, so someone always has to assemble the four. That makes coordination a requirement of the sport rather than a feature added on top. It also makes success easy to define and measure: a game either has four validated players on a free court, or it doesn’t.
Padel is the starting environment, not the boundary. The same shape (a fixed number of people, one place, one time) appears in other racquet sports, pickup sports, classes and small-group activities. Doubles does not operate in any of them today. More on the wedge.
05Why agents
Rules can enforce a constraint. They can’t read a sentence.
Real availability arrives like this:
- “Saturday evening, or Sunday morning if the same group is playing.” A conditional.
- “Can do 7-ish, but I have to leave by 8:30.” A soft start and a hard end.
- “Gurgaon is fine, I’d rather not cross the city.” A preference with no boundary.
- “Beginner, but I play tennis.” A skill level that needs interpretation.
A fixed form can’t hold these. A model can read them. But a model should not be the thing that decides whether a court is free, or whether payment has cleared. So the work is divided.
06Claude and software
Where Claude sits, and where it doesn’t.
Claude reasons. Deterministic systems decide what is true.
A model may propose a group. It cannot override an unavailable court.
Claude: model reasoning
- Natural-language intent understanding
- Separating hard constraints from soft preferences
- Reasoning across incomplete groups and uncertain skill
- Choosing which scoped tool to request
- Handling cancellations and unusual exceptions
- Drafting context-aware messages to players
Software: deterministic state
- Player identity and authoritative state
- Court capacity and venue inventory
- Final availability and scheduling conflicts
- Booking state and payment state
- Exactly-four validation before any action
- Irreversible actions and audit logging
07Research
How we will know whether it works.
Coordination quality can be measured. These are the dimensions the evaluation is being designed around. They are definitions, not results; no scores have been produced.
- Hard-constraint violation rate
- Group completion rate
- Human clarification rate
- Cancellation recovery rate
- Manual intervention rate
- Matching stability
- Preference satisfaction
- Time to complete coordination
- Tool-call failure recovery
08Current status
What exists, stated plainly.
| Layer | Status | State |
|---|---|---|
| Arranging padel games in Delhi NCR | Today (Operating now, by hand or in production.) | Done by hand over WhatsApp. A person does the coordination. |
| Intent extraction with Claude | Prototype (Built in the repository. Not used with real players.) | Server-side boundary implemented and unit-tested on fixtures. Not used with real players. |
| Hard-constraint validator | Prototype (Built in the repository. Not used with real players.) | Implemented on fixtures, with a worked example. |
| Group proposals, recovery, evaluation | Research (A question we are working on. No result is claimed.) | Open questions. No results. |
| Booking, messaging and payment tools | Planned (Intended. Not built.) | Not built. |
Verified facts and their sources are listed on Evidence.
09Go deeper
Where to read next.
- ProductWhat a player experiences, and what is built, manual or planned.
- TechnologyThe architecture: intent, reasoning, validation, tools, state, failure modes.
- ClaudeWhere Claude sits in the system, where it does not, and why.
- ResearchThe research question, evaluation design and failure taxonomy.
- EvidenceVerified facts, in-development work and research directions, separated.
- CompanyWho is building Doubles and where.