Blog

Agent of the Day – November 12, 2026

Some workflows fail with a stack trace. Others fail on a schedule, every morning, with nothing to show for it. This week’s spotlight is a workflow that has now missed three daily runs in a row, and the audit of its latest run tells a more useful story than the red X does.

Agent of the Day: Daily A/B Testing Advisor

Section titled “Agent of the Day: Daily A/B Testing Advisor”

Daily A/B Testing Advisor runs on a daily schedule around 10:00 UTC on the Codex engine. It is built to produce A/B testing advice and to open pull requests with the [ab-advisor] title prefix, up to two per run. This is its first time in the spotlight.

Three scheduled runs have completed, and none succeeded:

RunStarted (UTC)DurationResult
43200335556Nov 12, 10:2627.7 minfailure
43003579140Nov 11, 10:2625.7 minfailure
42799062363Nov 10, 10:257.5 minfailure

Across the three runs, the log summary reports zero successful runs, zero safe outputs, about 366 AIC, roughly 19 million tokens, and 62 Actions minutes. Each failure was classified as a driver exit, and the failure cluster points at the conclusion job’s “Handle agent failure” step.

The structured audit of the November 12 run adds detail:

  • The agent reported its own failure. It called safeoutputs.report_incomplete at 10:49:52 UTC. The runner then recorded the error as Agent reported that it could not complete the task.
  • The firewall blocked no observed requests. It observed 292 requests with zero blocked. That rules out a recorded firewall-policy rejection, not other network failures such as TLS or DNS errors, timeouts, API errors, or rate limiting.
  • Token use was flagged. The audit marked the run for high token usage (about 7.4 million tokens) and for resource use heavy for its domain.
  • Two public issues were withheld. The GitHub MCP integrity filter kept github/gh-aw#77074 and github/gh-aw#77021 from the agent because their integrity level was below “approved”. The filter did what it is meant to do. We did not open either issue for this post, so we make no claim about whether they relate to this failure.

We can say with confidence that three consecutive scheduled runs failed and that the agent itself concluded it could not finish. The November 12 run logs give us a more specific lead: the campaign’s focused workflow compilation and both variant-rendering checks passed, but the required repository-wide make recompile gate failed when npm package validation hit DEPTH_ZERO_SELF_SIGNED_CERT for packages used by unrelated workflows. The agent stopped before opening a pull request.

That points to certificate trust during package-registry validation as the immediate blocker visible in the logs. It does not establish why the certificate was untrusted, nor does the firewall’s zero-blocked count rule out other network problems.

A daily workflow that fails quietly burns compute every morning and produces nothing. Here is the happy ending the evidence supports: the focused campaign checks passed, and the broader validation gate caught an environment-level certificate problem before an unvalidated change could be published. The workflow reported the blocker and left the repository unchanged. Once the package-feed certificate trust is repaired, a future run can repeat the full gate; until then, this is a safe stop, not a successful run.

If you maintain a scheduled agent, check whether its conclusion job reports failures somewhere a human will see them, and whether its token budget matches what the workflow actually needs.

Want to see how gh-aw turns a markdown file into a monitored, auditable workflow? Start at github/gh-aw.

Connectors: A Clear Integration Point for Services

Every service integration has to answer the same questions: where does the service live, how does authentication work, and what can a workflow do with it?

Without a clear integration point, those answers end up scattered across scripts, custom tools, and prompts. Each new service becomes another special case.

The new experimental connectors give services a shared integration point in GitHub Agentic Workflows. A declarative YAML definition describes the service contract. gh-aw’s compiler and runtime use that contract to expose selected capabilities to workflows.

The goal isn’t a different integration mechanism for every provider. It’s one place to define how a service fits into gh-aw.

A connector brings the pieces of an integration together: fixed endpoints, credential routes, resource grants, read capabilities, and safe outputs. It can describe bounded REST or GraphQL readers, read-only HTTP MCP tools, and typed mutations. Trigger declarations use the shared webhook gateway path rather than inventing a separate dispatch mechanism for each service.

The provider-specific details live in the declaration. The compiler and runtime supply the common machinery for validation, tool exposure, and safe-output execution. Adding a supported operation is a declaration change, not a reason to build a new provider-specific execution path.

That also makes the integration reviewable. A new endpoint, a different secret reference, or an added write operation is visible in a diff. The contract can be versioned and reused alongside the workflows that consume it.

In gh-aw, connector YAML lives in the frontmatter of an importable Markdown file under .github/workflows/connectors/. Here’s a short excerpt from the Linear declaration:

connectors:
linear:
experimental: true
endpoints:
api: https://api.linear.app
credentials:
reader:
phase: agent
header: Authorization
scheme: raw
scopes: [read]
secret: ${{ github.aw.import-inputs.reader-secret }}
resources:
issues: ${{ github.aw.import-inputs.issues }}

The shape matters more than the provider: a named endpoint, an explicit credential phase, and resource bindings supplied by the consuming workflow. Secret values stay in GitHub Actions secrets.

This isn’t a complete connector. The full declaration adds typed operation inputs, request mappings, response limits, resource checks, and import input definitions. Its commented documentation explains setup and provider-specific limits.

Linear, Jira, Azure DevOps, Slack, Teams, and other services already have declarations using this shared model. Their capabilities differ, but they have a common place to plug in.

The connector defines what’s available. The workflow selects what it needs. Importing alone enables no provider tools or writes.

Reads go under tools; mutations are selected separately under safe-outputs, outside the agent’s writer-credential boundary. Resource bindings constrain access, and IDs returned by the service don’t expand those grants.

For example, the Linear triage workflow selects two readers and one staged comment. Another workflow can consume the same declaration with different selections and approved resources. Staging previews the write without delivering it; reads remain live.

The service contract is reusable. The authority stays specific to the task.

Connectors are experimental, and they aren’t turnkey service installations. Declarations don’t provision credentials, install webhook receivers, or turn scope metadata into provider permissions. Start with a connector-capable compiler and matching runtime, a reviewed source revision, manual dispatch, and staged outputs.

If you’re bringing a service into gh-aw, start with the connector reference or the create-connector skill. The example catalog shows how workflows consume the contract.

Define the service once, in YAML. Let workflows choose the capabilities they need. Keep integration behavior in a clear, reviewable place.

Ecosystem Spotlight: elastic/oblt-aw

Wiring an agentic workflow by hand into every repository works for one repository and falls apart at fifty. elastic/oblt-aw is an opinionated framework for GitHub Agentic Workflows that addresses this directly: shared, reusable routes live in one repository, small “client” workflows are installed automatically into consumer repositories, and a control plane decides whether each agent is allowed to run. It is aimed at platform and developer-productivity teams that need to roll out, tune and switch off agents across many repositories without chasing each one.

Thin clients, central logic. Consumers hold only narrow-trigger files such as trigger-obs-aw-pull-request.yml, each of which calls an event-scoped orchestrator in the framework repository. The client template doc explains the split-trigger design: only the routes that match the GitHub event run, which keeps pull requests quiet. Improving an agent means changing it once in oblt-aw.

A checkbox dashboard as the on/off switch. Each repository gets a single pinned issue, [oblt-aw] Control Plane Dashboard, with one task-list entry per workflow. The get-enabled-workflows workflow reads it with only contents: read and issues: read, and the rules are fail-closed: no open dashboard issue means no gated workflow proceeds. Repository owners get a self-service control with no config file to edit. The dashboard guide describes the flow.

A shared prelude, enforced by CI. aw-prelude runs once per event family. It reads the dashboard, optionally loads bot allow lists for pull request and issue authors, and emits a proceed-by-workflow map. A validation script (validate_aw_workflow_prelude.py) checks that every route declares the shared-proceed input, so a new workflow cannot quietly skip the gate. A matching check covers aw-resolve-agentic-assets, which merges platform instructions with a consumer’s optional apm.yml so repositories can tailor an agent without forking it.

Multi-organization ownership. Per-organization configuration lives under config/<org-key>/, and checkboxes use compound ids like org:workflow-id. The multi-org design lets several teams share one catalog while a repository still sees one dashboard grouped by owner. A maturity model (stable, early adoption, experimental) labels each workflow so adopters know what they are opting into.

A release train with rollback. The release model separates development repositories, which follow @main and act as live canaries, from production repositories, which are pinned to a moving major tag. Promotion is a manual dispatch that runs the end-to-end suite first, then pushes an immutable audit tag and updates config/release-pointers.json. Rollback retargets the tag to the previous commit. The docs also record fail-closed rules: distribution will not write a pin for a tag that is missing on origin.

  1. A repository is listed in its organization’s active-repositories.json.
  2. The distribution workflow opens pull requests that install the client templates, substituting the right pin for the repository’s pin-class. If two organizations would install different files at the same path, it stops with an explicit conflict.
  3. A sync job creates or updates the dashboard issue.
  4. When an event fires, the client calls its orchestrator, the prelude evaluates the gates, and enabled routes run an agent, resolving instructions first through the assets workflow.

Reusable agents that are called across repositories have one extra requirement. Elastic’s sibling project docs-actions documents that cross-repository workflow_call use depends on inlined-imports: true, so the compiled lock file is self-contained. That detail is easy to miss and worth copying if you publish reusable agents.

oblt-aw is tailored to Elastic’s organizations, so treat it as a reference architecture rather than a drop-in package. The patterns transfer well:

  • Keep consumer workflows tiny and call a pinned reusable workflow centrally.
  • Use an issue with checkboxes as a fail-closed, auditable enablement switch.
  • Add a CI check that every agent route honors the gate.
  • Separate canary repositories (@main) from production (@v0), and rehearse rollback.

For a smaller example of the same idea, elastic/docs-actions publishes reusable documentation agents with example.yml caller templates and a table of the safe outputs each workflow may use.

Explore elastic/oblt-aw, starting with its README and architecture overview, and see what a governed fleet of agents looks like. To build your own, start with GitHub Agentic Workflows.

Agent of the Day – November 9, 2026

Codebases rarely collapse in one commit. They drift: a file gains a few hundred lines, a function picks up one more branch, a package exports one more symbol. Today’s spotlight goes to the workflow that watches for that drift.

Architecture Guardian analyzes commits from the last 24 hours and looks for code structure violations in Go and JavaScript files: large files, oversized functions, high export counts, and import cycles. It runs on a schedule, around 14:00 UTC on weekdays, and can also be dispatched manually.

Its permissions are read-only (contents: read, actions: read), which suits a reviewer whose job is to observe and report.

Today’s scheduled run, 42632762703, started at 14:14 UTC on main and finished successfully in about 7 minutes. A structured audit of the run reports:

SignalValue
Conclusionsuccess
Turns1
Tool types2
Errors / warnings0 / 0
Token usage~104k
Execution styledirected, read-only

The audit labels the execution path “directed”: one linear turn, a narrow set of tools, no writes. The one flag it raised was medium-severity high token usage, a reminder that scanning a day of commits for structure has a real cost, and a useful number to watch over time.

The same day’s scheduled fleet included Dead Code Removal Agent, PR Sous Chef and Daily Fact. In this run the audit shows no issue or pull request was created, so there is nothing to link beyond the run itself.

Combined workflow activity chart

Structural checks are easy to postpone and hard to retrofit. Running them daily, against only the newest commits, keeps feedback close to the change that caused it.

Browse the workflow source, copy the pattern, and build your own guardian at github/gh-aw.

Weekly Update – November 9, 2026

Two releases landed in github/gh-aw this week, with a focus on durability, observability, and security. Here’s what you can use today.

v1.2.1 (November 6) focuses on workflow durability, safer updates, and broader engine and auth support.

  • Durable workflow continuation (#75097): Artifact-backed continuation lets work carry across agents.
  • Specification-aware PR reviewer (#75207) and an experimental Atomic declarative engine (#75196).
  • Smarter create-issue (#75323, #74941): Issue artifacts and label-scoped title deduplication.
  • GitHub App auth for repo-memory (#74937) and deployment controls on workflow environments (#74938).
  • Safer updates (#74948, #74945): gh aw update preserves source refs, frontmatter comments, and formatting.
  • Security reviews fail closed when unresolved (#75335), and a new warning flags dynamic checkout refs (#74951).

v1.2.0 (November 4) is a security and observability release.

  • Breaking: pull_request_target forks now require explicit opt-in for unrestricted use (#74884). Review fork-facing workflows and add the opt-in where intended.
  • Breaking: the -l shorthand was removed from project new (#74561).
  • OpenTelemetry: opt-in OTLP session logs (#74599) and dependency-free OTLP protobuf support for Azure Monitor (#74594).
  • Hardening: bounded ZIP extraction (#74906) and stricter run-step expression sanitization (#74793).
  • #75995 replaces the Pi durable runtime with native session chaining.
  • #75927 adds OpenAI workload identity federation for Codex.
  • #75988 supports name-based artifact upserts in update-issue.

Agent of the Week: PR Specification Reviewer

Section titled “ Agent of the Week: PR Specification Reviewer”

It reviews PRs for conformance and updates specifications on the PR branch so implementation and specs stay aligned.

It was just promoted in v1.2.1, and the logs show it busy: in its three most recent runs it was triggered on pull requests within about an hour of each other. Two finished successfully (about 7 minutes each), each in a single turn.

The third run failed after 26 seconds, so even the spec police occasionally trip on the way in.

Usage tip: Scope a reviewer like this to paths that matter (pkg/**, specs/**) so it runs only when specs could drift.

→ View the workflow on GitHub

Upgrade to v1.2.1 and check the pull_request_target opt-in from v1.2.0. Feedback and contributions are welcome in github/gh-aw.