Latch

Inspiration

Every meeting ends the same way: "I'll send that over by Friday." "Let me check and get back to you." "We'll circle back once finance looks at it." Everyone nods, the call ends, and nobody owns any of it anymore.

We kept watching projects slip for reasons that had nothing to do with talent. They slipped because a promise made out loud was never written down anywhere that mattered. There's no error message for something that just didn't happen. Silence looks exactly like "handled" until the deadline has passed and the damage is done. We wanted an agent that owns the gap between "I'll get back to you" and whether anyone ever did.

What it does

Latch reads the full meeting conversation, not a summary, and pulls out every real commitment anyone made, including the ones you made yourself. Each one becomes a tracked loop: who owns it, what counts as done, and when it's due (stated, or inferred from how it was said). Vague remarks like "we should look at that sometime" are deliberately ignored.

When a loop goes overdue, Latch first checks whether it's already done, then chases it by email, quoting the original promise word for word.

The part we're proudest of is how it reads the reply. A reply is rarely "done" or "not done", so Latch classifies it into one of five outcomes:

• Closed: verified against the counterparty's own system of record. Latch doesn't take anyone's word for it.
• Deferred: spawns a linked follow-up loop and keeps the full history.
• Transferred: re-targets the new owner and sends them the whole backstory, so they don't start from zero.
• Disputed or Ambiguous: escalated to a human. Latch never guesses.

Every decision cites the exact sentence it was based on. Over time, Latch builds something nobody has ever had: an evidence-based scorecard of which vendors and partners actually keep their word.

How we built it

• Strands Agents SDK running three specialized agents:
  • an Extractor that turns a transcript into typed loops
  • a Pursuer with six tools that picks its next move from each loop's history
  • an Adjudicator that turns replies into structured verdicts
• Amazon Bedrock (Nova Pro) as the model.
• Bedrock AgentCore Runtime hosting the deployed agent.
• Real infrastructure: real Gmail sending and receiving, with reply matching by email threading headers plus a subject-tag fallback, and a real Google Sheet as the counterparty's system of record. Nothing is mocked.
• A shared domain core, so every service agrees on what a loop is.

Challenges we ran into

• Model access: our first two model families were blocked or unusable on Bedrock. Llama structurally can't stream tool calls, which Strands depends on. We moved to Nova Pro, then found it would skip its tools when asked for structured output in the same call, so we split reasoning and output into two turns.
• Email: phone mail clients strip threading headers, so we added a subject-tag fallback to keep replies matched to the right loop. First-contact automated emails land in Spam, and we learned to plan for that.
• Deployment: AgentCore builds only see the folder you deploy from, which broke our monorepo. We fixed it by reading the raw build logs, because the toolkit's error message didn't say what went wrong.

Accomplishments that we're proud of

• An agent that knows when not to act: it escalates disputes and unclear replies instead of guessing.
• A deferral that becomes a linked follow-up instead of a dead end, and a handoff that carries the full history to the new owner.
• Every judgment comes with its evidence highlighted, so a human can audit any decision in seconds.
• Real emails, a real system of record, and a real cloud deployment.
• A reliability scorecard built from what people actually did, not what they promised.

Built With

• amazon-web-services
• python
• react
• strands-sdk
• typescript