Rally

Inspiration

Modern teams are drowning in tools but starving for alignment. Tasks live in one app, calendars in another, decisions get lost in chat, and critical context disappears as conversations scroll by. We kept running into the same pain while building with friends: the work wasn’t hard — staying synced was.

So we asked a simple question: what if every team had a shared operational brain?

Not another dashboard. Not another “process.” A brain that lives where teams already operate: messages. The same “text an AI and it just does it” experience (à la Poke), but tuned for how dev teams actually work: calendar tetris, shared knowledge, lists — and the piece that felt missing — code. If you can text “add a blue CTA to the landing page,” why can’t you get a real PR back?

That became Rally: one MCP server that plugs into Poke and turns group chat into alignment + execution.

What it does

Rally is an AI-powered operational brain for teams — built for messaging-first startups.

Teams message Rally through iMessage (via Poke) to:

Schedule meetings + find team availability
Store and retrieve knowledge (decisions, brand, runbooks)
Manage shared lists (shopping, tasks, launch checklists)
Ship code from a text (“add a blue button” → PR link)

Instead of forcing new workflows, Rally turns messy team conversation into structured, searchable team state — so context doesn’t die in the scroll.

Rally workflow

1) Messaging → structured team state

When teammates text Rally in their own 1:1 Poke threads, Rally writes into a team-scoped database:

Calendar events (team + personal opt-in visibility)
Decisions / notes / runbooks
Lists and recurring ops

Rally normalizes messages into structured objects (events, decisions, tasks) so they’re queryable and consistent even when people ask things differently.

2) Semantic “team memory” retrieval

When someone asks “what did we decide about onboarding?” or “what’s the launch checklist?”, Rally:

generates embeddings for new notes
stores them in the team index
retrieves relevant context by meaning (not keywords)
responds conversationally with the source context

So the brain gets smarter over time, without anyone maintaining documentation manually.

3) Text-to-PR pipeline (the “ship it” moment)

When someone requests a code change (“make the CTA blue”, “add rate limiting”, “fix the navbar on mobile”), Rally:

pulls repo context (registered once)
clones the repo into a sandbox
has an agent propose a plan + file-level edits
runs checks/tests
commits, pushes a branch, and opens a PR
returns the PR link right back into iMessage

One message → a real PR, with verification.

Rally vs Poke group chat (why we exist)

Poke group chats are intentionally limited for privacy: no one’s personal calendars, email, etc. In group chat, Poke is mostly web/search/images/reminders.

Rally is the opt-in “shared layer.”
If your team wants shared context — shared calendar, shared knowledge, shared lists, and text-to-PR — you add Rally. Everything is team-scoped by default, and personal visibility is explicit opt-in.

So:

Poke 1:1 = your personal assistant
Poke group chat = lightweight coordination + chaos
Poke + Rally = a real team operating system in messages

How we built it

MCP Server (Python / FastMCP): exposes tools for calendar, knowledge, lists, and code workflows
Team state + API: persistent DB + REST endpoints for a lightweight dashboard
Semantic memory: embeddings + search index for “decision retrieval” and runbook recall
Text-to-PR: GitHub repo registration → sandbox clone → agent edits → checks → PR via GitHub API
Poke integration: Rally appears as a single MCP integration (“Rally”) so Poke can reliably discover and call tools

Challenges we ran into

Multi-user async consistency: two people can ask for updates in different threads at different times — keeping shared state deterministic (especially calendar logic) was harder than it looked.
Tool discoverability + naming: MCP clients are picky; small naming mismatches made tools appear but not callable. We unified tool naming and reduced integration ambiguity so Poke consistently executed the right functions.

What we learned

Teams don’t struggle from a lack of tools — they struggle from fragmented context. The fastest way to ship isn’t more dashboards; it’s reducing coordination overhead by making the “state of the team” always available, always current, and living where people already talk.

We also learned that messaging integrations live and die by reliability: one clean MCP integration, deterministic tool behavior, and clear boundaries around shared vs personal data makes the experience feel real.