Partnership-first patterns for AI agents

Three paths to agents that learn.

Agentic DevOps is for teams building with AI agents as collaborators, not automation. From CVE remediation skills to the feedback loop that makes every run start smarter.

What persists when the model changes, the tools evolve, and the platform shifts? The feedback loop. The institutional memory. The partnership between humans and agents.

$copilot plugin install ember@awesome-copilot

Find your path

Or point any agent at a skill file below. They're just markdown, so they work anywhere.

Don't read docs. Load a skill.

These aren't guides for you to read.

They're skills for your agent to read. Load one, tell the agent what you're working on, and build together. Start with the one that sounds like your week.

Start here

Before anything else

The Partnership Framework

Agents produce useful signals only when the interaction makes honesty safe. Without it, confidence is always 5 and what_was_hard is empty. Read this first.

Read the framework

"I have a CVE hitting my repos"

`build-cve-skill`

Pull your fix expertise into a skill a cold agent can execute across your whole fleet. Any language, any ecosystem.

Build a CVE skill

"I own the library / I write the advisory"

`build-agent-first-advisory`

Write documentation that IS the fix, agent-executable, so developers using your library never need a separate skill at all.

Write an advisory

"I inherited a skill, is it still current?"

`check-agent-drift`

An evidence-based audit across five dimensions that scores the drift and ranks the highest-leverage fixes. Model-agnostic, so it survives the next frontier move.

Audit for drift

"I want agents to learn from every session"

Agent Signals

The open protocol for capturing agent reasoning, self-assessment, and outcomes. Skills are the input, signals are the output. Together they close the loop.

Explore the protocol

"I'm the switchboard between too many tabs"

The Workshop

Run a room of agents on one shared bench, each with its own memory, so you direct a team instead of relaying between them.

Open the workshop

The pattern

A CVE drops. The knowledge compounds.

The skill is institutional memory. The signal is the feedback loop. Put them together and the system gets smarter with every run.

A CVE drops. The clock starts across every affected repo.

The developer who knows the fix writes a skill. 30 to 60 minutes, once.

Test against one repo. Prove the pattern before it scales.

Run across the fleet. The same expertise, applied everywhere at once.

Humans review and merge. Judgment stays where it belongs.

Agent signals capture what worked and what was hard. The struggle becomes data.

The next run starts smarter. Every skill update includes what the agent learned.

Retire when clean. The knowledge stays in the repo, not in someone's head.

Skills Institutional memory

When the developer who figured out the fix switches teams, the knowledge doesn't leave with them. It's a markdown file in a repo.

Signals The feedback loop

When the agent struggles with a pattern the skill doesn't cover, the signal captures it. The next update includes what the agent learned. The system compounds.

What's here