Agentic Automation in Developer Workflows

Developer tooling crossed a threshold in 2025–2026. AI assistants no longer just suggest the next line: they propose multi-file edits, run terminal commands, open pull requests, and iterate until tests pass — or until they hallucinate success. This is agentic automation: systems that plan, act, observe, and replan inside your repository.

Three names dominate the serious conversation: Google Antigravity CLI (agy) — terminal successor to Gemini CLI with a harness shared with Antigravity 2.0; Hermes Agent from Nous Research — MIT open source agent stack with a real hermes CLI; GitHub Copilot workspace — agentic issue-to-PR flow inside the GitHub ecosystem.

The Automation Spectrum

Antigravity, Hermes, and Copilot workspace operate primarily at Levels 3–4. The productivity upside is real; so is the risk surface.

Common Architecture of Coding Agents

Despite different branding, internal structure converges:

1. LLM core: Gemini (Google), Hermes/Nous models, GPT-4.x (Microsoft) — routing, fallback, context window
2. Agent harness: plan → act → observe loop; session memory and tool registry management
3. Tool layer: filesystem read/write, grep/search, terminal, browser, git, sometimes MCP servers
4. Context builder: relevant file selection, repo summarization, respect for .gitignore and policy
5. Output sink: diff in IDE, git branch, GitHub pull request

The harness is the real product. The model changes every quarter; agent loop quality (when to stop, how to handle tool errors, how to avoid spirals) determines whether the tool is usable in production or just an impressive demo.

Google Antigravity CLI (agy)

Google's Antigravity platform — including Antigravity 2.0 — provides an agent harness: model routing, tool definitions, filesystem access, session memory. The Antigravity CLI, invoked as agy, is the legitimate terminal successor to the previous Gemini CLI for developers who live in shell and IDE rather than web UI.

Key features

• Shares the same agent harness as Antigravity 2.0 — skills learned in IDE transfer to CLI sessions
• Terminal-native workflow: clone repo, launch agy, describe task, watch tool calls execute
• Deep integration with Google model lineup (Gemini family and successors) and Google Cloud identity for enterprise teams
• Designed for multi-step coding tasks — refactor, test fix, dependency upgrade — not single-line completion

# Illustrative session (exact flags vary by release)
agy

> Fix the failing auth test in packages/api and run the test suite

# The agent might:
# 1. grep "auth" in tests
# 2. read source and test files
# 3. apply patch
# 4. run npm test
# 5. iterate if it fails

Workflow integration

GCP-centric teams benefit from SSO, audit logs, and org policy. Enterprise adopters should enforce: feature branches only, no direct commits to main, CI required, logging of every tool invocation for audit.

Hermes Agent (Nous Research)

Hermes Agent from Nous Research is an MIT open source agent framework for developers who want model choice and self-hosting options. The CLI binary is hermes — not a fictitious hermes init copied from other tools.

Real installation

# Install via official curl script (verify current URL in Nous docs)
curl -fsSL https://install.nousresearch.com/hermes | sh

# Initial configuration wizard
hermes setup

# Model selection / endpoint configuration
hermes model

After setup, interactive sessions go through hermes with tool access to the workspace — similar in spirit to other agent CLIs but with emphasis on the Nous model ecosystem (Hermes fine-tunes and OpenAI-style compatible endpoints).

Why teams choose Hermes

• MIT license — inspect, fork, modify the agent loop
• Model flexibility — point to Nous-hosted models or local/cloud endpoints via hermes model
• Research-friendly — Nous Research publishes open weights; Hermes Agent is the operational layer on top
• Self-hosting — ability to keep code and inference on a private network

Typical session

hermes

> Add input validation to the REST endpoint in api/routes/sensors.py
> Run pytest tests/test_sensors.py after changes

GitHub Copilot Workspace

Microsoft's Copilot workspace starts from an issue or natural language brief and generates an implementation plan, branch, code changes, and pull request — all inside GitHub's permission and review model.

• Issue-native: "Implement rate limiting on /api/v2" starts from the ticket developers already use
• Plan before code: Workspace shows a step list for human approval before massive diffs land
• PR-centric output: Fits existing code review culture — agents propose, humans dispose
• Enterprise controls: Org policy, audit log, Copilot Business/Enterprise data handling applied
• Actions integration: Existing CI pipeline validates agent output automatically

Copilot workspace shines when workflow already lives in GitHub Issues and Actions. Less attractive for monorepos on GitLab or fully air-gapped environments.

Tool Comparison and Selection

• Google / GCP shop: Antigravity CLI (agy) — unified harness, Gemini models, enterprise identity
• Open source / custom model preference: Hermes — MIT, curl install, hermes setup and hermes model
• GitHub-centric delivery: Copilot workspace — issue to PR without leaving github.com
• Many teams use two: IDE agent for daily work, workspace or CLI for batch issue grinding — same guardrails everywhere

Concrete Use Cases

Scoped bug fix

Test fails due to known regression. Agent reads stack trace, locates file, proposes minimal patch, reruns test. Human verifies fix does not introduce architectural debt.

Feature boilerplate

New CRUD endpoint with pattern already used in repo. Agent replicates existing structure (controller, schema, test). Human review on input validation and auth.

Dependency migration

Major library upgrade with documented breaking changes. Agent applies codemod, fixes compile errors iteratively. Human verifies edge cases not covered by docs.

Documentation and comments

Docstring generation, README section, ADR draft. Low risk if reviewed for technical accuracy.

Maker projects (BVRobotics)

Refactor firmware deploy scripts, generate sensor driver stubs, fix Python test suite on IoT modules — well-delimited tasks with existing tests where agents excel.

Guardrails That Actually Work

1. Branch protection: Agents push to feature branches; merge requires human approval and green CI
2. Sandboxed execution: Container or VM for agent shell access — never raw production credentials
3. Secret hygiene: Pre-commit hooks, GitHub secret scanning, rules blocking .env from agent context
4. Scope limits: Production read-only; write access only on dev clone
5. Test gates: Agent cannot mark task "done" without passing defined test commands — but verify tests were not weakened
6. Human review checklist: Architecture fit, security implications, test quality, diff size — not just "CI is green"
7. Tool call rate limit: Prevent infinite loops that burn tokens and modify hundreds of files
8. Audit trail: Log of every command executed by the agent for incident post-mortem

An agent that passes tests but deletes observability hooks or bypasses auth checks is worse than no agent. Review for intent, not just green badges.

Failure Modes to Expect

• False completion: Agent reports success while tests were skipped or incorrectly mocked
• Dependency drift: Unpinned upgrade breaking reproducible builds
• Context rot: Long sessions where agent forgets constraints stated at the start
• License contamination: Copy-paste from training data with incompatible licenses
• Rubber-stamp review: Humans approving unread 2000-line diffs — fastest path to incident
• Over-engineering: Agent adds unrequested abstraction layers to "complete" task

MCP Integration and Extended Tools

Modern agent harnesses — including those Antigravity and Hermes converge on — increasingly support Model Context Protocol (MCP) servers: read-only databases, documented APIs, issue trackers, CI status. For BVRobotics teams already using MCP for documentation and GitHub, agents can invoke the same servers with explicit permission constraints.

Safe pattern: MCP server in container with scoped credentials (read-only DB, repo clone without push). Agent reads context; writes always go through git branch + PR review.

# Conceptual example: agent with MCP GitHub read + local filesystem write
# 1. MCP: fetch issue #42 description
# 2. agy/hermes: plan implementation steps
# 3. Tool: edit files in workspace clone
# 4. Tool: run local test suite
# 5. Git: commit + push feature branch
# 6. Human: open PR, review, merge

Metrics and Honest ROI

Measuring agentic automation requires discipline. Useful metrics:

• Time-to-PR for issues tagged "agent-eligible" vs human baseline
• Revert rate on agent-generated PRs — high revert = insufficient guardrails or scope too broad
• Human review time — if agent produces huge diffs, dev savings get eaten by review
• Incident correlation — track if production bugs correlate with agent merge without thorough review

Positive ROI comes when agents handle verifiable grunt work (test fix, lint, boilerplate) and humans focus on architecture and security review — not when agents replace critical thinking.

Outlook 2026–2027

Likely convergence: shared agent harness between IDE and CLI, centralized org policy, MCP integration as de facto standard. Teams investing today in guardrails and review culture — not "automatic merge" — will be ready when agent capability grows without proportionally increasing incident risk.

Conclusions

Agentic automation is no longer vapor — agy, hermes, and Copilot workspace are real, usable tools with distinct ecosystems. They compress the gap between ticket and PR, especially for scoped bugs, test repair, and boilerplate features.

They do not replace engineering judgment. Install Hermes with the real curl script, configure models with hermes model, run Antigravity on protected branches, and treat every agent PR like a junior contributor's first submission: promising, but never merge-on-trust. Winning teams treat agents as accelerators inside a review culture that already worked — not an excuse to skip it.

Sources

• Google Antigravity / Gemini Developer Docs — ai.google.dev
• Nous Research — nousresearch.com
• Hermes Agent (GitHub) — github.com/NousResearch/hermes-agent
• GitHub Copilot workspace — github.com/features/copilot
• GitHub Docs — Responsible use of Copilot — docs.github.com/en/copilot