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

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 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 with deterministic versioning locked in .agents/manifest.lock.json using SHA-256 checksums. The dependency visualization lives in DEPENDENCY_GRAPH.md, while .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:

npx @vudovn/ag-kit init

Execute the /plan workflow to decompose features into tasks:

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:

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

The Antigravity Runtime validates this request against 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 with SHA-256 lockfiles in manifest.lock.json
• The runtime uses 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 with deterministic versioning locked in .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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}