Agentics Framework

An AI agentics framework for building multi-agent systems focused on software engineering, datascience research, and personal knowledge management. Built for Claude Code and Claude Agent SDK, with support for other agentics platforms like OpenCode and Cursor.

The Problem

Building robust multi-agent systems is challenging:

• Inconsistent agent definitions - Each agent defined differently across projects
• Skill duplication - Writing the same capabilities for different agents
• Workflow complexity - Orchestrating commands and agents is ad-hoc
• Limited extensibility - Hard to add custom skills and MCP servers

The Solution

This framework provides a standardized system for:

• Standardized Agent Definitions - Consistent structure for defining specialized agents
• Reusable Skill Library - Build skills once, use across multiple agents
• Command Workflow Automation - Chain commands and agents for complex workflows
• Custom Skills & MCP Servers - Extend agents with custom capabilities and MCP integrations

Architecture

The framework is built on the ARD design pattern:

• Abstract - Take existing methods and abstract them to understand underlying frameworks and context from user input
• Refactor - Modularize and reorganize ideas from abstraction
• Derivative - Derive new specialized variations from existing ideas

Core Components

The framework has three essential building blocks that work together:

1. Agents (/agents)

Specialized AI agents with defined roles and capabilities. Each agent is a prompt template with specific expertise (e.g., architect, developer, analyst, tech-writer, etc.). These are the primary abstractions users work with.

Examples:

• architect.md - Architecture and design decisions
• dev.md - Software development and coding
• analyst.md - Data analysis and research
• tech-writer.md - Documentation and technical writing
• pm.md - Project management
• ux-designer.md - UI/UX design
• sm.md - Scrum/agile management
• agent-dev.md - Building custom agents

2. Commands (/commands)

Reusable Claude Code commands that orchestrate agents and define workflows. Commands are executed via Claude Code and can chain multiple agents together.

Core commands:

• prime.md - Understand a codebase quickly
• quick-plan.md - Create rapid implementation plans
• build.md - Execute implementations
• meta-prompt.md - Generate new command prompts
• load_ai_docs.md - Load documentation context
• parallel_subagents.md - Orchestrate multiple agents in parallel

Expert commands (/commands/experts)

• plan.md - Create detailed implementation plans
• build.md - Execute plans with expert guidance
• plan-build-improve.md - Complete workflow with continuous improvement
• self-improve.md - Update expertise based on learnings

3. Skills (/skills)

Reusable capabilities that agents can use. Skills are MCP servers, tools, and utility functions that extend agent capabilities.

Examples:

• Custom MCP servers for domain-specific tasks
• Tool definitions for agent use
• Integration skills for connecting to external systems

Project Structure

agentics/
├── agents/                 # Agent definitions
│   ├── architect.md
│   ├── dev.md
│   ├── analyst.md
│   └── ... (other agents)
├── commands/              # Command workflows
│   ├── prime.md
│   ├── quick-plan.md
│   ├── build.md
│   └── experts/          # Expert command variants
└── skills/               # Reusable skills & MCP servers
    └── meta-skills/

Project-specific workflows and templates are built outside these core folders in your project directory.

Getting Started

Installation & Setup

1. Clone this repository to your _ard folder or relevant configuration directory:

   git clone <repo> ~/_ard/agentics

2. Symlink to your projects - Link the framework into your project directories:

   ln -s ~/_ard/agentics/agents ./project/_ard/agents
   ln -s ~/_ard/agentics/commands ./project/_ard/commands
   ln -s ~/_ard/agentics/skills ./project/_ard/skills

3. Use in Claude Code - Reference agents and commands in your Claude Code workflows

Your First Agent

1. Start with the prime command to understand your codebase:

   /prime

2. Create a plan using quick-plan:

   /quick-plan

3. Execute with the appropriate agent (architect for design, dev for implementation, etc.)

Creating Custom Agents

Use the agent-dev.md agent or meta-prompt command to create new specialized agents:

/meta-prompt "Create a [Role] agent that handles [Responsibility]"

Creating Custom Skills

Define custom skills in the /skills directory following the established patterns. Skills can be:

• MCP servers
• Tool definitions
• Integration wrappers

Platform Compatibility

• Primary: Claude Code & Claude Agent SDK
• Compatible: OpenCode, Cursor, and other agentics platforms (with adaptations)

Current Status

Internal/Experimental - This framework is actively being developed. It's suitable for internal use and early adopter feedback, but not yet production-ready for external distribution.

Next Steps

• [ ] Define each agent's specific capabilities and use cases
• [ ] Build a comprehensive skill library with examples
• [ ] Create workflow templates for common scenarios
• [ ] Document best practices for extending the framework
• [ ] Add examples and sample projects

Contributing

For internal development:

1. Create new agent definitions in /agents
2. Add commands in /commands
3. Extend skills in /skills
4. Follow the ARD pattern for consistency