Eyes on the Pipeline

A GitHub Actions tool for AI agents

The Blind Spot

An agent can push code — then CI takes over and it goes blind

Agents already commit and push. But once a workflow starts running, they can't tell if the build passed, read the failing logs, or retry a broken run. This GitHub Actions tool restores that feedback loop.

So what actually ships to close the loop?

Proof

It's a real, wired implementation — not a sketch

Roughly 2,200 lines of Python expose exactly seven CI/CD operations, backed by a collected suite of 28 tests.

But restoring the loop means letting the agent act — and that's where it gets dangerous.

2,219

lines of Python in src

7

CI/CD operations

28

tests collected

611

lines across the 7 op modules

The Risk

Write access to CI/CD is exactly where things get dangerous

Four of the operations only read. But three of them act — triggering, canceling, and rerunning workflows. Give an agent those and an unguarded mistake can kick off the wrong run, or a deployment.

The mechanism has to answer that. Start with how the operations split.

The Seven Operations

Four safe reads to watch, three guarded writes to act

Reads let the agent see the pipeline; writes let it drive. The README numbers them exactly this way.

The writes are the dangerous half — so every one of them is gated.

4 Read Operations (safe)

list_workflowslist_runsget_runget_run_logs

3 Write Operations (safety checks)

trigger_workflowcancel_runrerun_workflow

Guardrails

Every write passes a repo allowlist — and deploys are blocked by default

check_write_operation always checks the repository allowlist (an empty list allows all). Deployment-looking workflows are blocked unless explicitly enabled.

Guarded to act — now the reading half, done without drowning in logs.

1Repo allowlist on every writecheck_write_operation always calls check_repository_allowed; empty allowlist = allow all
2Deploys blocked by defaultallow_deployment_triggers = False; a 6-keyword heuristic (deploy, deployment, release, publish, production, staging) raises DeploymentTriggerBlockedError
3Rate-limit aware, fails saferaises RateLimitError when remaining < 100; a failing rate-limit check is caught and logged, never blocks the op

Token-Efficient Debugging

get_run_logs returns only the failing lines an agent needs

Logs cap at 500 lines by default (max 2,000), with an optional failed-jobs-only filter. The truncator prioritizes errors instead of dumping everything.

Watch, guard, read — now the whole loop closes.

500

default log lines (max 2,000)

11

error patterns scanned

10

context lines kept per match

20

head & tail lines always kept

The Closed Loop

The agent now drives CI end to end — no human relay

Push, watch the run, pull only the failing lines, rerun the fixed job. The feedback loop that broke at CI is whole again.

That's the pattern worth keeping.

Push code to the repo
Watch the run with list_runs / get_run
Pull the failing lines with get_run_logs
Rerun the fixed job with rerun_workflow

The Takeaway

Give an agent guarded eyes and hands, and it stops being a blind code-pusher

Safe, typed, remediation-carrying access closes the agent's CI loop. Eleven exception classes — one base plus ten subclasses, each carrying remediation text — tell the agent exactly what to do next when something breaks.

A DevOps partner, not just a code-pusher.

Sources

Research Methodology

Data as of: 2026-01-21 (single commit c0e748e, branch main)

Feature status: Single-commit initial implementation; fully wired. 26/28 tests pass in this environment (2 fail only because no valid GITHUB_TOKEN is present).

Repository: amplifier-module-tool-github-actions — sole author Sam Schillace (ramparte@gmail.com), 1 commit.

Research performed:

Git history: git log --oneline -20; git rev-list --count HEAD (1 commit found)
Operation count: grep -n 'enum' schema.py; grep -n 'VALID_OPERATIONS' tool.py; ls operations/*.py
Read/write split: grep -n 'Read Operations\|Write Operations' README.md
Exceptions: grep -c '^class .*Error' exceptions.py; grep -c 'remediation=' exceptions.py
Log truncation: sed -n '13,28p;112,135p' log_truncator.py
Safety & guardrails: sed -n '37,73p' safety.py; grep 'allow_deployment_triggers' config.py
Line counts: find src -name '*.py' | xargs wc -l; wc -l operations/*.py
Tests: .venv/bin/python -m pytest --collect-only -q; .venv/bin/python -m pytest -q

Gaps: No .github/workflows CI config exists in the module; test results reflect local pytest runs, not a CI pipeline. The "5,000 requests/hour" figure appears only as a hard-coded string in RateLimitError remediation text, not measured against the live API.

Primary contributor: Sam Schillace — sole author of the only commit (100%).