KYC.ai

What it does

KYC.ai is an always-on meeting prep agent for founder-led sales. When a new meeting lands on your Google Calendar, the agent automatically:

1. Detects the event and infers the company and attendee context from calendar data
   
2. Enriches the meeting with three parallel real-time web searches — company news, role-specific pain points, and competitor landscape
   
3. Synthesizes prioritized insights, personalization hooks, competitor positioning, a pre-meeting email draft, and a follow-up template using GPT-4o structured output
4. Delivers everything to Notion and creates Gmail drafts — ready before you even think about the meeting

The key differentiator is the continual learning loop. A Steering Profile controls every dimension of the agent's behavior — product focus, ICP, key pains, competitor list, and prioritization weights. When a founder gives thumbs-down feedback, the system automatically adjusts: "too generic" adds specificity rules, weak competitor coverage boosts competitor weight, and all weights are renormalized so $\sum w_i = 1$. Every meeting stores which steering version produced its output, so the learning is auditable, not just magical.

How we built it

Backend — FastAPI (async Python) with SQLite/SQLAlchemy. The pipeline orchestrator chains four stages: calendar polling → enrichment → synthesis → artifact delivery. Each service soft-fails gracefully — missing API keys return placeholders instead of crashing.

Enrichment — Three parallel You.com API searches with queries templated directly from the steering profile:

• "{company} latest news announcements {product_focus}"
• "{role} pain points challenges {icp} {key_pains[:2]}"
• "{competitors[:3]} comparison {product_focus}"

Synthesis — OpenAI Agents SDK with GPT-4o and Pydantic structured output. The system prompt is fully parameterized by the steering profile — weights, focus areas, disallowed claims, specificity rules — so changes propagate instantly without retraining.

Integrations — Composio SDK for unified OAuth and tool execution across Google Calendar, Gmail, and Notion. One entity, three connected apps, zero token management.

Frontend — Next.js + TypeScript with server-side data fetching. Three views: meeting queue, meeting dossier (insights/hooks/competitors/drafts/feedback), and a steering profile editor with weight controls.

Feedback loop — Keyword analysis on negative feedback adjusts weights and injects rules, then creates a new immutable steering profile version. Weight normalization ensures:

$$w_i' = \frac{w_i + \Delta_i}{\sum_j (w_j + \Delta_j)}$$

Challenges we ran into

Composio SDK breaking changes — The SDK API changed between versions (composio.tools.execute → entity.execute(action=Action.ENUM, params=...)), causing silent 400 errors at runtime. No migration docs existed — we had to inspect the SDK source code to find the correct API surface.

You.com API response format drift — The documented response structure (web.results[]) didn't match the actual API (results.web[]), and the age field became page_age. Our unit tests passed with mocks but returned zero results against the live API. Lesson: always integration-test against the real endpoint.

Dependency conflicts — openai-agents==0.8.0 requires openai>=2.9.0 but the project pinned openai==1.59.9. Pip's error messages were unhelpful. Debugging the resolution tree and loosening the pin resolved it.

Making learning visible — The hardest design challenge wasn't technical. It was making the continual learning observable in a demo. Storing steering_version on every meeting and supporting re-runs via "Run now" lets you see the same meeting produce different outputs as the profile evolves.

Accomplishments that we're proud of

• End-to-end pipeline in a hackathon — Calendar detection → real-time enrichment → LLM synthesis → Gmail drafts and Notion sync, all wired together and working live
• The feedback loop actually works — Thumbs-down on a meeting visibly changes the next run's output. It's not a gimmick — the weight adjustments and specificity rules produce measurably different synthesis results
• Immutable steering versions — Every meeting records which profile version produced it, giving full traceability. You can compare v1 vs v3 output on the same meeting and see exactly how the agent learned
• Soft-fail architecture — Every external service (You.com, OpenAI, Composio) degrades gracefully. You can demo any subset of the system without the rest being configured
• 19 unit tests + live integration tests — Real test coverage with mocked and live API validation, not just "it works on my machine"

What we learned

• Structured output changes everything — Pydantic models as GPT-4o output types eliminated all JSON parsing headaches and made the synthesis → frontend pipeline trivial to wire
• Parameterized prompts > fine-tuning for fast iteration — Embedding steering profile values directly into the system prompt gives instant behavioral changes without any training step. For founder-led sales where the pitch evolves weekly, this is the right abstraction
• Integration testing catches what unit tests can't — Both the You.com response format and Composio SDK issues were invisible to mocked unit tests. The live integration tests caught both immediately
• Composio is powerful but moving fast — Unified OAuth across Calendar, Gmail, and Notion saved days of integration work, but the SDK is iterating rapidly and docs lag behind the code

What's next for KYC

• Multi-meeting learning — Aggregate feedback across meetings to detect patterns (e.g., "insights about {competitor X} always get thumbs-down") and auto-adjust without explicit steering edits
• Attendee-level enrichment — LinkedIn profile context, past interaction history, and org-chart positioning for each attendee, not just the company
• Post-meeting feedback ingestion — Ingest call recordings or meeting notes to auto-score whether the prep was actually useful, closing the loop without manual thumbs-up/down
• Drift detection — Alert the founder when steering weights have shifted significantly over time, or when enrichment queries are returning stale results for a market segment
• Team-wide deployment — Shared steering profiles with per-rep overrides, so an entire sales team benefits from collective learning while preserving individual style

Built With

• python