中文 | English

Enterprise Harness Engineering

Enterprise-grade AI Agent Skills for software development, DevOps, SRE, security, and product teams.

Over the past year, almost every company has been "using AI" -- adopting Cursor, Claude Code, running a few training sessions. Yet the results rarely match expectations.

The problem is not that AI is not powerful enough. The problem is that your enterprise was not designed for AI.

An enterprise needs to cross three chasms to be truly AI-driven:

• Human habits. The more experienced people are, the more they default to "is this really allowed?" instead of "why not?"
• Tool interfaces. Most internal tools are GUI-only -- designed for humans clicking buttons. AI calls APIs. No API means AI cannot operate, and entire departments are excluded from AI transformation.
• Organizational structure. Assembly-line dependencies -- I finish then hand off to you, you finish then hand off to the next person. Every extra person in the loop is another blocking point.

The root cause is the same: existing enterprises are designed for human-to-human collaboration, not human-to-AI collaboration.

Giving everyone a chainsaw but keeping the factory designed for handsaws -- workstations too small, voltage too low, assembly line unchanged -- gets you 1.2x, not 10x.

10x is easier than 2x. 2x means optimizing within the old framework. 10x means adopting a new one. Enterprise Harness Engineering is that new framework.

What is Enterprise Harness Engineering

Harness Engineering has become a popular concept in the tech community -- building feedback loops, testing frameworks, and runtime environments for AI Agents so they can autonomously verify and deliver code. This is right, but it only solves part of the problem.

Enterprise Harness Engineering extends Harness Engineering to the enterprise level. It is not just about building feedback loops for AI coding agents -- it is about making every layer of the enterprise AI-accessible:

• Can the technology be AI-harnessed? Does the code have closed-loop feedback? Can AI autonomously verify and deliver?
• Can the tools be AI-harnessed? Do internal systems have APIs? Can AI operate them directly?

The core formula:

Enterprise AI Readiness = Tech Loop x Tool API

This is multiplication, not addition. If either dimension is zero, the total is zero:

Most companies have only addressed a fraction of the tech layer. Tool layer remains untouched. The result: 1.2x, not 10x.

Harness Architecture

The 4-Layer Stack: Human -> Agent -> Skill -> Tool

+----------------------------------------------------------+
|                   Human (Judgment & Decision)             |
|                                                          |
|  Provides intent, business context, final decisions      |
|  No need to remember Skill names -- describe in          |
|  natural language what you want to do                    |
+----------------------------+-----------------------------+
                             | Natural Language
+----------------------------v-----------------------------+
|                   Coding Agent Layer                      |
|                                                          |
|  Claude Code / Cursor / OpenClaw                         |
|  - Understand intent -> select Skill -> orchestrate      |
|  - Multi-Skill composition, cross-department calls       |
|  - Same Agent + different Skills = different roles       |
+----------------------------+-----------------------------+
                             | Invocation
+----------------------------v-----------------------------+
|                      Skill Layer                          |
|                                                          |
|  ~100 Skills across 6 departments                        |
|  - Each Skill is a Markdown document                     |
|  - Encodes expert experience: triggers, steps, rules     |
|  - Everything as Code: Git-managed, Code Review enforced |
+----------------------------+-----------------------------+
                             | Operation
+----------------------------v-----------------------------+
|                       Tool Layer                          |
|                                                          |
|  SaaS -- Collaboration / Dev (GitLab, Sentry) /          |
|          Data (DataHub, Superset) / Ops (Grafana, K8s)   |
|  Internal Platforms -- IoT platform / Test automation     |
|  Hardware Toolchain -- Firmware build / Instruments       |
+----------------------------------------------------------+

Each layer has a clear purpose:

Tool Layer -- Everything as Code or SaaS. Eliminate manual operations. All tools must be SaaS or API-accessible. All operations must be codified. Infrastructure uses Terraform (IaC), deployments use ArgoCD (GitOps), secrets use Vault, CI uses GitLab Pipeline. Nobody clicks buttons in a console. Nobody runs scripts locally. Everything as Code or Data -- manual operations are the enemy of AI closed loops. Only when all state is API-queryable and all changes have audit trails can AI Agents see the full context.

Skill Layer -- Encode expert knowledge into AI-executable workflows. Skills are not just API documentation. They encode how senior experts think -- how they judge, how they decide, what rules they follow -- into Markdown. Skills are the crystallization of professional knowledge. Once encoded, an employee's core expertise can be executed in parallel by AI, amplified infinitely through tokens.

Coding Agent Layer -- Unified entry point, free orchestration. No need to build a specialized bot for every scenario. The same Coding Agent, loaded with different Skills, becomes different roles. And it can natively write code -- when it finds a bug, it does not just notify someone; it reads the source, writes the fix, and submits a merge request.

Skill: Not API Docs, but Organizational Muscle Memory

A Skill does not just tell AI "how to call this API." It encodes a senior expert's entire judgment framework:

• A VOC Analysis Skill does not just call APIs to scrape data -- it encodes how a senior product manager reads reviews, identifies trends, and benchmarks against competitors.
• A WiFi Tuning Skill does not just control instruments -- it encodes how an RF engineer selects initial parameters, judges convergence direction, and defines pass/fail criteria.
• An SRE Alert Handling Skill does not just read Grafana metrics -- it encodes how an on-call engineer triages, identifies root causes, and decides when to scale vs. when to rollback.

The old model: Human Skill x Time = Output -- one person, 8 hours a day.

The new model: Professional Knowledge x Token = Output -- the same expertise executed in parallel by AI, amplified infinitely, no longer bounded by human time. Skills are the crystallization of knowledge. AI is the amplifier.

Agent Personas: One Agent, Many Roles

The same Coding Agent, loaded with different Skill combinations, becomes a different Agent Persona:

Personas are not independent Agent services -- they are working modes of the Coding Agent. Switch the Skill set, switch the role. No deployment, no integration, no maintenance.

Why Not Traditional Specialized Agents

Many companies build specialized AI Agents using LangChain/LangGraph -- hardcoded workflows, independent services. We chose a fundamentally different approach:

The last row is the decisive advantage: a Coding Agent can natively write code. A traditional SRE Agent that finds a bug can only notify a human. A Coding Agent can read the source, write the fix, run tests, and submit a merge request. Skills tell it how to find the problem; once found, it inherently has the ability to fix it. This is not "AI-assisted" -- it is "AI end-to-end closed loop."

Core Principles

These principles share a common direction: make AI a first-class citizen. Every system, every data source, every tool in the enterprise must be visible, operable, and verifiable by AI.

Skills Catalog

25 Skills across 6 categories:

Software Development

GitLab Integration

Monitoring & Observability

SRE & Operations

Security & Compliance

Market Research

Installation

All skills follow the Agent Skills Specification, compatible with 30+ AI coding agents.

Claude Code (Plugin Marketplace)

# Install as a plugin (recommended)
/plugin marketplace add addxai/enterprise-harness-engineering

# Then install specific skills
/plugin install enterprise-harness-engineering

Cursor

# Clone and copy skills to your project
git clone https://github.com/addxai/enterprise-harness-engineering.git
cp -r enterprise-harness-engineering/skills/* .cursor/skills/

# Or install globally
cp -r enterprise-harness-engineering/skills/* ~/.cursor/skills/

You can also add individual skills via Settings > Rules > Add Rule > Remote Rule and point to a skill directory on GitHub.

Windsurf

git clone https://github.com/addxai/enterprise-harness-engineering.git
cp -r enterprise-harness-engineering/skills/* .windsurf/skills/

# Or install globally
cp -r enterprise-harness-engineering/skills/* ~/.codeium/windsurf/skills/

Universal (.agents/skills/) -- GitHub Copilot, Gemini CLI, Codex, Kiro, Junie, and more

git clone https://github.com/addxai/enterprise-harness-engineering.git
cp -r enterprise-harness-engineering/skills/* .agents/skills/

# Or install globally
cp -r enterprise-harness-engineering/skills/* ~/.agents/skills/

Install a Single Skill

# Example: install only the sre-agent skill
git clone --depth 1 https://github.com/addxai/enterprise-harness-engineering.git
cp -r enterprise-harness-engineering/skills/sre-agent .claude/skills/

Supported Platforms

Contributing

See CONTRIBUTING.md for guidelines on adding new Skills or improving existing ones.

The short version:

1. Fork this repository
2. Create a skill directory under skills/
3. Add a SKILL.md with proper frontmatter (name and description in YAML frontmatter)
4. Submit a merge request

About

Built by AddX.ai (积加科技) — an AI-first engineering organization practicing Enterprise Harness Engineering at scale.

License

Apache-2.0