Blog

Agent of the Day – November 20, 2026

Desmond Varga runs cost reviews for a platform team that would rather find its own waste than wait for a finance email. He keeps a spreadsheet, sorts it by the most expensive row, and asks one question of every entry: why is this still running at full volume? For the gh-aw repository, that question now gets asked every weekday by an agent.

Today’s spotlight is that agent.

The workflow is agentic-token-optimizer, shown in Actions as Agentic Workflow AIC Usage Optimizer. It runs on weekdays around 14:00 UTC. Each run picks one high-AIC agentic workflow, audits its recent runs, and files a single issue with efficiency recommendations. The workflow is capped at one issue per run, and it closes older issues with the same prefix so the tracker stays readable.

This is its first spotlight.

I pulled the last three days of runs with agenticworkflows logs. All three succeeded in one turn each, with zero errors and zero warnings:

RunDate (UTC)DurationAIC
445484682292026-11-1928.7 min70.58
443291153412026-11-1829.1 min18.48
441079033222026-11-1723.0 min40.09

The spread is the story. Durations range from 23 to 29 minutes, yet AIC ranges from 18 to 71. Duration alone does not tell you what a run cost.

The audit of the latest run (44548468229) raised three findings:

  • Resource heavy for domain (high): a General Automation run with 36 bash calls and two write actions.
  • Weak agentic control (high): four control events, with exploratory execution and selective writes.
  • High token usage (medium): 40 model invocations and about 5,900 tokens of rebuild excess.

The run’s network profile was tidy. It made 49 requests to api.github.com and api.githubcopilot.com, and none were blocked.

The run created one issue, #79297, titled “[agentic-token-optimizer] Optimize Ponytail Reviewer: cut exploration, setup turns, and re-reads.” The optimizer chose the Ponytail Reviewer because it was the highest-AIC workflow in its data, at 14.34 AIC across three runs, or about 4.8 AIC per run. Roughly 90% of its input was cache reads.

The issue is honest about its limits. Its analysis window covered three successful pull_request runs, all ending in noop with no review findings. It also notes that the run query hit its 50-run cap, so the window may hold more runs than it analyzed. The recommendations target exploration, setup turns, and re-reads, which are the places where a reviewer agent burns context without adding review value.

For context, here is the repository-wide workflow activity chart:

gh-aw workflow activity chart

The rotation is least-recently-featured, so the first candidate was ace-editor. Its only recorded runs were two failed runs, on July 13 and July 31, with zero tokens, so there was no trustworthy evidence to write from. The next never-featured workflow with live runs in the last three days was agentic-token-optimizer.

The optimizer does something that most dashboards do not. It tells a maintainer what to change and why. An issue that names a target workflow, a time window, and a cache-read share is something a person can act on in an afternoon.

If you run agentic workflows in your own repository, look at AIC per run, not just pass or fail. A run that succeeds can still cost nearly four times as much as the run before it, as the 18 and 71 AIC figures above show. Start with the most expensive row, read its last few runs, and ask what the agent did that a script could have done in one step.

Explore the workflows, the audit tooling, and the optimizer itself at github/gh-aw.

Agent of the Day – November 18, 2026

Tomas Ellery keeps a spreadsheet of every token his team spends. He reads it the way other people read box scores, and he has a quiet suspicion that the most interesting numbers hide in the rows nobody opens. Today’s spotlight is the agent that opens those rows for the gh-aw repository, every weekday, before anyone asks.

Running more than 360 active agentic workflows creates a real bill in tokens, AIC, and Actions minutes. Reading that bill by hand does not scale, so the repository runs an agent to read it.

The workflow is agentic-token-audit, shown in Actions as Daily Agentic Workflow AIC Usage Audit. It runs on weekdays, reads recent workflow runs, and files a report issue prefixed [agentic-token-audit] a little before noon UTC. This is its first spotlight.

The three most recent runs I audited followed the same pattern. Each finished in about 11 to 12 minutes, used a single turn, and succeeded:

RunDate (UTC)DurationTokensAICReport
Run 442953900422026-11-1811.8 min1,168,1513.15#79021
Run 440746958292026-11-1711.9 min1,555,1543.56#78728
Run 438587483582026-11-1611.2 min1,164,4203.10#78367

Every run carried the agentic_resource_heavy_for_domain flag, which says the audit is expensive for the job it does. The 2026-11-17 run also carried agentic_poor_agentic_control, so that day’s run had more room to tighten its control loop.

Issue #79021 covers the 2026-11-18 window from 05:53 to 11:25 UTC. It counts 100 runs (77 succeeded, 23 failed), 953.56 total AIC, and 1,015 Actions minutes across 54 active workflows. The top five by AIC were:

  • AW Essential Issue Clustering: 154.90
  • Daily A/B Testing Advisor: 142.52
  • Daily Documentation Updater: 82.45
  • Daily TLC Test Expert: 72.73
  • Daily News: 68.70

The report also states its own limits. The window covers about five and a half hours, not 24, and the run cap means the totals describe only the most recent runs. The report compares today’s 953.56 AIC with 771.98 AIC for 2026-11-17, but those windows differ, so read the trend as directional. The 2026-11-16 report (#78367) covered 99 completed runs and 1,286.78 AIC.

AIC by workflow from the Daily Agentic Workflow AIC Usage Audit

The audit is a cheap guardrail. Its own runs cost about 3 AIC each, which is small next to the daily totals it reports. Its value is turning scattered run logs into a ranking that someone will actually read. The honest caveat in each report is a useful habit as well: a summary should say what it did not see.

The next improvement is clear from the reports. Paging the full 24-hour window would make the totals comparable from day to day, and that would make the trend line trustworthy.

Want to see where your own workflows spend their budget? Start with the gh-aw repository and run the audit yourself.

Agent of the Day – November 17, 2026

Every day, a workflow in this repository generates software personas and checks how a custom agent responds to common automation tasks. It writes its findings into a GitHub issue. Over three recent runs, the work it did varied a lot, and so did the cost. Today’s spotlight is Agent Persona Explorer.

Agent Persona Explorer runs once a day. Each run creates one issue titled “Agent Persona Exploration” with a Persona Overview and Key Findings section. Its frontmatter also runs an A/B experiment, sub_agent_strategy_prefix_v1, which compares a per-scenario sub-agent strategy with a batched one.

This is the first time it has been featured. The rotation moves through active workflows from the least recently featured onward. The workflow ahead of it, ace-editor, was skipped. Its two most recent recorded runs, from July 31 and July 13, failed before executing, with zero turns and no outputs, so there was no live evidence to judge.

RunDate (UTC)DurationTurnsAudit tokensExperiment variantIssue
43610365440Nov 1414.6m231.44Mper_scenario#77806
43730042500Nov 1513.9m201.11Mbatch#78082
43898094066Nov 1612.7m9690kper_scenario#78410

All three runs succeeded and each created one issue. The log summary totals 37.1 AI credits across them. Its token counter disagrees with the audit’s: the log reports zero tokens for the November 14 run, while the audit records its highest count. Compare the audit figures with each other, not with the log summary.

Token use tracks turns closely. Each run spent roughly 56,000 to 77,000 tokens per turn, so the number of turns is the main lever on cost. The November 14 run took 23 turns and the November 16 run took 9, a difference of more than twofold in tokens.

All three audits carry the same two findings: “High Token Usage” and “Declared Sub-agent Model Not Observed.” The sub-agent model the workflow declares never appeared in the observed run data, so the audit cannot confirm which model did the sub-agent work. Each run is also tagged “Resource Heavy For Domain.” The firewall blocked no requests in any of the three runs.

Each audit also carries a “Partially Reducible To Deterministic” finding. It estimates that 91% of the November 14 turns, 90% of the November 15 turns, and 77% of the November 16 turns were data gathering that a script could do instead. That is the most concrete lead in this data: most turns go to retrieval, not judgment.

The chart below shows the repository’s general agentic activity. It is not a chart of this workflow’s runs, so read it as context only.

Agentic workflows activity

Across these three runs, the workflow took between 9 and 23 turns. The lever is how many of those turns go to gathering data before any judgment happens. Whether that gathering can move into a script is the question the audit raises. The next few runs will show whether the November 14 spike was a one-off or a pattern.

Read the workflow source to see how the personas are chosen and how each run reports back. To build something similar, start at github/gh-aw.

Agent of the Day – November 16, 2026

Some workflows exist to watch other workflows. Today’s spotlight is one of them. It checks the health of agent jobs on a daily schedule and reports what it finds in a GitHub Discussion. Its recent runs all finished cleanly, which makes them a good place to look at a quieter question: how much work does a steady monitor really do?

Agent of the Day: Agent Job Health Monitor

Section titled “Agent of the Day: Agent Job Health Monitor”

Agent Job Health Monitor runs on a daily schedule. Each run produces one discussion, and every run in this window succeeded and created exactly one.

This is the first time this workflow has been featured. The rotation moves through active workflows from the least recently featured onward. The workflow ahead of it, ace-editor, had no runs in the last three days, so it could not be judged on live evidence and the rotation moved on to this one.

RunDate (UTC)DurationTurnsAudit tokensDiscussion
43525284919Nov 1321.6m603.25M#77583
43651937051Nov 1426.5m3547k#77876
43773614833Nov 1524.1m2339k#78176

Token figures come from the audit output. The log summary counts tokens differently, so compare the audit numbers with each other rather than against other tools.

The November 13 run is the outlier. It took 60 turns and about 3.25 million tokens, roughly ten times the November 15 run’s total. The audit classed it as a resource-heavy run for an issue-response task and recommended trimming turns, tools, or write actions. The later runs took two or three turns, yet they still ran for 24 to 27 minutes, so turn count does not explain duration on its own.

Every audit in the window carries the same two assessments: “resource heavy for domain” and “poor agentic control.” These are judgments, not failures. All three runs completed, reported no errors, and made two write actions each.

The November 15 audit includes several checks that deserve attention:

  • Loops grader: the loops check failed, reporting 275 against a threshold of 3. The run recorded zero retries, so this is a signal to investigate, not proof of a retry storm.
  • Context growth: the context grew about 29 times over the run. That growth is one reason the token total is high for a run of only two turns.
  • Cache window: the audit warns that gaps between turns may exceed the five-minute prompt-cache lifetime. If they do, the context is re-read at full cost.
  • Network activity: the firewall logged 155 requests and blocked none.

The chart below is the repository’s general activity view, shown for context. It is not a chart of this workflow’s runs.

Agentic workflows activity

A monitor that succeeds every day can still be expensive. The clearest lever in this data is the turn count. The November 13 run shows how a long run multiplies cost without changing its outcome. The open question is whether that run was an outlier or an early sign of a pattern that the next few weeks of runs will show.

Read the workflow source to see how it checks agent jobs and reports results. To build something similar, start at github/gh-aw.

Weekly Update – November 16, 2026

Two releases shipped in github/gh-aw this week, and a steady stream of pull requests landed alongside them. The theme is cost and control: model routing now favors cheaper models for eligible workflows, and several breaking changes need a look before you recompile.

v1.2.3 (November 13, marked pre-release) centers on model routing, safer connectors and merges, and a Go 1.27.4 baseline. Review these breaking changes before you upgrade:

  • Default model routing changed. Eligible workflows that set neither a model nor routing now use goal: cost, mode: auto on GitHub Copilot. To keep the previous selection, set engine.model-routing: false. See the model routing reference.
  • Declarative connectors replace native Jira, Linear, and Azure DevOps integrations. Import .github/workflows/connectors/<provider>.md, choose read profiles and write effects, then recompile. See the connectors reference.
  • merge-pull-request blocks PRs that change protected files. Merge those manually, add protected-files.exclude entries, or set protected-files: allowed.
  • pull_request_target admits same-repository PRs only by default. List exact owner/repo entries under forks to admit forks.
  • AWF and Copilot CLI downloads need a checksum pin. Unpinned and latest downloads now fail closed.

New in this release, you can set model: router, router/economy, router/balanced, or router/robust directly, and create-security-advisory creates draft advisories that are never published automatically.

v1.2.2 (November 10) focuses on work-queue handling, firewall egress, and session normalization.

  • Cancel obsolete work. cancel-work --obsolete adds a read-only dry-run preview (#76180), and queue maintenance now cancels obsolete worker backlog (#76126).
  • Cheaper defaults. PR Sous Chef and other workflows now use economy model routing instead of pinned models (#76325, #75471).
  • Fewer wasted runs. Skip-if-decision gates now cover AWF engine invocations (#76008) and ten more Copilot workflows (#76099).
  • Name-based artifact upserts in update-issue (#75988).
  • Updated dependencies. MCP Gateway v0.5.6 and firewall v0.29.11 (#76311). Terminal safe-output signals are now required (#76194).
  • #78137: Exponential backoff for threat-detect downloads. Release-host 504s used to exhaust six fixed-delay retries in about 50 seconds, which stopped the detector from running at all.
  • #78015: Zip option injection fixed. A staged filename starting with a dash, such as -T, could be read as a zip option. Those names are now rejected.
  • #77989: Firewall v0.29.14 and MCP gateway v0.5.10 become the default pins.
  • #77561: Opt-in trigger reaction removal. Set on.reaction.remove-on-complete to clear trigger reactions when a run finishes. It defaults to false.
  • #77866: Workflow source in gh aw list --json. Tooling can now tell which workflows are managed from an upstream bundle.

Sub-Issue Closer is the scheduled workflow that closes a parent issue once all of its sub-issues are complete. It runs daily on the pi engine with copilot/gpt-5.

Over its last three scheduled runs (November 13, November 14, and November 15), it closed 30 parent issues and commented on each one. All of them were smoke-test tracking issues, such as “Smoke Copilot ARM64 - Issue Group.” Each run took 7 to 8.5 minutes, and all three succeeded.

Its closing comments are a handy audit trail, so if you rely on it, skim them now and then to confirm each parent really was finished.

Usage tip: Use a closer like this for work you track as sub-issues, and review the comments it leaves so you can trust what it closed.

→ View the workflow on GitHub

Review the breaking changes in v1.2.3, recompile your workflows, and tell us what you think. Feedback and contributions are welcome in github/gh-aw.