Build Production-Grade AI Agents with Context Engineering Skills

Most agent skill collections throw more skills at the same problems: more prompts, more tools, more model calls. This collection from muratcankoylan attacks the actual failure mode of production agents: context that degrades over long horizons, memory that loses track, tools that conflate concerns, and harnesses that don't measure their own performance. 17 skills, organized into the patterns every serious agent system eventually needs.

Why This Skill Matters

Agent failure in production is rarely about the model — it's about context. The "context engineering" framing is recent vocabulary for an old problem: as the agent runs, context fills up, gets compressed poorly, loses critical details, and decisions silently degrade. This collection codifies the patterns that handle each of those failure modes:

• Foundational (3 skills) — what context actually is, how it degrades, how to compress it.
• Architectural (6 skills) — multi-agent patterns, long-horizon prompting, memory systems, tool design, filesystem-based context, hosted agents.
• Operational (6 skills) — context optimization, latent briefing, harness engineering, evaluation, advanced evaluation, self-improvement loops.

For anyone building an agent that runs longer than a single chat, this is the skill set the agent itself should be carrying.

Installation

For Claude Code:

/plugin marketplace add muratcankoylan/Agent-Skills-for-Context-Engineering
/plugin install context-engineering@context-engineering-marketplace

For other agent hosts, follow the same marketplace pattern your host uses (Codex, Cursor, Windsurf each have their own install path — see your host's documentation).

Real Workflow: Build a Multi-Agent "X-to-Book" System

A realistic scenario, not "hello world": monitor X accounts you care about, and have a multi-agent pipeline turn their posts into a synthesized daily book.

The workflow:

1. Activate multi-agent-patterns to design the agent topology.
2. Activate memory-systems to define what each agent remembers.
3. Activate context-optimization to keep the long-running context lean.
4. Activate tool-design to scope each agent's tool surface narrowly.
5. Activate evaluation to measure whether the synthesized book actually matches the source posts.

Prompt your agent:

Build a daily X-to-book system: monitor N accounts, deduplicate posts,
group by theme, draft a chapter per theme, and produce a synthesized book.
Use multi-agent-patterns, memory-systems, context-optimization, tool-design,
and evaluation. Output the chapter drafts and an evaluation report.

Expected output: a structured pipeline description (which agent owns what), a memory layout (what's retained where), tool definitions scoped per agent, and a measurable evaluation report — for example:

Daily run, 2026-08-17
  posts: 184 across 6 accounts (deduplicated: 142)
  chapters: 7
  evaluation:
    thematic-coverage: 0.92  (target ≥ 0.85)
    source-fidelity:    0.88  (target ≥ 0.80)
    length-appropriateness: 0.79 (target ≥ 0.75, flag)

The evaluation skill is what makes this different from a generic multi-agent sketch — every chapter has measurable quality, not vibes.

Real Workflow: Diagnose a Degrading Long-Running Agent

A realistic scenario: your agent does great for the first 30 minutes, then decisions get worse and you can't tell why.

The workflow:

1. Activate context-degradation to identify the failure mode.
2. Activate context-compression to fix compression policy.
3. Activate context-optimization to slim what stays in context.
4. Activate self-improvement-loops to capture the failure so it doesn't repeat.

Prompt your agent:

This agent has been running 2 hours and decisions degraded in the last
30 minutes. Use context-degradation to diagnose, context-compression to
fix the compression policy, context-optimization to slim the kept context,
and self-improvement-loops to capture the failure mode so it doesn't
recur on the next long run. Output a before/after report.

Expected output: a diagnostic with the specific degradation pattern (e.g. "instructions lost prominence after compression round 4"), a compression policy change, and a recorded failure-to-avoid list. This is what context engineering actually looks like in practice — not prompt tricks, but engineered behavior over time.

Tips

• Install foundational skills first. The three foundational skills (context-fundamentals, context-degradation, context-compression) are the base. Architectural and operational skills are most useful once those are loaded.
• Pair evaluation with anything you ship. Without evaluation, the multi-agent patterns are toys. With it, they're measurable.
• Use self-improvement-loops on every long-running agent. Manual postmortems don't scale; the loop captures and feeds back.
• Re-read tool-design whenever a tool surface grows. The most common long-running failure is tool creep — agents that have too many tools make worse decisions.

When Not to Use This

• You're building a single-shot agent. If your agent runs once per request with no long-horizon behavior, context engineering adds complexity for no gain.
• You don't measure outcomes. Evaluation is the spine of this collection. Without it, the skills will give you better architecture but no proof it's better.
• You want a turnkey agent framework. These are skills, not a runtime. You'll combine them with your own harness — and you'll need to understand what your harness is doing.

See the leaderboard for more skills.