A Standup Bot in 90 Lines of TOML

An autonomous agent that runs without you, uses only shell + git, and remembers across sessions.

standup_bot.toml

The Problem

Standup is a chore. You forget what you did yesterday. Your git history knows, but you don't have time to review it every morning. And when you do write standup notes, they're generic and unhelpful.

What if an agent could do this for you — every day, at the same time, without being asked?

The Config

The entire agent is defined in standup_bot.toml — 90 lines of TOML. No Python. No JavaScript. No runtime dependencies beyond QueryMT itself.

Agent definition

[agent]
provider = "anthropic"
model = "claude-sonnet-4-5-20250929"
assume_mutating = false
# No mutating tools — this agent is strictly read-only
mutating_tools = []

Read-only by design

assume_mutating = false and an empty mutating_tools list means this agent can never write to disk or execute mutating commands. It reads git history and writes to its knowledge store — nothing else.

Tool selection

[agent]
tools = [
  # Git & codebase analysis (read-only)
  "read_tool", "index", "glob", "search_text", "ls", "shell",

  # Knowledge lifecycle — the magic
  "knowledge_ingest",      # Store findings
  "knowledge_query",       # Recall past standups
  "knowledge_consolidate", # Merge daily → weekly
  "knowledge_list_unconsolidated",
  "knowledge_stats",

  # Task tracking
  "create_task", "todowrite", "todoread",
]

Knowledge lifecycle tools

Three tools handle persistent memory: knowledge_ingest stores structured findings, knowledge_query retrieves them, and knowledge_consolidate merges related entries into higher-level summaries. The agent remembers across sessions automatically.

Three-layer context compaction

# Layer 1: Tool output truncation
[agent.execution.tool_output]
max_lines = 1000
max_bytes = 25600

# Layer 2: Pruning after every turn
[agent.execution.pruning]
protect_tokens = 20000

# Layer 3: AI summary on context overflow
[agent.execution.compaction]
auto = true

Git log output can be huge. These three layers keep the context window manageable: truncate tool output at 1000 lines, prune old messages while protecting recent ones, and automatically summarize the conversation when it grows too large.

Middleware: execution limits

[[middleware]]
type = "limits"
max_steps = 30    # Max tool calls per cycle
max_turns = 15    # Max conversation turns

[[middleware]]
type = "context"
warn_at_percent = 80   # Warn when 80% of context used
compact_at_percent = 90 # Auto-compact at 90%
fallback_max_tokens = 128000

Cost-bounded execution

With max_steps = 30 and max_turns = 15, each scheduled cycle has a hard ceiling on cost. The agent can't run away. Context management ensures it never hits token limits unexpectedly.

Setting Up the Schedule

After launching the dashboard, create a schedule via the UI:

Open Session → Schedules → Create Schedule
Prompt: "Run a standup cycle: analyze recent git activity, ingest findings, and report."
Trigger: Interval, 86400 seconds (every 24 hours)
Max runs: 30 (one month of daily standups)
Max steps: 20

Automatic expiry

After 30 runs (one month), the schedule expires automatically. No orphaned processes. No cleanup needed.

What Happens

Every day at the same time, the agent runs this cycle autonomously:

1. Git analysis Runs git log for the last 24 hours. Reads changed files, commit messages, and diff patterns.

→

2. Pattern extraction Identifies what areas were worked on, what issues appeared, what patterns emerged.

→

3. Knowledge ingest Stores structured findings: "API layer saw heavy refactoring, 3 new endpoints added, test coverage dropped."

→

4. Standup report Generates the day's standup: what was done, what's in progress, what's blocked.

Over time, the agent builds a knowledge graph of your project's history. Weekly consolidation merges daily standups into weekly summaries. Query past standups anytime:

# Ask the agent in the dashboard:
"What were the main themes from last week's standups?"

Key Features

Interval scheduling — runs on a fixed cadence, no user interaction needed
Knowledge lifecycle — ingest daily, consolidate weekly, query anytime
Autonomous execution — the bot does its job without you watching
Cost-bounded — max_steps and max_turns prevent runaway costs
Three-layer compaction — handles large git outputs gracefully
Automatic schedule expiry — no orphaned processes after the trial period

Try It Yourself

# Clone and run
git clone https://github.com/querymt/querymt.git && cd querymt
cargo run --example qmtcode --features dashboard -- \
  confs/standup_bot.toml --dashboard

# In the dashboard, create a schedule:
#   Session → Schedules → Create Schedule
#   Prompt: "Run a standup cycle: analyze recent git activity, ingest findings, and report."
#   Trigger: Interval, 86400s (daily)
#   Max runs: 30