AI Agent templates with Skills, Agents, and Workflows — now with Coordinator Mode, Persistent Memory, and Context Compression

AG Kit 2026.5.13 introduces 7 new skills, 3 new workflows, and a major orchestrator upgrade — informed by studying advanced AI agent architectural patterns. The result: 13-33% fewer tokens per session through smarter orchestration, persistent memory, and context compression.

• Token-efficient: 13-33% fewer tokens per session through memory, compression, and smarter prompts
• Cross-session memory: Never re-explain preferences, conventions, or past decisions
• Smarter orchestration: Parallel for read-only work, sequential for writes — with synthesis protocol
• Production-tested patterns: Distilled from advanced AI agent architectures (512K+ lines analyzed)
• Backward compatible: All v2 workflows, agents, and skills still work unchanged
• Self-improving: Skillify lets the system create new skills from repetitive tasks
• Better verification: /verify proves code works through execution, not inspection

• Larger .agent/ folder: ~40KB additional markdown files
• MEMORY.md overhead: ~1,000 tokens per session (but saves 3,000-10,000 by eliminating re-discovery)
• Coordinator complexity: Advanced orchestration patterns have a learning curve
• Frontmatter audit: All 45 skills now have when_to_use — needs periodic review
• Agent tool required: Coordinator patterns need model with agent/subagent tool support

• Non-breaking: All existing agents, skills, and workflows unchanged
• Additive: New features don't modify existing behavior
• Optional: Memory system and coordinator mode are opt-in per project
• Simple: ag-kit update to upgrade

npx @vudovn/ag-kit init

Or install globally:

npm install -g @vudovn/ag-kit
ag-kit init

This installs the .agent folder containing all templates into your project.

If you use AG Kit across many projects and don't want to copy-paste the .agent/ folder into every single one, you can use Symbolic Links (Symlinks) to reference a single global .agent folder.

1. Install it somewhere globally, e.g., ~/.ag-kit/

   mkdir ~/.ag-kit && cd ~/.ag-kit
   ag-kit init

2. Symlink it into your local projects:
   • Mac/Linux: ln -s ~/.ag-kit/.agent .agent
   • Windows (Command Prompt as Admin): mklink /D .agent C:\Users\YourUser\.ag-kit\.agent
   • Windows (PowerShell as Admin): New-Item -ItemType SymbolicLink -Path ".agent" -Target "C:\Users\YourUser\.ag-kit\.agent"

This way, updating your global .agent folder instantly applies the updates to all your projects.

If you are using AI-powered editors like Cursor or Windsurf, adding the .agent/ folder to your .gitignore may prevent the IDE from indexing the workflows. This results in slash commands (like /plan, /debug) not appearing in the chat suggestion dropdown.

Recommended Solution: To keep the .agent/ folder local (not tracked by Git) while maintaining AI functionality:

1. Ensure .agent/ is NOT in your project's .gitignore.
2. Instead, add it to your local exclude file: .git/info/exclude

If you work on many projects and don't want to duplicate the .agent folder for each one, you can keep a single .agent folder somewhere on your system and use Symlinks (Symbolic Links). This lets you update the kit in one place, and all your projects will automatically use the latest version.

1. Create a central folder: Install the Kit to a common location (e.g., ~/global-tools/.agent or C:\tools\.agent).

2. Link it to your project: Navigate to your project directory in the terminal and run:

Windows (Command Prompt as Admin):

mklink /D .agent "C:\path\to\global\.agent"

macOS / Linux:

ln -s /path/to/global/.agent .agent

This creates a lightweight folder shortcut. Your IDE and AI assistants will treat it as if the .agent folder is right inside your project!

The code-review-graph skill automates blast-radius mapping for your codebase (via Tree-sitter & SQLite). If it is installed globally via Pip/Pipx, AG Kit Agents will now intelligently auto-query it, dropping token usage massively on large projects:

(Note: The integration automatically ignores parsing small projects under 200 files since naive file-reading is cheaper at that size).

No need to mention agents explicitly! The system automatically detects and applies the right specialist(s):

You: "Add JWT authentication"
Agent: Applying @security-auditor + @backend-specialist...

You: "Fix the dark mode button"
Agent: Using @frontend-specialist...

You: "Login returns 500 error"
Agent: Using @debugger for systematic analysis...

How it works:

• Analyzes your request silently

• Detects domain(s) automatically (frontend, backend, security, etc.)

• Selects the best specialist(s)

• Informs you which expertise is being applied

• You get specialist-level responses without needing to know the system architecture

Benefits:

• ✅ Zero learning curve - just describe what you need
• ✅ Always get expert responses
• ✅ Transparent - shows which agent is being used
• ✅ Can still override by mentioning agent explicitly

Invoke workflows with slash commands:

Example:

/coordinate comprehensive security + performance review
/remember I prefer bun over npm
/verify the login endpoint handles expired tokens

Skills are loaded automatically based on task context. Each skill has a when_to_use field that helps the AI determine relevance — loading only what's needed instead of browsing all 45 skills.

Memory persists across sessions. The AI remembers your preferences, project conventions, and past decisions:

You: "/remember Always use TypeScript strict mode"
AI: ✅ Saved to memory: [project] TypeScript strict mode required

--- Next session ---
You: "Create a new util function"
AI: (silently applies strict mode, no need to re-tell)

ag-kit init --force        # Overwrite existing .agent folder
ag-kit init --path ./myapp # Install in specific directory
ag-kit init --branch dev   # Use specific branch
ag-kit init --quiet        # Suppress output (for CI/CD)
ag-kit init --dry-run      # Preview actions without executing

AG Kit 2026.5.13 was informed by studying advanced AI agent source code architectures, including patterns observed in production AI coding assistants. Architectural patterns and prompt engineering insights were analyzed and rewritten as original markdown-based skill templates. No external code was copied — all skills are original implementations.

Key patterns distilled:

• Coordinator mode: Multi-agent orchestration with parallel workers and synthesis protocol
• Persistent memory: MEMORY.md index with topic files and 4-type taxonomy
• Context compression: Auto-compact, micro-compact, and phase summarization
• Conditional skill loading: when_to_use frontmatter for intelligent skill activation
• Worker prompt synthesis: "Never delegate understanding" protocol

• Web App Example - Step-by-step guide to creating a web application
• Online Docs - Browse all documentation online

- or -

MIT © Vudovn