What Are Pods?
Pods are peer-learning virtual circles—typically 7 to 30 days—where participants engage through posts, comments, hearts, and other interactions. Over time, ServiceSpace has run many pods: interfaith challenges, compassion practices, Gandhi study circles, and more. Some people participate in multiple pods across months or years, creating a rich web of relationships and shared learning.
The Opportunity
After a pod ends, we often want to create smaller "Metta Circles" of 4–6 people for continued connection. But how do we form these circles wisely? Currently, it's manual—facilitators do their best based on memory and intuition.
What if we could form circles based on resonance (deep mutual engagement), edge (respectful differing perspectives), serendipity (surprising cross-pod connections), or shared history (alumni of many pods together)? This requires understanding relationships at a scale beyond human memory.
Why a Graph Database?
Traditional databases store data in tables with rows and columns. They're excellent for many things, but relationships between entities require complex "joins" that become slow and unwieldy. Graph databases store relationships as first-class citizens. Instead of asking "find all comments where user_id = 123 and post_author_id = 456," you simply traverse: Person → COMMENTED_ON → Post ← AUTHORED ← Person.
This makes questions like "who are the bridge people connecting the Gandhi pod community to the Rumi pod community?" not just possible, but fast.
Why Agentic AI?
Building and querying a graph database requires technical skill—writing Cypher queries, understanding graph traversal, interpreting results. Agentic AI acts as an intelligent intermediary: for building, agents can analyze our existing database and execute the migration; for circle formation, agents can translate natural requests into graph queries and balanced groupings; and for exploration, facilitators can ask questions in plain English and get meaningful answers.
From a Network of Interactions to a Layer of Meaning
The first version of Circle Agent reasoned mostly over the interaction graph—who commented on whom, who hearted what, which activity trails crossed. That reveals a great deal, but it can only see connection where people have visibly engaged.
Version 2 adds a semantic understanding layer on top of that graph. Rather than looking only at who interacted with whom, the agent now reads the actual content of people's reflections, builds an understanding of each person from it, and uses that to find resonance across the whole community—including between people, or posts, that may never have directly met.
How a reflection is read
Each post is analyzed for more than keywords. The agent looks for two things: the engagement archetype—how a person tends to show up, the shape of their presence—and the core concepts—the themes they keep returning to.
How a person comes into focus
Those per-post signals roll up into a person-level semantic profile: an archetype vector, a set of top concepts, and a short AI-written blurb that captures, in plain language, how this person reflects and what they circle around.
Archetype Vector
A read on how someone tends to show up—the texture of their presence across many reflections.
Top Concepts
The themes a person returns to again and again, drawn from the meaning of what they write—not just shared words.
Written Blurb
A short, human-readable portrait, so a profile can be understood at a glance—not only computed.
What this lets the agent see
With meaning in hand, two new kinds of connection become visible:
Kindred Posts
Reflections that share meaning even when the words are completely different—resonance the old keyword and link view would miss.
Kindred People
People who are deeply aligned in how and what they reflect—even if they've never directly engaged.
Not a black box
Because the profiles, concepts, and relationships are stored explicitly, the semantic layer is human-auditable. Through an admin workflow, a facilitator can inspect the profiles, the relationships between them, and the graph the agent reasons over—so matching driven by meaning stays as reviewable as matching driven by activity. The principle holds: the agent proposes, a human decides.
Where v2 is today
The semantic profiling is primarily driven by posts. Comments now live in the graph as structure and context, but the meaning-extraction layer is currently centered on post analysis. We'd rather say that plainly than imply the system reads everything, everywhere.
Five Modes of Weaving
The Circle Agent supports multiple approaches to forming Metta Circles. Facilitators can request single modes or combinations.
Resonance
High mutual engagement, similar themes. People who deeply connected with each other's reflections.
Edge
Respectful disagreement, diverse perspectives. Engagement across difference.
Serendipity
Surprising commonalities across pods that no one noticed. Non-obvious connections.
Alumni
Shared pod history—people who've done 5+ pods together but haven't reconnected.
Bridge
People who connect otherwise separate pod communities. Cross-cluster connectors.
Architecture
┌─────────────────────────────────────────────────────────────────────┐ │ C I R C L E A G E N T │ ├─────────────────────────────────────────────────────────────────────┤ │ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │ Pod App │────▶│ AWS SQS │────▶│ Lambda │ │ │ │ (Frontend) │ │ (Queue) │ │ (Processor) │ │ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ │ │ │ ▼ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │ Agno │────▶│ MCP Server │────▶│ Neo4j │ │ │ │ (Agents) │ │ (Tools) │ │ (Graph DB) │ │ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ │ ▲ │ │ │ ┌─────────────┐ │ │ │ └─────────────▶│ Claude API │───────────┘ │ │ │ (Reasoning)│ │ │ └─────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────┘
| Component | Purpose |
|---|---|
| Neo4j | Self-hosted graph database storing people, pods, posts, their relationships, and the computed semantic profiles (archetypes, concepts, blurbs) |
| AWS SQS | Message queue that buffers interaction events from the pod application |
| Lambda | Serverless functions that process events and update the graph |
| Agno | Open-source framework for building AI agents with tools and workflows |
| MCP Server | Exposes graph operations as tools that agents can invoke |
| Claude API | Provides reasoning capabilities for agents |
Six Phases
Infrastructure Setup
Get the foundational systems running.
- 1.1 Deploy EC2 instance (t3.large or r6g.medium recommended for Neo4j's memory needs)
- 1.2 Install and configure Neo4j Community Edition (self-hosted)
- 1.3 Set up security groups, SSL, and backup routines
- 1.4 Install Agno framework for agent orchestration
- 1.5 Deploy MCP server with initial toolset
- 1.6 Configure AWS SQS queue for event ingestion
Ontology Design
Define how pod data becomes a graph—what are the nodes, what are the relationships?
- 2.1 Agent analyzes existing MySQL schema (tables, columns, foreign keys) Schema Analyzer Agent
- 2.2 Agent examines common query patterns in existing PHP code Agent-Assisted
- 2.3 Agent proposes initial ontology: node types, relationship types, properties Agent-Assisted
- 2.4 Human review with pod facilitators—what relationships matter for circle formation?
- 2.5 Refine ontology based on feedback
- 2.6 Document final ontology with examples
Key principle: Columns typically become node properties; foreign key joins typically become relationships. But the agent helps surface non-obvious patterns and the humans ensure the model reflects pod wisdom, not just database structure.
Data Migration
Populate the graph database with historical pod data.
- 3.1 Agent generates Cypher CREATE statements based on approved ontology Migration Agent
- 3.2 Agent executes migration in batches, starting with a pilot pod Agent-Assisted
- 3.3 Agent validates record counts and relationship integrity Agent-Assisted
- 3.4 Agent computes derived relationships (resonance scores, engagement patterns) Agent-Assisted
- 3.5 Agent surfaces anomalies or edge cases for human review Agent-Assisted
- 3.6 Expand to full historical migration after pilot validation
Real-Time Event Pipeline
Keep the graph current as new interactions happen in pods.
- 4.1 Modify pod frontend to emit events (post created, comment added, heart given) to SQS
- 4.2 Build Lambda function to process events and execute Cypher updates
- 4.3 Implement periodic job to recompute derived relationships (resonance, etc.)
- 4.4 Add monitoring and alerting for pipeline health
- 4.5 Test with live pod, validate graph stays in sync
Circle Agent Core
Build the intelligent agent that forms Metta Circles.
- 5.1 Define MCP tools for graph operations (query, compute resonance, propose circle)
- 5.2 Build Circle Agent with formation modes: resonance, edge, serendipity, alumni, bridge
- 5.3 Implement scoring algorithms for each mode
- 5.4 Create human-in-the-loop workflow: agent proposes, facilitator approves or adjusts
- 5.5 Test with facilitators using historical data
- 5.6 Refine based on feedback
Query Interface
Enable exploration of the graph by non-technical facilitators.
- 6.1 Build natural language query interface using Claude
- 6.2 Create library of common questions with example responses
- 6.3 Add direct Cypher access for technical team (secured)
- 6.4 Build simple dashboard for graph health and statistics
Example queries: "Who are the bridge people between the Gandhi pod and the Rumi pod?" · "Show me people who engaged deeply but have never been in a circle together" · "What themes resonated most in last month's pods?"
What Makes This "Agentic"?
Traditional automation follows rigid rules. Agentic AI brings judgment.
Understanding intent. "Mix resonance and edge" requires interpreting what balance means, not just running two queries.
Handling ambiguity. When there aren't enough people for perfect circles, the agent makes tradeoffs and explains them.
Learning patterns. Over time, agents can notice what circle compositions lead to sustained engagement.
Natural interaction. Facilitators describe what they want in human terms, not query syntax.
The agent has tools (graph queries, scoring functions) but decides how to use them based on the request. It proposes; humans decide.
For Refinement
Version 2 settled the first question this doc once held open: what signals indicate resonance is now read as semantic alignment—overlap in archetype and concept—rather than hearts and reply-counts alone. A few questions remain genuinely open.
- 01 How do we identify "edge" respectfully? Difference is valuable, but we want constructive contrast, not conflict—and meaning-level signals make this easier to ask, not yet easy to answer.
- 02 How much history to include? All pods ever? A recent window? Profiles get richer with more reflections, but older signals may no longer describe who someone is now.
- 03 Retention & privacy. The graph now holds posts alongside the profiles computed from them. How long do we keep the underlying reflections, and what can be discarded once a profile exists?
- 04 Circle formation cadence. On-demand requests? Periodic suggestions? Both?
Circle Agent transforms scattered pod interaction data into a living map of community relationships. By combining graph technology with agentic AI, we can form Metta Circles based on genuine patterns of connection—not guesswork.
Technology serves the deeper intention:
Agents propose. Humans decide. Community deepens.