Power your agent
पब्लिशर का इंस्टॉल। PlugMCP एंडपॉइंट नहीं।
Host a copy with our keys and logs.
रजिस्ट्री में अभी कोई पैकेज्ड रिलीज़ नहीं है। रिपॉज़िटरी का README देखें.
रिमोट URL या आपकी मशीन पर कमांड? दोनों इंस्टॉल में क्या अंतर है
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.
लॉन्चपब्लिशर से
AI engineering framework delivered as an MCP server. Turns AI-generated code into production-ready software.
Positioning note (2026). A2P was built in the Claude 4.5/4.6 era, when even frontier models routinely wrote code before tests, declared work "done" without evidence, and shipped stubs. Today's top frontier models have internalized much of that steering themselves. The value of this repo has shifted accordingly. Its primary audience is now strong open-weight coding models (GLM, Qwen3-Coder, Kimi, DeepSeek class), which still carry the discipline gap A2P was built to close. And for every model class, including the frontier, A2P remains a verification layer: gates and receipts enforced in code that turn an agent's self-reports into machine-checkable evidence. Details in Who A2P is for.
The v2 layer treats AI-delivered code the way a staff engineer treats a
system: thirteen systems-engineering concerns (data_model, invariants,
state_machine, api_contracts, auth_permissions, failure_modes,
observability, performance_under_load, migrations,
concurrency_idempotency, distributed_state, cache_invalidation, security)
must carry evidence at every hardening artifact (requirements, tests,
plan, completion review) before a slice can reach ready_for_red or
done. Applicability is deterministic. The state-manager enforces the
gates in code — no prompt-only checklist.
v2.0.2 (current) adds codebase-memory-mcp as a required companion:
the planning → building transition is blocked without it, so every
slice exploration runs against the symbol graph instead of bash grep.
Before you can verify systems-engineering concerns, you need to verify delivery: that tests exist, that they were written first, that they pass against fresh SAST, that acceptance criteria are actually met. v1's hardening triad (requirements → tests → plan), test-first guard, completion-review loop, security gates, backup policy, and SSL verification are all still in place — v2 is strictly additive and the state file migrates v1 → v2 transparently on first read.
Use v2 if you want both delivery discipline AND systems rigor. Use the v1 flow (the default for slices without v2 triggers) if the slice is narrow enough that the 13 concerns don't apply.
37 MCP tools · 1473 tests · Dogfood-validated (153/158 rubric, 50/50 adversarial) · Architecture → Plan → Build → Audit → Security → Deploy
Best for: developers running strong open-weight coding models (GLM, Qwen3-Coder, Kimi, DeepSeek class) in Claude Code (via router), Cline, Roo Code, opencode, or any MCP client — and anyone, on any model, who wants machine-checkable evidence instead of self-reports from long autonomous runs. Works from scratch or for hardening a vibe-coded MVP. See Who A2P is for.
npx architect-to-product init
This creates .mcp.json in your project. Then restart Claude Code and run:
/a2p
A2P starts with two onboarding paths:
A2P is an AI engineering framework packaged as an MCP server.
It adds engineering discipline to AI-assisted software development: architecture-driven planning, evidence-gated TDD, security review, backup strategy, and deployment generation.
The MCP server is the interface. The engineering system is the product.
In one sentence: A2P is an AI engineering framework, packaged as an MCP server, for turning AI-generated code into production-ready software.
A2P drives software through a gated lifecycle:
Architecture → Plan → Build → Audit → Security → Deploy
During build, each feature (called a "slice") runs through the native flow — every step enforced in code, with a concrete tool call behind each gate:
requirement hardening → test hardening → plan hardening (1–3 adversarial rounds + finalize) → ready_for_red → test-first guard → RED → GREEN → REFACTOR → SAST → completion review loop → DONE
That means:
a2p_verify_test_first) diff-classifies the worktree against a baseline commit or file-hash snapshot and requires ≥1 test file touched, 0 production files touched, and a failing test run — it won't let the slice reach RED otherwise.a2p_completion_review) runs after SAST. A2P auto-scans the diff for stub signals, diff-checks the implementation against finalPlan.expectedFiles and interfacesToChange, and enforces verdict consistency: any non-"met" AC, non-"deep" coverage, non-"ok" plan compliance, or unjustified stub signal forces NOT_COMPLETE and loops the slice back through completion_fix with a refreshed baseline.The AI agent cannot skip a gate. If it tries to advance without meeting the conditions, the state machine throws an error pointing at the missing tool call. The exception is a one-per-project bootstrap slice (marked bootstrap: true) that runs a legacy flow and is used only for A2P's own self-rebuild.
onboarding → planning → building → security → deployment → complete
↑ ↓ ↑ ↓
└── refactoring ←───┘ (re-entry: full
↓ security cycle
e2e_testing required again)
→ Full lifecycle, gates, and re-entry rules: docs/WORKFLOW.md
AI coding agents are fast, but they tend to skip discipline:
How often that happens depends on the model class — which is why A2P today has two distinct value propositions.
Strong open-weight coding models write good code but typically run one to two generations behind the frontier on long-horizon delivery discipline: staying test-first over hours, not shortcutting, not declaring "done" early, not suppressing errors. That is exactly the gap A2P was built to close — with gates enforced in code, not prompts. And at open-weight token prices, the hardening overhead (requirements → tests → plan → reviews) is nearly free relative to what it buys.
The pitch in one line: open-weight speed and pricing, frontier-grade delivery discipline.
Two honest constraints:
Current frontier models rarely need A2P's steering — they plan adversarially and write boundary tests unprompted. What no model can do, structurally, is verify its own claims: "I wrote the tests first" and "all acceptance criteria are met" are self-reports. A2P's diff-based test-first guard, stub scan, plan-compliance check, and timestamped audit trail turn those self-reports into machine-checkable receipts. The more autonomously agents run — background agents, scheduled runs, multi-hour sessions nobody watches — the more those receipts are worth.
A2P adds the missing engineering system around the agent: enforcement where the model is weak, evidence where trust is expensive.
codebase-memory-mcp builds a code graph instead of scanning files raw — up to 100x fewer exploration tokens.Use A2P from day one to define architecture, plan slices, build with TDD, and generate deployment artifacts.
/a2p → /a2p_planning → /a2p_build_slice (repeat per slice) → /a2p_audit → /a2p_security_gate → /a2p_whitebox → /a2p_audit (release) → /a2p_deploy
Skip straight to security, audits, refactoring, and deployment preparation — no slices needed.
/a2p → set architecture → transition to security
/a2p_security_gate → /a2p_whitebox → /a2p_refactor → /a2p_deploy
Transition back to security from deployment or complete — prior approvals are automatically invalidated and the full security cycle must be re-satisfied.
security re-entry → /a2p_security_gate → /a2p_whitebox → /a2p_deploy
A2P includes active claim verification across the full pipeline.
→ Full validation results: docs/validation/
A2P's native flow has been validated end-to-end by running A2P against itself in a controlled sandbox with hidden adversarial test suites and independent observer scoring.
6 scenarios tested: pure function (divide), HTTP integration (webhook), date parser (10 edge-case pitfalls), retry with abort (plan critique depth), median (semantic correctness trap), trivial constant (over-engineering trap).
Key finding: The hardening triad (requirements → tests → plan) is load-bearing, not ceremonial. Agents consistently anticipated edge cases that were absent from the reference implementations — including signed-zero IEEE-754 semantics, abort-mid-delay race conditions, year-0 Date.UTC quirks, and the even-length median trap. The 40–60% Schublade-2 improvement estimate from docs/QUALITY-IMPACT.md is supported by the evidence; observed capture rate is closer to 60–70%.
Real-world trial: One slice (German phone number normalizer) built through the full native flow on the Handwerk CRM codebase (121 existing slices). Plan-hardening rounds 1–2 found two real algorithm bugs before any code was written: a plus-sign stripping order-of-operations error and an Austrian 0043-prefix misclassification.
→ Full dogfood artifacts: a2p-dogfood/OBSERVATIONS-SUMMARY.md, per-scenario scorecards in a2p-dogfood/observations/
All dogfood and benchmark numbers were produced with 2025-era Claude frontier models as the operating agent. Read them accordingly:
A2P's gates are strong forcing functions, not absolute proof. This section is the honest list of things A2P cannot do, things it does imperfectly, and things that are intentionally conservative. Read it before relying on A2P for high-stakes production work.
For a non-technical overview of what the native flow actually improves (and what it doesn't), see docs/QUALITY-IMPACT.md.
.a2p/state.json mutation. Any client-side state store can be edited out-of-band. Every gate described in docs/WORKFLOW.md is enforced when tools are called through A2P — not when state is written directly. Treat the state file as trusted input from your own workflow."met" AC coverage claim is honest. The completion review forces the model to make the claim explicitly, cross-referenced with fresh test and SAST runs — but "I ran the tests, they pass, AC met" is self-report at the end of the day..gitignore parser is a simple subset. Supports literal files, directory patterns (build/), and simple wildcards (*.log). Does not support negation (!pattern), nested .gitignore files, or full glob semantics. If you rely on complex ignore rules, use A2P inside a git repo — the git-backed diff path uses git diff directly and honors the full ignore spec.pass-only stub detector matches single-line def signatures only. A function with a multi-line signature (e.g. def foo(\n a,\n b\n):\n pass) will not be flagged. Plain def foo(): pass — caught. async def, class methods, etc. — caught.export function|const|class|interface|type|enum declarations in changed .ts/.tsx/.js/.jsx/.mjs/.cjs files. Non-TS/JS files are checked at file granularity (unplannedFiles) but not at symbol level. Sufficiently creative refactors across non-TS files can drift without being flagged in unplannedInterfaceChanges.shortcutsOrStubs in the completion review is the complementary channel; it is enforced structurally (any non-empty → NOT_COMPLETE) but not semantically.StateManager.forceLegacyFlowForTests is a static class field in production code that, when set to true, disables the hardening triad and test-first guard for all non-bootstrap slices. It exists so legacy test suites can walk slices through the old pending → red path without seeding full hardening artifacts. It defaults to false, is never set from production code paths, and is visible only to test helpers (useLegacySliceFlow() in tests/helpers/setup.ts). A malicious or accidental write to this field from outside the test suite would silently disable the gates — treat it as a known test-only escape that should not exist in a future audit-hardened version.fs.symlinkSync-based tests may behave differently on Windows (where symlinks require admin or Developer Mode).A2P works with Claude Code, Claude Desktop, Cursor, VS Code, and any MCP-compatible AI coding assistant.
Claude Code (CLI)
claude mcp add architect-to-product -- npx architect-to-product
Claude Desktop — Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"architect-to-product": {
"command": "npx",
"args": ["architect-to-product"]
}
}
}
Cursor — Add to .cursor/mcp.json:
{
"mcpServers": {
"architect-to-product": {
"command": "npx",
"args": ["architect-to-product"]
}
}
}
VS Code — Add to .vscode/mcp.json:
{
"servers": {
"architect-to-product": {
"command": "npx",
"args": ["architect-to-product"]
}
}
}
MCP prompts are invoked with / in Claude Code:
A2P layers multiple security mechanisms from deterministic pattern matching to LLM-guided code review to active runtime testing.
Coverage by numbers: 32 deterministic probes · 25 adversarial review domains · 8 runtime test categories · 2 active verification categories · deployment artifact validation · dependency scanning · pre/post-deployment checklists
Mechanisms:
Domains covered: SQL/command/NoSQL injection, XSS, path traversal, SSRF, insecure deserialization, auth middleware, IDOR, privilege escalation, mass assignment, hardcoded secrets, JWT, session fixation, CSRF, CORS, race conditions, business logic bypasses, file upload, webhook security, and more.
→ Full security coverage matrix: docs/SECURITY.md
A2P auto-configures companion MCP servers based on your tech stack.
Core (always installed)
Conditional (installed based on stack)
Security note: Companion MCPs are third-party software with access to your project files and databases. Review the source repo and generated
.mcp.jsonbefore enabling any companion.
Frontend Aesthetics (enforced)
A2P enforces Anthropic's frontend aesthetics guidelines for all hasUI slices. The build prompt requires distinctive typography, cohesive color themes, motion, atmospheric backgrounds, and creative spatial composition. Generic AI aesthetics (Inter/Roboto fonts, purple gradients, cookie-cutter layouts, emoji icons) are explicitly prohibited.
Languages: Python, TypeScript/Node.js, Go, Rust, Java/Kotlin, Ruby, PHP, C#/.NET, Dart/Flutter, Swift
Databases: SQLite, PostgreSQL, MySQL/MariaDB, MongoDB, Redis
Hosting: Hetzner, DigitalOcean, AWS, Fly.io, Railway, Vercel, Cloudflare, Render, any VPS
Deploy targets:
git clone https://github.com/BernhardJackiewicz/architect-to-product.git
cd architect-to-product
npm install
npm run typecheck # Type checking
npm test # 1473 tests
npm run build # Build
npm run dev # Dev mode
Running Claude Code against your local build. The committed
.mcp.json pins to the published npm version so contributors and
external users always get a stable server. When you want Claude Code
to load your in-progress dist/ instead, copy
.mcp.local.json.example to an out-of-repo override
(~/.claude/settings.local.json or a private .mcp.local.json you
gitignore) and edit the absolute path. The local override takes
precedence over the committed .mcp.json. Restart Claude Code after
any npm run build to pick up a fresh dist/.
MIT
Vibe code fast. Ship like an engineer. AI engineering framework packaged as an MCP server that enforces TDD, security scanning, pentesting, secret management, QA audits, and deployment to a securely
ओवरव्यू
Vibe code fast. Ship like an engineer. AI engineering framework packaged as an MCP server that enforces TDD, security scanning, pentesting, secret management, QA audits, and deployment to a securely configured VPS — automated with up to 100× fewer exploration tokens.
टूल
अभी टूल सूची नहीं है। रिमोट सर्वर को पहले हेल्थ चेक के बाद सूची मिलती है।
FAQ
इस पेज पर Cursor, Claude Desktop, Claude Code या VS Code के लिए stdio कॉन्फ़िग कॉपी करें। यह पब्लिशर का इंस्टॉल इस्तेमाल करता है, PlugMCP प्रॉक्सी नहीं।
इस रिकॉर्ड में कोई ज़रूरी एनवायरनमेंट वेरिएबल दर्ज नहीं है।
Architect To Product stdio पर लोकल चलता है।
पिछली जाँच 2026-10-28 को हुई। Vibe code fast. Ship like an engineer. AI engineering framework packaged as an MCP server that enforces TDD, security scanning, pentesting, secret management, QA audits, and deployment to a securely configured VPS — automated with up to 100× fewer exploration tokens.