PitchLoop

Inspiration

At my startup, one of the things we've been wrestling with lately is marketing outreach — finding the right people, actually reaching them, following up, and figuring out what messaging lands. It's manual, repetitive, and easy to do badly. I wanted to use this hackathon to explore what an agent could realistically take off our plate.

Most "AI SDR" tools just run a fixed script. We were more interested in an agent that improves itself — one that learns from each conversation and even builds the capabilities it's missing, instead of us hand-coding every step.

What it does

PitchLoop is a sales/marketing outreach agent. You give it a goal in plain language — "book a qualified meeting with this kind of person" — and it runs the whole loop on its own:

Discover and research prospects.
Place a real, paid outbound call.
If the call doesn't land, diagnose what went wrong, adjust its own pitch, and log it.
If it's missing a capability, build a new tool for it, verify it, ship it via a pull request, and reuse it on the next prospect.

Every action is checked against policy before it happens, and every step is recorded so the agent's next decision is based on evidence, not guesswork.

How we built it

A team of four, one person per layer, all coding to a frozen shared contract so we could work in parallel and still integrate cleanly.

The agent is one explicit state machine — plan → check policy → enrich → pitch → call → diagnose → grow toolset → retry — where every transition is driven by recorded evidence, not a hardcoded path. Three sponsors do the heavy lifting:

Zero.xyz — the runtime marketplace the agent buys prospecting, enrichment, and calls from, and the backbone of its self-improvement loop.
Pomerium — the policy layer that authorizes each sensitive action, sandboxes generated tools to only what they need, and gates repository changes.
Nexla — the record-keeper that normalizes every event into one trustworthy history the agent reasons over.

It's built in Python with strict typed contracts, and it enforces a hard budget: a paid action only fires while $\text{spent} + \text{price} \le \text{budget}$. The full loop runs in a faithful local mode for the demo, with the live sponsor adapters wired in behind configuration.

What we learned

The hard part of an autonomous agent isn't the model — it's the guardrails and the feedback substrate. Making the loop safe (policy on every action, path-restricted code generation, one automated repair attempt, budget limits) and observable (a clean evidence trail) was most of the work.
Freezing the interface contract on day one let four people build independently and integrate in hours instead of days.
Self-improvement is far more convincing as "grow your own toolset" than as "rewrite your own prompt."

Challenges we faced

Coordinating four people on one system without overwriting each other — solved with strict file ownership plus that frozen contract.
Keeping the loop honest — outcomes had to come from the real call result and recorded evidence, never a hidden "if this is call #1" shortcut.
Letting an agent write and merge its own code safely — restricting it to three approved files, requiring fixed conformance tests to pass, and only loading the tool after a genuine PR merge.
Live vs. demo — real phone calls, hosted policy, and data flows take real setup, so we built a faithful local mirror to prove the entire loop end-to-end while keeping the live path one config away.