Michael Hoefert

Instead of relying on a single AI prompt, I have challenger and defender agents literally debating each other to fact-check claims and kill hallucinations before you ever see the output. I also integrated LangSmith so we can actually understand and measure agent performance. To keep the AI from hallucinating logic, I built a Shared Tool Registry—the agents are bound to deterministic Python scripts they can call to scrape job descriptions with Firecrawl, execute exact KNN vector searches against a Postgres database, and securely decrypt PII during document export.

But the coolest part is the Compounding Memory System. In the background, Joey's memory agents analyze your edits and feedback to build specific writing 'skills' tailored to different job titles, company sizes, and industries (e.g., a Staff PM at a Growth-Stage FinTech). When you apply for a job that fits those criteria, the system's writing agents automatically retrieve and use those exact skills via a HyDE (Hypothetical Document Embeddings) RAG model. These skills are constantly refined every time you provide feedback or make an edit, meaning Joey learns your unique voice over time. The product uses some of the best agentic memory practices so that you aren't constantly context seeding. Coupled with a 'Labor Illusion' UI that shows you the agents' thought processes in real-time, it's an engine built from the ground up to actually learn your career narrative and never lie.

Built over 7+ months as a solo founder project, the real complexity lives in the closed feedback loop the platform creates. Every graded call feeds a "maverick" detection layer that surfaces wins where reps broke the playbook and still closed deals. Each maverick is analyzed by complex context-seeking LLM APIs to distinguish replicable techniques from deal-specific context, then verified by the manager. The manager verification stage is crucial; it provides a human-in-the-loop verification gate but also allows managers to add commentary on why or why they are not verifying a call. The manager commentary is then stored and used to power the self-learning maverick detection engine so that over time, the detections are more aligned with what the manager wants. Once enough verified mavericks accumulate, a correlation engine cross-references bypass frequency against historical coaching session records, and when a criterion has been coached repeatedly but top performers keep skipping it in winning calls, the system classifies it as terminally flawed and flags it for removal in the next evolution proposal. That proposal renders as a side-by-side rubric comparison with per-change rationale and evidence strength, with the pre-computed frequency analysis injected as structured context. The result is a methodology that updates itself from the team's own winning patterns, and a system that can tell a manager not just that their reps aren't following the script, but that the script is wrong.

Built as a fully custom, self-improving training engine, the real complexity lives in the automated closed feedback loop. Raw data is server-side rendered directly from Airtable, ensuring the dashboard is always hydrated with live metrics. Every activity logged on Strava triggers a scheduled GitHub Actions workflow that streams raw sensor data into our Python math engine. Here, we run decay calculations to track CTL (Fitness), ATL (Fatigue), and TSB (Form), along with cardiac drift (Pa:HR) metrics to flag aerobic decoupling. Every morning, an autonomous Antigravity AI Agent runs an analysis on the updated metrics, cross-references my subjective recovery notes and IT-band pain logs in Airtable, and writes back detailed coaching narratives. These narratives actively shape future workout intensities, closing the loop from raw biometrics to physical adaptations.

The core of this setup is designed around architectural reliability and efficiency. There is so much I want to speak about here with my GitHub but one of the most fascinating learnings I had recently was while exploring agentic systems, I found that relying on Model Context Protocol (MCP) servers and LLMs to query live third-party databases was highly token-inefficient and prone to latency or formatting issues. To solve this, I designed a pipeline of scheduled Python scripts that fetch data deterministically via direct APIs, storing clean datasets before any AI models are invoked. Every morning, three separate GitHub Actions workflows spin up: two prepare daily intelligence briefings for my day, and one runs a weekly analysis to structure my Sunday reviews (I also built 10+ other scripts for other data ingestion tasks like syncing my complete tasks from my task tracker app - I won't get into them all here). By building this deterministic data layer, I can leverage LLMs and custom knowledge skills on structured, predictable outputs, showing firsthand how a PM's architecture choices dictate both product utility and operational margins.