From Personal AI Coding to Team Agent Workflows: The EP-Harness Platform

Gaps in Personal AI Coding for Teams

Direct local use of AI coding tools is convenient short-term but exposes four gaps when scaled to a team:

No Prompt Review : Code has code review; prompts do not. Agent instruction quality, ambiguity, security risks, and reusability rely solely on individual judgment.

Experience Cannot Be Reused : Troubleshooting steps, deployment checks, and development prompts remain in personal local files, forcing each new member to relearn.

Lack of Process Visibility : No centralized view of which agent is used, which model/runtime, success rates, latency, or token costs.

No Closed-Loop in R&D Pipeline : After an agent writes code, manual handoffs for code review, push, deploy, test, CR feedback, bug triage, and log inspection limit value to local efficiency gains.

EP-Harness turns these gaps from personal habits into platform capabilities.

EP-Harness: A Managed Agents Platform

EP-Harness is a secondary development based on the open-source project Multica (an open-source managed agents platform). Multica treats coding agents as real teammates that can be assigned tasks, tracked, and have skills persisted. EP-Harness further aligns this foundation with internal R&D processes and systems.

Layered Composable Architecture

Multica comprises three collaborating components:

Server : Manages workspaces, Issues, members, task queues, and real-time updates.

Daemon : Runs on each developer's machine, pulls tasks, and invokes the local AI coding CLI.

AI Programming Tools : Actual code execution occurs in the local toolchain and working directory.

In EP-Harness, tasks enter Issues linked to projects, requirements, app branches, workflows, comments, execution logs, file changes, and feedback. This enables:

Tracking when an agent's task enters an Issue.

Reviewing agent rules via Instructions and Workflows.

Reusing experience via Skills.

Retrospecting via Runtime and logs.

Closing the loop through deployment, review, and feedback channels.

Backend.Execute: Unified Agent Execution Contract

In server/pkg/agent/agent.go, EP-Harness defines Backend.Execute(ctx, prompt, ExecOptions) as the unified entry point for all agent runtimes. agent.New selects a specific Provider Backend (Claude, Codex, OpenCode, ACP, etc.) based on agentType and Config. Each backend retains its own parameters, processes, and transport protocols while exposing a consistent execution lifecycle to upper layers.

Four-Layer Evolution of AI Coding

AI coding usage evolves through four expanding layers:

How to ask (prompt techniques)

What materials to feed (context)

How to execute and constrain (harness)

How to continuously close the loop (loop engineering)

Personal tools typically address the first two layers. EP-Harness solves the latter two and embeds all four into the team R&D flow.

1. Agents Need to Understand the Real R&D Environment

Generic AI coding tools lack knowledge of internal requirement structures, Feishu document permissions, branch creation, code management/release pipelines, and team-accumulated Skills. EP-Harness integrates these internal systems into the agent's working environment, shifting the question from "can the model write code?" to "can the model work correctly in our R&D process?".

2. Prompts: From Personal Tricks to Team Procedures

Teams initially focus on prompt techniques, but long-term success requires turning prompts into maintainable procedures.

3. Context: From Copy-Paste to Structured Context

Agent failures often stem from incorrect context, not model weakness. Requirements background, design docs, acceptance criteria, related repos, target branches, historical discussions, failure records, and internal system call patterns should not rely on manual copy-paste. EP-Harness structures context from:

Issue: task goal, comments, status, history

Requirements: business context, docs, iteration info

Projects: business boundaries, repo resources

Workflows: phase goals, delivery requirements

Skills: team-accumulated methods and tool docs

Runtime: real execution environment

Feishu integration: notifications, discussions, document reading

Execution records: process, outputs, failures

Thus the agent enters a workspace composed of Issues, projects, docs, branches, comments, and run records. Context Engineering's focus is not stuffing context full, but ensuring the right context enters the agent at the right time.

4. Harness: Making Agents Executable, Observable, Governable

A bare model lacks a working directory, doesn't know project test conventions, won't automatically follow team norms, and won't integrate with requirement management, code management, release platforms, Feishu, or log platforms. The Harness layer adds these engineering capabilities.

This transforms an agent from "a model that can talk" into "a manageable execution unit". For teams, long-term stable operation within engineering constraints matters more than a single impressive answer.

5. Loop: Turning Repetitive Work into Controlled Closed Loops

Loop Engineering is not about infinite automation; a valuable loop includes discovery, dispatch, execution, verification, recording, and next-step decision. Two examples:

Upstream Version Update Analysis : Scheduled checks of external releases; determine if analysis Issue exists; create analysis task for new versions; agent analyzes impact, risk, migration suggestions, verification items; spawn migration sub-tasks when needed.

Online Log Inspection : Automated pulling of anomalies by time window; aggregate error fingerprints, impact scope, samples; agent analyzes probable root causes; generates fix and verification suggestions; creates follow-up fix Issues when necessary.

The key is not "agent runs automatically" but that every cycle has records, judgments, outputs, and follow-up actions. Loop value lies in closure, not the loop itself.

Landing Effects

1. Decision Traceability

After requirement delivery, decision records and implementation notes in Issues enable quick reconstruction of implementation context and key trade-offs.

2. Multi-Agent Collaboration

By splitting the delivery process into proposal, development, review, archival phases and introducing multi-agent collaboration, a closed loop from requirement clarification, implementation, quality review, to experience accumulation is formed, continuously improving code quality.

3. Automated Governance

Governance results: 100+ automated fixes for abnormal log issues; log anomalies converged from high-frequency exposure to single digits. Typical high-frequency issues dropped from 2400+ per 4 hours pre-governance to single digits post-governance.

Future Evolution

Continued investment in agent orchestration, skill marketplace, cross-repo collaboration, and deeper integration with CI/CD and observability stacks.

Conclusion

The first phase of AI coding treats agents as personal tools. The next phase treats agents as collaborative team members. When agents touch real requirements, real code, real deployments, and real feedback, chat windows and local prompts are insufficient. Teams need a platform to organize agent tasks, context, rules, execution, review, feedback, and metrics. Once this mechanism runs, agents evolve from a personal assistant into a manageable, reusable, continuously optimizable productive force in the team R&D process.