harness

Project Harness Scaffolder (/harness)

This skill designs in bulk a team of specialized **agent personas** tailored to whatever project form or vision the user wants to build, along with the official-spec custom skills (Skills) structure they will use, and scaffolds it (automatically generates the skeleton) under the project folder, or analyzes the entire existing configuration of agents and skills to additionally configure agents as needed and fully complement the existing configuration.

When to use this skill

• When starting a new project and wanting to build a multi-agent collaboration team specialized for it.
• When the user makes a domain-specific request such as "Set up a React test automation team" or "Build agents and skills dedicated to a data analysis pipeline."
• When wanting to analyze and review the entire list of existing configured agents and skills, and if necessary, additionally configure new agents or complement and refactor the existing agents' personas and skills.
• When wanting to automate the repetitive work of manually creating subfolders one by one and SKILL.mdfilling them in.

Instructions

When this skill is activated, the agent must handle precise design, review, and file creation according to the rules below.

[!IMPORTANT] Omission of writing an Implementation Plan: When working on the harness skill, do not require or wait for a separate implementation plan (implementation_plan.md) to be written; instead, immediately complete the domain analysis and architecture design, then immediately execute (create/update) the agent and skill configuration.

1. Diagnosing the Current State of Existing Agents and Skills (Review Phase)

• If a AGENTS.md or .agents/ directory already exists at the project root, precisely analyze the roles and responsibilities of the previously designed agents and the entire structure of registered custom skills.

2. Deriving User Requirements and Gap Analysis

• Based on the user's domain requirements and tech stack, identify gaps in the existing team composition.
• To resolve this, additional specialized agent role groups that need to be configured(e.g., performance monitoring, security auditing, etc.) or remedies for existing agentsare derived, and the new core skills they will use in collaboration and improvements to existing skillsare planned.

3. Scaffolding Under the Project Folder and Incremental Update Rules

1) Integrated Agent Guidelines (/AGENTS.md)

• Create or update in the project root directory.
• While preserving existing agent information and conventions as much as possible, cumulatively reflect and update the role specifications of newly complemented/added agents and the updated collaboration rules.
• [Change History] Whenever the harness configuration is completed or updated, record the change date, configuration type (new/modified), agent team composition difficulty, and major changes (list of added/modified agents and skills) in the Change History The section should be reflected so that it is described in detail in the form of a table or list, accumulated at the bottom of the AGENTS.md file.

2) Individual Agent Detailed Specification (.agents/agents/<AgentName>.md)

• .agents/agents/ Create as individual Markdown files in the directory or update existing files.
• Include YAML Frontmatter (name, role, description) at the top and write specific behavioral guidelines in the body.

3) Individual Agent Execution Profile (.agents/agents/<agent_name>/agent.json)

• In each agent folder, create a agent.json file and describe the agent's runtime instructions and permissions.
• Declare in strict compliance with the latest Flat JSON spec of the Antigravity CLI:

  {
    "name": "에이전트 이름",
    "description": "에이전트 역할 설명",
    "system_prompt": "시스템 지침 및 협업 SOP 상세 기술",
    "enable_write_tools": true,   // 쓰기 및 명령어 실행 도구 사용 여부
    "enable_mcp_tools": true,     // MCP 연동 도구 사용 여부
    "enable_subagent_tools": false // 하위 에이전트 기동 도구 사용 여부
  }
  

4) Standard Specification Skills (.agents/skills/<skill-folder>/SKILL.md)

• Skill names that are added or supplemented must be specified in kebab-case, and individual folders must be created/selected.
• Within each folder, it must be created or modified under the filename SKILL.md .
• Fill in the required YAML Frontmatterat the top of the file:

  ---
  name: <kebab-case-name>
  description: <3인칭 시점의 기능 설명 및 트리거 조건 포함>
  allowed-tools:
    - <허용할 도구 1>
    - <허용할 도구 2>
  ---
  

• The body must include the following 3 mandatory headers:
  • ## When to use this skill (present the situation and trigger for when it should be invoked)
  • ## Instructions (detailed prompt instructions required for the operation)
  • ## Workflow (the sequential execution procedure the agent must carry out)

5) Workspace for Storing Intermediate Results and Outputs (_workspace/)

• All intermediate source code, analysis files, temporary outputs, temporary datasets, and execution results generated while all agents built with the harness perform tasks must be recorded under a _workspace/ folder created under the project root.
• This is to keep the project's core source tree clean and to safely isolate/manage temporary outputs generated by agents. When defining the Persona of all configured agents and the behavior of skills, the system prompts and instructions must be strongly designed so that the intermediate result path always points to this _workspace/ directory.

---

4. Guide to Designing Agent Orchestration Architecture Patterns

When designing relationships between agents to match domain complexity and task requirements, specify the optimal configuration among the following 6 core orchestration architecture patterns , and formalize and structure it in AGENTS.md:

1. Pipeline: Sequential serial workflow (e.g., spec definition -> code implementation -> verification).
2. Fan-out/Fan-in: A method of processing independent tasks in parallel and then finally aggregating them.
3. Expert Pool: Dynamically select a suitable expert agent from a pool according to the type of task at hand.
4. Producer-Reviewer: A two-stage collaboration structure consisting of a generation agent and an agent that audits/tests/supplements it.
5. Supervisor: A central master agent dynamically dispatches and controls lower-level tasks in real time.
6. Hierarchical Delegation: Recursively splits and delegates complex, large-scale tasks to lower-level subagents.

---

5. Antigravity CLI Optimized Runtime and Message Specification (Runtime Collaboration Protocol)

Agents must not simply wait statically on the Antigravity CLI runtime, but must collaborate with each other using advanced integration tool APIs and real-time communication specification protocols.

1) Runtime Agent Lifecycle Management

• Subagent Registration (define_subagent): An agent dynamically registers the specialized persona (Name, Description, System Prompt, and tool permission flags) needed during runtime. When a session starts or a project is loaded, the existing .agents/agents/{agent_name}/agent.json agent profiles defined in the file are loaded and define_subagent proactively registered in bulk to the session runtime through the tool.
• Subagent Launch (invoke_subagent): When real-time parallel task execution is needed, invoke_subagentis used to run the agent in the background, and the unique Conversation IDreturned is acquired to direct the task execution flow.

2) Antigravity CLI Standard Messaging Protocol

send_message When using the tool to synchronize context and convey intent between isolated agents, for parsing and automation of follow-up work, standard message specification wrapped in JSON structureis internalized in the agent system prompt so that communication uses it.

Message payload format (JSON) specification:

{
  "sender": "송신 에이전트명",
  "action": "액션 유형 (REQUEST_REVIEW | TASK_COMPLETE | REFACTOR_REQUEST | STATUS_UPDATE)",
  "target_artifact": "작업 중인 대상 파일 경로 (절대 경로)",
  "content": "상세 텍스트 설명 및 요청 사항",
  "metadata": {
    "task_id": "작업 식별용 ID",
    "status": "현재 상태 값",
    "additional_context": "기타 참고 데이터"
  }
}

Agents must, when calling send_message , insert this JSON as a string into the text body and send it, and the subagent receiving it must be designed to first parse the JSON data to accurately identify the target and request specifications and then proceed with tool work.

3) Organic Integration with the Orchestrator Skill

The orchestrator skill equipped on the main agent must manage the launching (invoke_subagent), waiting, result aggregation, and communication coordination of all subagents, and by interpreting the standard message payloads in JSON format returned by each subagent, efficiently orchestrate subsequent-stage agent launches or feedback delivery.

---

6. Differential Configuration Guidelines by User Skill Level

By analyzing the user's requests and level (skill level), the difficulty and structural complexity of the harness agent team configuration are designed with the following three-tier differentiation.

• Beginner:

  • Purpose: Maximize intuitive understanding and simplicity.
  • Architecture: Choose a simple pipeline or a simple Producer-Reviewer pattern composed of 1–2 agents.
  • Skill Composition: Compose with 1–2 unit skills that are easy and clear, focused on core behavior, without complex asynchronous or branching control.
  • Orchestration: A form in which a central main agent drives sub-agents sequentially in a single line and shows feedback to the user, omitting complex parallel/asynchronous flows.

• Intermediate:

  • Purpose: Modularization of functionality and efficient automatic collaboration.
  • Architecture: Apply a composite architecture of an Expert Pool or a pipeline + Producer-Reviewer, and deploy 2–3 individually defined agents.
  • Skill Composition: Design by separating into functional module skills with high independence and reusability.
  • Orchestration: Equip with a semi-automated collaboration structure using a clear messaging protocol, and guide sequential feedback between agents and exception handling.

• Advanced/Expert:

  • Purpose: Maximized automation, advanced exception recovery, parallel processing, and autonomy.
  • Architecture: Design complex hybrid architectures such as Hierarchical Delegation or the Supervisor pattern, and compose 3 or more highly differentiated specialized agents.
  • Skill Composition: Fill with advanced skills equipped with high-performance autonomous execution, dynamic state management, and parallel execution recovery capability (Recovery Strategy).
  • Orchestration: The main agent simultaneously launches multiple sub-agents in the background (Fan-out/Fan-in), and dynamic define_subagent Build a fully autonomous mutual feedback loop utilizing launch and JSON-standard communication, deeply internalizing error and conflict recovery strategies into the orchestrator skill.

---

Workflow

When the user requests a task with the harness skill, the agent must proceed with the task precisely according to the 6-step sequence below:

Step 1. User Request Domain Analysis (Domain Analysis)

• Fully analyze the user's target system and domain requirements and technology stack.
• Based on the context of the user's request, determine the user's proficiency level (beginner/intermediate/advanced) and set the difficulty of the agent team and skill composition to apply.

Step 2. Agent Team Architecture Design (Architecture Design)

• Design the optimal orchestration architecture pattern that matches the determined difficulty (proficiency level).
• So that the user can intuitively understand the relationships between agents, data flow, and call order AGENTS.mdclearly describe the design plan and structure it.

Step 3. Agent Configuration

• Configure the markdown files (.agents/agents/<AgentName>.md) of the specialized agents defined in the architecture design and the agent.json profile files that comply with the Antigravity flat specification.
• In the project root directory, create the overall agent guideline AGENTS.mdas a new file, or update it incrementally without breaking existing conventions. In this process, you must add a section explaining the specific operational instructions and user interactive operation manual that actually execute and handle the work commands issued by the user (e.g., automatic harness planning and technical research) by activating the orchestrator skill (orchestrator).

Step 4. Skill Configuration for Agents to Use

• Finalize the list of custom skills that each agent will directly load and operate when performing tasks.
• .agents/skills/<skill-folder>/SKILL.md Under the directory, create skill files that strictly comply with the standard specification (Frontmatter and the three major headers: When to use, Instructions, Workflow), or precisely refactor the existing structure.

Step 5. Orchestrator Skill Configuration

• Exclusively configure the Antigravity CLI main agent's orchestrator skillso that agents can interact organically and effectively and run the automation loop.
• .agents/skills/orchestrator/SKILL.md Create the orchestrator skill file in the path, and implement the specific SOP and prompt instructions for the main agent to launch (invoke_subagent), control, and process messages (send_message) of sub-agents, direct the collaboration loop, and respond to failures. In this process, you must explicitly insert into the body of the orchestrator skill a detailed technical description list of the entire sub-agent specifications (names, roles) currently deployed and integrated in the harness system and the custom skills (names, automation tasks) owned by each individual agent.

Step 6. Harness Configuration Review & Test

• Perform a final check to ensure that the created or updated harness structure (agent profiles, skill markdown) is loaded in compliance with the Antigravity standard specification.
• [CRITICAL] Immediate Agent Registration: At the completion stage of configuration, the agent performing the harness skill must directly read and parse the profile (.agents/agents/{agent_name}/agent.json) files of all created agents, and define_subagent actually call the tool to substantially and immediately register the agents in the current conversation session runtime. (Prevent omission of agent registration)
• invoke_subagent 및 send_messageRun it virtually to thoroughly test and verify that autonomous communication between agents and the collaboration scenarios of the orchestrator skill flow smoothly without errors.
• When all tests and tasks are complete, visually output the agent and skill structure tree map (Tree Map) to the console, and present the review information concisely and clearly without unnecessary extras so that the user can quickly recognize the agent team and skills built this timemust do. In this process, provide detailed explanations of the unique 'skill name (kebab-case)' of each newly built custom skill, the clear technical role they are responsible for, and their core function (e.g., a one-line core summary of what work it automates) without omissionmust do. (Instead of simply exposing and explaining the file path (SKILL.md) as is, you must clearly show the official skill name so that the user can easily recognize it)
• Finally, so that the user can actually run the currently built harness if there are no issues after review, you must include in the final usage guide instructions specific conversation examples for instructing and controlling work with simple natural language prompts (e.g., intuitive conversation scenarios such as "Start harness planning collaboration," "Build a harness research report and training course") inside the Antigravity CLI chat window instead of terminal shell commandsand finish.