Zero to Agent in 30 Minutes: Build a Sports Concierge Agent with Chester Ismay

Michelle Smith · rss · 2026-09-21 Reader 🖥️

Agent Harness Agent Security Agent Context Files (CLAUDE.md / AGENTS.md)Long-Running & Managed Agents

A minimal-infrastructure pattern — a single markdown policy file plus pre-fetched data, scoped tool permissions, and ordinary OS scheduling — is enough to turn a recurring personal decision into a reliable, unattended weekly agent, without needing dedicated agent-orchestration infrastructure.

practical · expository — A build-log recap of a video walkthrough: a numbered how-to for assembling a narrow personal agent, framed by a problem statement (deciding what to watch, not finding schedule data) and closed with an iteration note and series teaser.

Structure

Part	Role
Problem framing: Chester already had schedule viewers for the sports he follows, but still had to manually decide which games were worth his attention each week.	context
Five-step build walkthrough: preferences file, a script that pre-fetches and combines schedule + preference data, CONCIERGE.md as the policy defining the agent's job, execution under limited permissions, and OS-level scheduling plus notification delivery.	evidence / main content
Iteration note: when output misses the mark, Chester edits CONCIERGE.md rather than the code; a timezone bug was fixed the same way, by adding explicit instructions to the policy.	evidence for the policy-file-as-primary-control-surface claim
Series teaser for next week's episode (an agent given its own cloud computer via E2B/Scrapybara).	context, not argument

Key terms

sports concierge agent
A narrow, single-purpose, scheduled agent that filters a personal data feed (sports schedules) against stated preferences and delivers a curated weekly recommendation.
CONCIERGE.md / policy
A single markdown file that defines the agent's job: goal, data sources, decision rules (including edge cases like finished tournaments and duplicate matchups), and expected output/delivery format. Used loosely — not a formal access-control policy, but a natural-language behavior specification.

Propositions

implicitA structured, context-rich preferences file (with a purpose-built editing interface) produces better agent decisions than working directly with the underlying raw JSON.conf: medium
explicitPre-fetching and combining schedule and preference data into one tool call, rather than letting the agent search for each game itself, reduces the work and error surface of the agent's task.conf: high
explicitWhen an agent's output misses the mark, the correct fix is to add detail to or adjust the natural-language policy file, not to change the underlying code or model.conf: high
supportsJobRunr Introduces ClawRunr, an Open-Source Java AI Agent · p4 — Both pieces treat a workspace markdown file (AGENT.md/INFO.md there, CONCIERGE.md here) as the actual configurable control surface for agent behavior — this is a second, independent case of the same pattern.
explicitRestricting an agent's permissions to only the files and tools a task requires is presented as a routine, low-effort safety step for a personal automation agent, not a specialized security exercise.conf: high
supportsThe Anatomy of an Agent Harness · p8 — Chester's permission-scoping is a lightweight, concrete instance of the architectural principle that permission/safety enforcement should sit outside the model's own reasoning.
implicitOrdinary OS-level tools (a Mac scheduler and a simple push-notification service) are sufficient for reliably running and delivering a personal agent's output on a recurring schedule — no dedicated agent-orchestration platform is needed.conf: medium
explicitCorrectness bugs in a narrow personal agent (e.g. a timezone default causing games to land on the wrong day) surface only through real use, not upfront design, and get patched by adding explicit instructions after the fact.conf: high

Arguments

The policy file (CONCIERGE.md) is the most leveraged place to iterate when a personal agent's behavior needs correcting. strength: medium

Explicit premises:

Chester's stated troubleshooting method, both generally and for the specific timezone bug, was to return to CONCIERGE.md and add or adjust instructions.

Implicit premises:

The agent's decision logic is fully governed by what's written in the policy file rather than by hidden code paths outside it.
The model reliably changes its behavior in the intended direction in response to more specific natural-language instructions.

Inferences:

This implies the policy file functions as the agent's real 'source code' for behavior — debugging the agent means editing prose, not code.

Narratives

A timezone bug: because the system defaulted to UTC, games could appear on the wrong day; Chester fixed it not by changing code but by adding explicit timezone instructions to CONCIERGE.md.
→ Shows concretely that even a narrow, well-scoped personal agent produces the classic class of silent default-assumption bugs — and that the piece's fix-the-policy-not-the-code proposition (p3) is more than a stated principle; it's what actually happened when something broke.

Questions addressed

✅ How do you keep a personal agent from doing more than its assigned job?
By scoping tool/file permissions narrowly to what the task requires, and by defining the agent's goal, data sources, and decision rules in one policy file.
✅ How do you build a small, recurring personal AI agent without standing up dedicated agent infrastructure?
Compose it from a policy file, a data-fetching script, Claude Code as the execution engine, OS-level scheduling (launchd), and a lightweight notification tool (ntfy).
⭕ How much ongoing manual review does a policy-file-governed personal agent actually need before its output can be trusted unattended?

Gaps

incompleteThe piece asserts errors get 'caught' by tests and multiple data sources and that Chester 'checks the recommendations against the underlying schedules,' but never specifies how much manual review still happens each week versus fully trusting automated output — leaving open how much human-in-the-loop checking this kind of low-stakes, high-frequency personal agent actually needs at steady state.
Read next: Look for content that measures or reports actual error/false-positive rates of policy-file-governed personal agents over time, or a human-in-the-loop framework calibrated to low-stakes, high-frequency automation specifically.
incompleteNo discussion of what happens to CONCIERGE.md as more edge cases (finished tournaments, duplicate matchups, timezone handling, and whatever comes next) get patched into it — whether a purpose-built agent policy file degrades the way large CLAUDE.md/context files are reported to elsewhere in this corpus as more rules accumulate.
Read next: Compare against material specifically on CLAUDE.md/AGENTS.md bloat and context degradation from iterative rule-patching.
uninformed'Limited tool permissions' is described only qualitatively ("configured permissions so the agent worked only with the files and tools required") with no detail on the actual enforcement mechanism (OS sandbox, Claude Code's permission-prompt system, filesystem scoping) or how it was verified — thinner than more rigorous treatments elsewhere in the corpus of what enforcing agent permissions architecturally actually means.
Read next: See the corpus's own treatments of permission-enforcement mechanisms for concrete comparison.