Hi, I'm Asaf. This is Daniel. We run Corgi. We help startups put AI into real workflows, and we run an AI employee inside our own company. Today, instead of telling you what's possible, we want to show you what we've seen actually survive contact with a real startup. Three patterns. That's it.

Quick on us. We help companies integrate AI into the workflows that actually move their business. And we run an AI employee inside our own company every day. Most of what we're about to show you, we live with daily.

Quick story on how this started. Both of us were running consulting. Calls every day. Companies coming in faster than we could process them. Follow-ups slipping. Scopes piling up. The CRM rotted in real time. We didn't have a sales problem. We had a "two humans can't be a sales team" problem.

If you're in this room you've felt this, or you're about to.

So we built our own AI employee. We called it Token. It transcribes every call, drafts the follow-up in our voice, updates the CRM straight from the conversation, schedules meetings without exposing the calendar, and catches commitments before they slip. We live in it daily.

A few weeks in, the people we'd just met started asking what we were running. That told us the patterns generalize. The rest of this hour is the three patterns that survive in real startups, plus the one rule for everything we don't automate.

Here's our premise. Most of the AI-for-ops stuff being sold right now demos great and dies in week three. The reason isn't bad models. It's that startups are chaos engines. Information moves in voice notes and DMs, not tickets. The tools that work in a 5,000-person org don't survive here.

Quick on us. Corgi is an AI-native services firm. We run an AI employee inside our own company every day. And we've built these patterns inside ~30 other startups. When we say something works, we mean at our scale and at theirs.

Every sales call ends with the same homework: pull the transcript, update the CRM, draft the follow-up, tell your team. It's 20-30 minutes per call. Most founders skip it; the CRM rots; follow-ups slip. This is the cheapest, highest-leverage thing to automate.

Here's the before and after. Left: the transcript captured the moment the call ends. Right: your Notion deal updated automatically. Stage, next step, blockers, pulled straight out of the transcript.

We're also drafting the follow-up email in your voice (saved to drafts, never sent) and dropping a 4-line recap into your team Slack. We just don't put those on the slide. They're easier to show in conversation.

The same shape shows up everywhere. One customer connected Gmail and immediately found 15 unsent drafts they'd forgotten about. Another set up an email digest so they stop opening the inbox at all. Another runs meeting prep that pulls LinkedIn for everyone on tomorrow's calendar. Same pattern every time: move information from where it lives to where you act.

One we like: CEOs live in WhatsApp, their teams live in Slack. The agent bridges the two so the CEO never has to context-switch and the team never misses a decision.

Principle: drafts not sends. Trust takes time to build, one bad send to break.

Founders make about 50 micro-commitments a week. "I'll send the deck Thursday." "I'll loop you in after my CTO call." Most live in DMs and never reach a task list. You're not unreliable on purpose. Commitments just don't have a state machine.

Left: a real promise in a thread. The agent flags it, logs it with the deadline, links back to the source message so you can verify in a second.

Right: on the day, a quiet nudge. "You said you'd send the deck today. Want me to draft it?" If yes, drafts. If no, dismissable in one tap.

Principle: annoying agents get muted, and a muted agent is dead. Detection has to be conservative. Only flag real promises.

Most founders end up split between Slack and WhatsApp. Slack collects investors, prospects, customer channels, partner threads. WhatsApp collects the team's day-to-day. Both accumulate fast. Neither has a good view of the other.

So you screenshot from one to the other. Or you skim Slack at 11pm trying to catch what mattered. Or you start writing a Slack update from your WhatsApp threads and give up halfway.

Left: Slack noise distilled into a short WhatsApp digest. Just what the founder needs to act on, in the app they already live in. Right: WhatsApp activity turned into a Slack update for whoever's reading it there.

The principle: don't ask anyone to open another app. Bring each channel's signal to where each person already is.

One we use almost every week. Or is on the move and instead of typing out an update, he just records a voice note in WhatsApp. Could be a minute, could be three. He sends it to a chat with the agent.

The agent transcribes it, pulls out what's actually decision-worthy, and routes a clean update into the right Slack channels — one update for #fundraising, another for #product — so the rest of the team gets the relevant piece without listening to the audio.

Saves the CEO 10 minutes of typing each time. Saves the rest of the team from listening to 3 minutes of voice they don't have time for.

One thing to add now that you've seen the patterns. None of them worked on day one. They got stable through a process, not a deploy.

Phase one: human in the loop. Every action is an approval. The agent proposes; we accept or reject. Early CRM updates were way off. Stage detection was finicky. We caught it because we were reviewing every one.

Phase two, and this is the most surprising part: we never changed code. We tuned by talking to it. Better prompts. Clearer tool descriptions. Better integrations. The agent kept memory of what we told it across the conversation. After a few rounds, the CRM updates were what we wanted.

Phase three: release autonomy, but only where trust is earned. The post-call routine runs by itself now. Sending an email to a human, though? Still a draft. Always a draft. Some things stay in approval forever, and we'll come back to that.

The flip side of "earn the autonomy" is "know what stays manual." There are three categories we never released, even with months of clean drafts behind us.

One: outbound to humans. Always a draft. The agent writes in your voice, lands in your drafts folder, you send. The day you let the agent send is the day it sends the wrong thing to the wrong investor.

Two: anything irreversible. Payments. Hires. Deletes. Public posts. The "undo in 10 seconds" test is the line.

Three: anything where the cost of wrong is more than 10 times the cost of doing it yourself. Updating the wrong deal stage costs you a week of confusion. Doing the update yourself costs you 30 seconds. The math is obvious once you write it down.

One thing to take home, then we open the room. Don't try to automate everything. Pick one workflow this week. The three filters: you do it more than three times a week, it takes you more than 15 minutes each time, and it's reversible if the agent gets it wrong. Frequency makes the savings real. Time-spent is the threshold below which automation costs more than it saves. Reversible is what keeps it safe while you build trust.

Then iterate in conversation, the way we showed you. Not in code. You'll know it's working when you stop checking it.

And the highest-leverage part of the next hour: steal whatever's working from the founders next to you. That's why we kept the back half of the session for the room.

Over to the room. We're not going to put anyone on the spot. Just throwing out a few prompts. Jump in wherever you want, on whichever one resonates. We promise we won't try to sell you Corgi unless you ask.

That's our 30 minutes. Thanks for having us. Now stick around, the back half is the room.