Weople

Weople started from a simple problem: relationships rarely weaken because people stop caring. They weaken because people, commitments, context, and opportunities fall out of working attention.

I wanted something different from a CRM. A CRM manages contacts and records activity. Weople is built for relationship intelligence: helping someone notice the right person at the right moment.

The broader idea predates the WebMCP Challenge, but the challenge gave me a reason to turn it into a focused, working vertical slice. The question I wanted to answer:

What changes when an agent can reason over the same relationship context a person is using, instead of merely looking at a webpage?

That became the challenge version of Weople.

What Weople does

Weople maintains structured relationship context: people, commitments, upcoming moments, evidence, hypotheses, and relationship policies.

In the demo, the user asks ChatGPT:

What am I missing today? If something is genuinely worth my attention, add it to my Weople Today view.

Through WebMCP, ChatGPT reads the structured context and notices a connection Weople had not precomputed:

• Maya has an upcoming working session.
• I still have an unresolved promise to introduce her to someone with relevant experience.
• Maya's company announced an expansion.
• That expansion may create scaling pressure, but that's an inference, not a confirmed fact.
• Carlos recently worked through a similar scaling problem.

ChatGPT connects those pieces and creates a timely intervention directly inside the live Weople workspace.

The point isn't remembering information. It's surfacing a connection that would otherwise go unnoticed.

Why WebMCP

WebMCP is a strong fit for Weople because the important information isn't always what's visible on the screen.

Relationship intelligence depends on structured concepts such as:

• people
• commitments
• evidence
• upcoming interactions
• hypotheses
• timing
• authority and relationship policies

Without WebMCP, an agent would have to infer meaning from the rendered interface or navigate through multiple pages to reconstruct that state.

Instead, Weople exposes semantic tools that let ChatGPT work directly with the application's underlying relationship context.

The challenge version exposes six WebMCP tools:

Read

• get_today_context
• get_person_context
• get_relationship_context

Write

• create_intervention
• snooze_intervention
• update_relationship_policy

The human interface and the agent operate on the same Weople state. The agent doesn't need a separate, agent-only version of the application.

That creates a collaboration neither side has alone: Weople maintains relationship continuity, ChatGPT notices connections across that context, and the person supplies judgment and authority. The agent can surface a possibility without taking over the relationship.

Human judgment stays in the loop

I didn't want Weople to become an autonomous agent that contacts people on someone's behalf.

Noticing an opportunity and being authorized to act on it are different things.

Weople keeps human judgment explicit. The agent might notice that Maya and Carlos could benefit from an introduction. The user still decides whether that introduction is appropriate.

The same principle applies to timing. An intervention can be useful but mistimed, so the user can snooze it without rejecting the reasoning behind it.

The challenge build keeps observed facts separate from inference. Northstar announcing a new facility is stored as an observed fact. The idea that the expansion may produce operational scaling pressure is stored as a hypothesis, with its own evidence and confidence.

That lets the agent reason with uncertainty without turning it into fact.

How I built it

I kept the challenge version small and focused, rather than trying to build the entire future Weople product.

I built the first working version with ChatGPT Sites. I used it to quickly build the interaction model, synthetic relationship state, Today view, People view, person details, policies, and the WebMCP tool surface.

Once the application worked, I synced the project to GitHub for a standard source repository and version history.

I then pulled the project down to my desktop and continued refining it locally. I used the Impeccable design skill in that pass to improve the visual design, hierarchy, spacing, typography, and overall presentation, while preserving the interaction model and WebMCP behavior.

The final challenge application is deliberately lightweight. It uses deterministic synthetic data and local state rather than external email, calendar, or contact integrations. That let me focus the submission on the core question the challenge is testing: what becomes possible when a person and an agent share the same structured web application context?

Challenges

The most difficult part was not the relationship reasoning itself. It was understanding the boundary between the webpage and the browser environment executing the WebMCP tools.

During testing, the Weople page registered its WebMCP tools correctly, and ChatGPT read context successfully. But write operations failed at first because ChatGPT sometimes opened a separate browser window. That new document did not contain the document.modelContext from the already-open Weople page.

At one point the agent reasoned correctly about the Maya/Carlos opportunity and described the action it intended to take, but the actual Weople intervention was never written.

That was a useful failure because it forced me to distinguish between:

the model saying an action occurred

and

the WebMCP tool actually returning a successful result and changing application state.

Once the browser was operating on the document that actually registered the Weople tools, the full read → reason → write loop worked, and the intervention appeared immediately in the live interface.

What I learned

The biggest lesson: WebMCP gets interesting when it exposes an application's semantics instead of recreating its buttons as tools.

create_intervention is useful because it represents a meaningful Weople operation. The agent does not need to know which button to press, where a card is rendered, or how the DOM is structured.

That changed how I think about the relationship between people, agents, and software.

The web application does not have to become invisible when an agent appears. The person can continue using Weople visually while ChatGPT works through the same state semantically.

The two interfaces become different projections of the same system.

That's the experience I wanted this prototype to demonstrate.

What's next

The challenge version is a narrow vertical slice.

The larger direction for Weople is to connect relationship context from sources like calendars, email, contacts, and personal knowledge. Relationship-specific reasoning, evidence, attention, and authority stay inside Weople.

The goal is not to automate relationships.

It is to augment human attention around them.

Weople remembers. The agent notices. The human keeps judgment.

Built With

• chatgpt
• css
• github
• html
• javascript
• localstorage
• mcp
• openai
• webmcp