The Tools We're Testing Right Now: Agent Swarms and AI Product Docs
In this lesson: Ash Tilawat and Derek Peters walk through the AI tools they're testing right now — routing each job to the harness built for it, giving an agent swarm a manager and a memory, and building the integration yourself when none exists, with a human still reviewing the output.
Get reminders
One signup gets you join links, reminders, and the recording library. No ongoing commitment.
Top 3 takeaways
Match the tool to the task, not the other way around
Neither presenter is looking for one universal agent. Ash splits his work by harness — Codex for coding, Grokbot for QA, research, and marketing ops, and Cowork for internal Claude-based work — while Derek reaches for ChatPRD specifically because it was built for product docs. The skill on display isn't loyalty to a tool; it's knowing which harness is built for which job.
Agent swarms need a manager and a memory
Ash runs a “chief of staff” agent that directs a swarm of bots, but context starts to fray past roughly 15 agents. The fix is structure: give the manager a queue and a real database — SQLite or Notion — so it can delegate, track state, and stay free to take your next instruction instead of stalling while it watches other agents work.
If the integration doesn't exist, build it — and keep a human in the loop
When a tool has no MCP, Ash has Cowork walk the app, write a spec, and hand it to Claude Code to generate a CLI wrapper, so agents can act anywhere. Across both demos the throughline holds: AI gets you to a running swarm or a fast first draft, but a person still reviews, redirects, and approves before anything ships.

Ash Tilawat
CTO, Gauntlet AI
Ash Tilawat is CTO of Gauntlet AI, where he leads the company's technical direction and hosts Night School. He spends his days stress-testing new AI tools and harnesses — often within days of release — to decide what's worth adding to the team's workflows.
Derek Peters
Professor, Gauntlet AI
Derek Peters works with Gauntlet and has been a product and program manager for fifteen years, focused on how AI changes the way product teams scope, document, and ship.
Lesson notes
A written walkthrough of the session, covering the tools each presenter is testing, how they orchestrate agents, and where a human still has to step in.
Why the team tests tools in the open
Night School regularly opens with the Gauntlet team showing what's at the top of their minds — the tools, workflows, and methodologies they're experimenting with before deciding whether to fold them into how they actually work. This session pairs an engineering-and-ops view from Ash with a product view from Derek, so the same question (“is this worth adopting?”) gets answered from two angles.
Grokbot and the chief-of-staff pattern
Ash's main demo is Grokbot, run through the Grok desktop app, using a single “chief of staff” agent to manage a swarm of sub-agents. The setup order matters: create the chief of staff first, give it a name and a description that spells out how it should lead the swarm and what to use the swarm for, then instruct it — explicitly using the words “swarm” and “bots” — to spawn workers. In the demo it fans out into an FAQ bot, a SERP bot, a community bot, and a Gauntlet-mentions bot, all combing the Gauntlet AI site and search results for missing questions, broken links, and 404s. The chief of staff then maintains a running report or dashboard so the human can verify the work rather than letting it run blind.
Managing a swarm without losing the thread
The practical ceiling Ash hits is context, not capability — things get messy past 15 to 20 agents. His answer is to manage the swarm the way you'd manage a team: have the chief of staff distill the important events and failure states, and back it with a queue in an outside store like Notion or SQLite. Once work is queued, the manager stops re-checking it and moves on, then comes back to the queue on a schedule. He also notes that evals and observability aren't solved on Grok yet; the interface is new, and rigorous tracing would mean piping the log database into an external tool.
When there's no MCP, build a CLI
A recurring wall is tools with a bad MCP or no MCP at all. Ash's workaround: you can make a CLI tool out of anything. Using Playwright and JavaScript to drive browser actions deterministically, he has Cowork walk through an app (his example is Facebook Marketplace), build a spec for a CLI, and hand that to Claude Code to generate it. The result is an agent that can act in any app or browser without waiting for an official integration.
Matching the harness to the work
Ash's daily workhorse model is Grok 4.6, and he escalates to Opus or Sonnet when Grok can't finish a task. For harnesses, Codex stays his primary coding engine, while Grokbot handles the surrounding work — QA'ing deployed sites via a dev or staging URL, writing specs, finding API docs, reviewing PRs, and research-heavy marketing tasks like combing the Facebook ads library or triaging resumes. Internal, Claude-entrenched team work runs through Cowork. His read on why Grokbot lands: it feels built for someone without a terminal background, a stepping stone to capability that Hermes- or Pi-style developer harnesses assume you already have.
ChatPRD: from blank page to first draft
Derek's tool is ChatPRD, built by a chief product officer, which he's been testing with the product team. It does two things well: it gets you to a draft fast, and it carries strong integrations — Slack, Google Docs, Notion, Teams, Confluence, Jira, and GitHub. Templates cover PRDs, one-pagers, go-to-market briefs, competitive analysis, API documentation, and coding rules, and the enterprise tier can scrape competitor information into the draft as you write. Because the tool is opinionated toward a product-first mindset, it asks the clarifying questions engineers often skip — users, outcomes, personas — which is exactly where engineers tend to struggle when writing a vision doc.
Feeding tools clean inputs
Both presenters converge on the same lesson: don't dump raw material into a model. Derek runs rough meeting transcripts through a dedicated notes skill first, then uses Cowork to file them, so his chats don't balloon and hallucinate. Ash goes further and stores text in SQL — modeling the data to match the information type — because agents navigate structured data far more reliably than a loose pile of tokens. As Derek puts it, SQL is a data structure, and LLMs work well with structured data.
Overnight and managed agents
Derek keeps most agent work in the daytime with checkpoints until he trusts a routine, but he does have Cowork draft social posts and morning email replies (around 6 AM) for him to approve on login. Ash points to three ways to run work unattended: a routine on Grok, a scheduled task on Cowork, or a managed agent running in the cloud — hosted by Anthropic, or a Cursor cloud agent built with the Cursor SDK — which he frames as a “dark factory” that can run around the clock. He references an earlier Night School on managed agents led by Matt Wood for the deeper version.
FAQ
Do you give the chief-of-staff agent a system prompt or special tools? +
How do you manage agents at scale before it gets messy? +
What happens when an agent fails a step — does it alert the human? +
How do you get an agent to act in an app that has no MCP? +
Grok, Claude, or Codex — which for what? +
How do you feed messy transcripts into a tool like ChatPRD without overwhelming it? +
How do you run agents overnight, and how do you sandbox them? +
What's next?
Keep building with the rest of Night School, or apply to Gauntlet — ten weeks of technical intensity with the best AI engineers we can find.