Arcgentic
Arcgentic is a harness engineering layer for AI coding agents. It turns ad-hoc prompting into a gated engineering workflow.
中文文档 -> README.zh-CN.md
Potencialize seu agente
Instalação do publicador. Não é um endpoint do PlugMCP.
Host a copy with our keys and logs.
Ainda não há uma versão empacotada no registro. Siga o README do repositório.
URL remota ou um comando na sua máquina? Como as duas instalações diferem
Rodar no PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
AbrirDo publicador
Arcgentic is a harness engineering layer for AI coding agents. It turns ad-hoc prompting into a gated engineering workflow.
中文文档 -> README.zh-CN.md
Mechanical plan/dev/self-audit/external-audit gates for AI coding agents, with a configurable role-routing topology engine, an MCP-UI live status panel, and native-tooling Claude Code V2 dispatch. Claude Code, Codex, OpenClaw, and PyPI.
Arcgentic helps Codex and Claude Code run software work as a disciplined sequence: clarify the idea, plan the work, build it, self-audit it, optionally run a realistic user test, audit it independently, then close only when the evidence is good enough.
It is for people who already use AI coding tools, but do not want every session to depend on memory, vibes, or a lucky prompt.
Arcgentic started as the development discipline behind
Moirai, a real agent project where AI
coding had to survive 30+ strict development rounds, repeated NEEDS_FIX
audits, planned handoffs, role boundaries, self-audit, external audit, and
recoverable session state.
This plugin packages the patterns that survived that work so Codex and Claude Code users can apply them to their own complex projects. It is not a new coding agent, and it does not copy Moirai-specific phase numbers, fact shapes, or runtime internals. It is the workflow layer extracted from real agent development.
Arcgentic sits in the harness layer around a coding agent.
Codex and Claude Code are the agents. Arcgentic is the engineering harness that gives those agents roles, handoffs, stop states, audit gates, and evidence. This is the same direction people describe as moving from vibe coding toward agentic engineering: the important work is not only prompting the model, but building the workflow around the model so its output can be checked, routed, and trusted.
Related reading:
Codex is the best current experience. In the verified Codex path, the current
project conversation becomes Orchestrator; Arcgentic then creates or reuses
the role threads, names them, sends the right role prompt, waits for their
return signal, and dispatches the next role without manual thread switching.
Claude Code support now has dogfood evidence for single-session-subagent
mode via a foreground Agent tier-0 broker dispatch, so treat that specific
path as a verified real workflow. The SendMessage-based footer-correction
retry path and ListAgents were not exercised by that gate, and
multi-session-subthread mode and the hook-backed fallback path have not yet
been verified in a real Claude Code session — all of these should still be
treated as unproven.
git clone https://github.com/Arch1eSUN/Arcgentic.git arcgentic
cd arcgentic
bash scripts/install-codex-local.sh --plugin-root .
Then start in a saved project workspace and ask:
Use Arcgentic to build this idea: <your idea>
Use this if you want the Arcgentic plugin assets through npm:
npm install -g arcgentic
arcgentic install-codex-local
The npm package is a zero-dependency plugin bundle and Codex local install helper. It includes the skills, agents, scripts, schemas, templates, and platform manifests. The Python CLI is still published separately on PyPI.
/plugin marketplace add Arch1eSUN/Arcgentic
/plugin install arcgentic@arc-studio
Then start inside your project:
Use Arcgentic to build this idea: <your idea>
For Claude Code V2 experimental workflow setup:
If your Claude Code session's own tool list already includes Agent,
SendMessage, and ListAgents (native tooling / "tier 0"), no setup step
is needed — the session broker uses those tools directly and this is the
preferred, dogfood-verified path (see "Platform status" above). Only run
install-hooks below as a fallback, for sessions that lack those three
tools:
arcgentic claude-code-broker install-hooks \
--settings .claude/settings.local.json \
--state .agentic-rounds/state.yaml
Use this if you only need the command-line helper:
pipx install arcgentic
arcgentic --help
Without Arcgentic:
User: Build a small expense splitter.
AI: writes code
AI: says it is done
User: later discovers missing edge cases, unclear scope, no audit trail
With Arcgentic:
User idea
-> current conversation becomes Orchestrator
-> Orchestrator creates or reuses Planner and sends the planning prompt
-> Planner returns the plan to Orchestrator
-> Orchestrator creates or reuses Developer and sends the dev prompt
-> Developer implements and returns a self-audit
-> Orchestrator dispatches optional Test only if realistic use needs it
-> Orchestrator creates or reuses Auditor and sends the audit prompt
-> Auditor returns PASS / NEEDS_FIX / AUDIT_INCOMPLETE
-> Orchestrator routes the next step
The important difference is not that the AI writes more text. The important difference is that each role has a job, each stage has a stop condition, and "done" is not accepted until the workflow can explain why.
When you start Arcgentic with a new idea, the current session becomes
Orchestrator. Before it plans or builds, it should judge whether the idea is a
small fast project or a larger project that needs stronger review. Then it
recommends one project-level mode and asks you to confirm or override it:
The choice is made once for the project. Arcgentic should not ask again every round unless you start a new project or intentionally reset the workflow.
Arcgentic V2 follows this shape:
idea
-> brainstorm and planning
-> round handoff
-> development
-> developer self-audit
-> optional user-test
-> external audit
-> pass or fix
-> next round, next phase, or closeout
The roles are fixed:
Arcgentic does not create a new role identity every round. The role names stay
fixed: Orchestrator, Planner, Developer, Test, and Auditor.
The role/state routing that decides "who acts next" is no longer a hardcoded
table. It is a Topology (toolkit/src/arcgentic/topology.py) that a project
can override via project.arcgentic_v2.topology in state.yaml — routes,
which states each role may act from, and conditional next-role selection based
on the returning role's artifacts (for example, routing differently depending
on an audit outcome field). Zero-config projects get the exact same 5-role
sequence as before, byte for byte; custom topologies are validated at parse
time (unknown role keys and routes with no matching next state are rejected
before they can leave a project stuck mid-round). This is for projects that
need a different role graph than the default plan/dev/audit loop — most
projects should never need to touch it.
Codex V2 is the verified path.
In Codex, Arcgentic can run either V2 mode.
The verified automation is:
User starts in a project conversation
-> Arcgentic marks that conversation as Orchestrator
-> Orchestrator asks for or records the project mode
-> Orchestrator creates or reuses the fixed role thread/agent
-> Orchestrator sends the role-specific prompt and artifact pointers
-> the role finishes and actively returns to Orchestrator
-> Orchestrator consumes the return and dispatches the next role
The user should not have to manually create Planner, Developer, Test, or Auditor threads in the verified Codex flow.
Single session, multiple agents:
Current project thread = Orchestrator
-> Planner role agent
-> Developer role agent
-> optional Test role agent
-> Auditor role agent
-> Orchestrator continues
Multiple sessions, multiple threads:
Current project thread = Orchestrator
-> create/reuse Planner thread and send Planner prompt
-> Planner returns to Orchestrator
-> create/reuse Developer thread and send Developer prompt
-> Developer returns to Orchestrator
-> create/reuse optional Test thread only when needed
-> create/reuse Auditor thread and send Auditor prompt
-> Auditor returns to Orchestrator
In multiple-thread mode, the Orchestrator should sleep after dispatching a role. It wakes only when the role returns its result. That prevents the Orchestrator from guessing when work is done or dispatching duplicate auditors.
In single-session mode, the Orchestrator stays in the same thread and runs the named role agents directly. The role names still stay exact: Planner, Developer, Test, and Auditor. Later rounds reuse those same role identities.
Use Codex V2 when you want the strongest current Arcgentic experience.
Claude Code V2 is complete as an experimental version. single-session-subagent
mode now has real-session dogfood evidence via a foreground Agent tier-0
broker dispatch (see tests/dogfood/gate-3-claude-code-native-broker/RESULT.md);
multi-session-subthread mode and the hook-backed fallback path have not yet
been verified in a real Claude Code session.
The intended behavior is the same:
current session = Orchestrator
-> create/reuse Planner session and send Planner prompt
-> Planner returns
-> create/reuse Developer session and send Developer prompt
-> Developer returns
-> optional Test only when needed
-> create/reuse Auditor session and send Auditor prompt
-> Auditor returns
Claude Code experimental mode aims to reach the same no-manual-routing behavior through the session broker. That full automation has not yet been verified in a real Claude Code session. If automatic return does not work in your setup, use explicit copy-back: paste the role's return message into the Orchestrator so the workflow can continue.
Use Claude Code V2 when you want to try the same discipline in Claude Code and are comfortable with experimental workflow behavior.
Arcgentic ships an optional MCP server exposing a live round-status panel via MCP Apps (the January 2026 official MCP extension for rendering interactive UI inside a conversation). Install it with:
pip install 'arcgentic[mcp]'
and declare it in your project's .mcp.json:
{
"mcpServers": {
"arcgentic": {
"command": "arcgentic",
"args": ["mcp-serve"]
}
}
}
Calling the round_status_panel tool renders round id, per-role dispatch
progress, and the latest audit verdict as an inline panel, with client-side
auto-refresh (capped, pauses when the panel isn't visible) and a "dispatch
next role" button that sends a chat message rather than mutating state
directly — the panel has no write path of its own; the Orchestrator still
drives every state change. On hosts without MCP Apps support (including plain
terminal Codex/Claude Code sessions), the same tool call falls back to a plain
text summary instead of failing.
MCP Apps host support is still young — this feature is for MCP-UI-capable hosts (a graphical Claude/Codex client, not a bare terminal session).
Use Arcgentic for:
Arcgentic is intentionally heavier than normal prompting. If the task is not substantial, risky, or multi-step, the workflow can feel like using a full engineering gate for a tiny change.
Do not use Arcgentic for:
A clean run should leave behind:
These artifacts matter because they make the workflow inspectable. You can come back later and see what was planned, what changed, what was checked, and why the round was allowed to close.
Current evidence:
Planned adoption assets:
multi-session-subthread mode and
the hook-backed fallback path, after those are verified in a real session
(single-session-subagent mode's run notes already exist at
tests/dogfood/gate-3-claude-code-native-broker/RESULT.md).Arcgentic V2 should reuse fixed role sessions. You should see only:
Orchestrator
Planner
Developer
Test
Auditor
If you see R1 Developer, R2 Auditor, or similar names, that is not the
intended V2 behavior.
The Orchestrator should stop after dispatching a role. It should resume only when the role returns information. If it keeps dispatching while a role is still working, the workflow is not following V2.
Audit should not loop forever. Auditor decides PASS, NEEDS_FIX, or
AUDIT_INCOMPLETE. If the evidence is missing and Developer can repair it, the
workflow should go back to Developer. If the same audit gap cannot be resolved
by another audit pass, it should stop instead of creating another auditor loop.
Test is optional. Planner decides whether the current round needs realistic user/session testing. Many small rounds should go directly from Developer self-audit to Auditor.
Near-term:
multi-session-subthread mode, the
SendMessage-based reuse-dispatch path, and the hook-backed fallback path
in a real Claude Code session (single-session-subagent mode's
first-dispatch/create path is verified; repeat dispatch via SendMessage
is implemented but not yet dogfooded);Longer-term:
Open an issue if:
Useful feedback includes:
MIT - Copyright (c) 2026 Arc Studio
Mechanical plan/dev/self-audit/external-audit gates for AI coding agents, with a configurable role-routing topology engine, an MCP-UI live status panel, and native-tooling Claude Code V2 dispatch. Cla
Visão geral
Mechanical plan/dev/self-audit/external-audit gates for AI coding agents, with a configurable role-routing topology engine, an MCP-UI live status panel, and native-tooling Claude Code V2 dispatch. Claude Code, Codex, OpenClaw, and PyPI.
Ferramentas
Ainda não há lista de ferramentas. Servidores remotos recebem uma após a primeira verificação de saúde.
Perguntas frequentes
Copie nesta página a configuração stdio para Cursor, Claude Desktop, Claude Code ou VS Code. Ela usa a instalação do publicador, não um proxy do PlugMCP.
Este registro não lista nenhuma variável de ambiente obrigatória.
Arcgentic roda localmente via stdio.
Última verificação: 2026-11-05. Mechanical plan/dev/self-audit/external-audit gates for AI coding agents, with a configurable role-routing topology engine, an MCP-UI live status panel, and native-tooling Claude Code V2 dispatch. Claude Code, Codex, OpenClaw, and PyPI.