# What Are the Core Components of AG-Kit? A Deep Dive into the Modular Architecture

> Explore the core components of AG-Kit Discover Agents, Skills, Workflows, Rules, and Runtime. Understand its modular architecture and how it's organized.

- Repository: [Vũ Đỗ/ag-kit](https://github.com/vudovn/ag-kit)
- Tags: deep-dive
- Published: 2026-07-29

---

**AG-Kit organizes its architecture into five tightly-coupled pillars—Agents, Skills, Workflows, Rules, and the Antigravity Runtime Layer—each defined by Markdown front-matter, generated manifests, and runtime contracts under the `/.agents/` directory.**

AG-Kit is a modular Antigravity workspace engineered by the `vudovn/ag-kit` repository to provide a version-controlled environment for AI-agent orchestration. Understanding the core components of AG-Kit is essential for developers who want to leverage its 20 specialized agents, 47 reusable skills, and 13 slash-command workflows within a reproducible CI/CD pipeline.

## The Five Pillars of AG-Kit Architecture

### Agents (Role-Based AI Personas)

Located in `.agents/agent/`, the **20 specialized agents** include personas such as `frontend-specialist`, `backend-specialist`, and `orchestrator`. Each agent is defined by Markdown front-matter that establishes its runtime contract, execution permissions, and coordination capabilities for task delegation.

### Skills (Reusable Knowledge Modules)

The **47 skills** reside in `.agents/skills/` and provide domain-specific knowledge that agents load on-demand. Every skill includes a **`when_to_use`** rule enabling conditional loading based on task context, allowing agents to dynamically assemble their toolset without hard-coding dependencies.

### Workflows (Slash-Command Procedures)

Found in `.agents/workflows/`, the **13 workflow definitions** expose slash-command interfaces such as `/plan`, `/debug`, and `/deploy`. These procedures trigger reproducible pipelines that route requests to appropriate agents and auto-load required skills to complete complex multi-step operations.

### Rules (Governance and Constraints)

The **6 rule files** in `.agents/rules/` establish safety, routing, and design constraints that govern how agents, skills, and workflows interact. These constraints ensure compliance with organizational policies and prevent unauthorized operations across the Antigravity workspace.

### Antigravity Runtime Layer (Execution Engine)

The runtime layer consists of the **[`antigravity.json`](https://github.com/vudovn/ag-kit/blob/main/antigravity.json)** contract, the native pre-tool-use hook in **`hooks/validate-tool-call.mjs`**, and MCP synchronization capabilities. This engine validates all requests against the contract, blocks destructive filesystem commands via the validation hook, and manages plugin building alongside diagnostic "Doctor" functions.

## Component Registration and Version Control

AG-Kit employs a dual-track versioning model: **CalVer** for the entire toolkit and **SemVer** for individual components. All elements register automatically in [`.agents/manifest.json`](https://github.com/vudovn/ag-kit/blob/main/.agents/manifest.json) with deterministic versioning locked in [`.agents/manifest.lock.json`](https://github.com/vudovn/ag-kit/blob/main/.agents/manifest.lock.json) using SHA-256 checksums. The dependency visualization lives in [`DEPENDENCY_GRAPH.md`](https://github.com/vudovn/ag-kit/blob/main/DEPENDENCY_GRAPH.md), while [`.agents/ARCHITECTURE.md`](https://github.com/vudovn/ag-kit/blob/main/.agents/ARCHITECTURE.md) documents the full system topology and component relationships.

## Working with AG-Kit Components (Practical Examples)

Initialize a new project to create the `.agents/` structure and generate the component manifest:

```bash
npx @vudovn/ag-kit init

```

Execute the `/plan` workflow to decompose features into tasks:

```bash
ag-kit run /plan "Add a user profile page"

```

This routes the request to the `project-planner` agent, which loads the `plan-writing` and `brainstorming` skills to produce a task list.

Submit direct agent requests via JSON payloads validated against the runtime contract:

```json
{
  "agent": "frontend-specialist",
  "task": "Audit UI accessibility",
  "skills": ["web-design-guidelines", "tailwind-patterns"]
}

```

The Antigravity Runtime validates this request against [`hooks.json`](https://github.com/vudovn/ag-kit/blob/main/hooks.json) and the `validate-tool-call.mjs` safety gate before execution.

## Summary

- **AG-Kit** consists of five pillars: Agents (20), Skills (47), Workflows (13), Rules (6), and the Antigravity Runtime Layer
- All components reside under `.agents/` and are registered in [`manifest.json`](https://github.com/vudovn/ag-kit/blob/main/manifest.json) with SHA-256 lockfiles in [`manifest.lock.json`](https://github.com/vudovn/ag-kit/blob/main/manifest.lock.json)
- The runtime uses [`antigravity.json`](https://github.com/vudovn/ag-kit/blob/main/antigravity.json) contracts and `validate-tool-call.mjs` hooks to enforce safety and prevent destructive operations
- Versioning uses CalVer for the toolkit and SemVer for individual components to guarantee reproducible builds
- CLI commands `init` and `run` provide immediate access to the modular architecture without global installation

## Frequently Asked Questions

### What is the difference between Agents and Skills in AG-Kit?

**Agents** are role-based AI personas that execute tasks and coordinate work, while **Skills** are reusable knowledge modules that agents load conditionally using `when_to_use` rules. A single agent might invoke multiple skills during a workflow execution, dynamically assembling capabilities based on the specific task requirements.

### Where are the AG-Kit component manifests stored?

The auto-generated registry lives in [`.agents/manifest.json`](https://github.com/vudovn/ag-kit/blob/main/.agents/manifest.json) with deterministic versioning locked in [`.agents/manifest.lock.json`](https://github.com/vudovn/ag-kit/blob/main/.agents/manifest.lock.json). These JSON files track all 20 agents, 47 skills, 13 workflows, and 6 rules, providing SHA-256 checksums for CI/CD reproducibility.

### How does AG-Kit prevent destructive operations?

The Antigravity Runtime Layer implements a native safety gate in `.agents/hooks/validate-tool-call.mjs` that intercepts and blocks destructive filesystem commands before tool execution. This works in conjunction with the six governance rules in `.agents/rules/` to enforce safety constraints at both the hook and policy levels.

### Can I use AG-Kit without installing it globally?

Yes. The toolkit supports zero-install initialization via `npx @vudovn/ag-kit init`, which creates the `.agents/` directory structure and generates the component manifest without requiring a global npm installation. The `ag-kit` CLI commands are available through npx or local node_modules execution.