Archcore CLI

Archcore is a git-native context layer for AI coding agents.

It ships as a CLI and a local stdio MCP server, so any MCP-compatible coding agent can read and write your repo context through standard tools. Works across Claude Code, Cursor, GitHub Copilot, Gemini CLI, Codex CLI, OpenCode, Roo Code, and Cline.

See it work

That context came from .archcore/ — typed Markdown documents versioned in Git, served to any agent through MCP tools and session hooks.

What changes

❌ Without Archcore

Every session starts from zero. The agent:

• guesses your architecture and breaks your conventions
• duplicates logic that already exists
• re-litigates decisions your team already made
• needs the same context re-explained in every chat

✅ With Archcore

Your decisions, rules, and conventions live in Git as structured context. The agent:

• loads the applicable decisions and rules at session start
• puts code where your architecture says it belongs
• respects the ADRs, specs, and rules already in the repo
• records new decisions as durable context — reviewable in PRs, portable across agents

The agent stops guessing and starts following the system.

Get started in 60 seconds

curl -fsSL https://archcore.ai/install.sh | bash    # macOS / Linux
cd your-project && archcore init

archcore init scaffolds .archcore/, detects your coding agents, and wires up hooks and MCP for them.

Then open your agent and say:

"We're using PostgreSQL for primary storage. Record this decision."

Done — there is now a structured ADR in .archcore/ that every future session, in any agent, will see.

On Windows: irm https://archcore.ai/install.ps1 | iex. For WSL, go install, and building from source, see Install methods below or the full install guide.

Works with your agent

The CLI is itself a local stdio MCP server — one integration surface for every MCP-compatible agent. Hooks add session-start context where the agent supports them.

archcore init configures detected agents automatically. To wire one up by hand:

archcore mcp install --agent cursor      # write MCP config for a specific agent
archcore hooks install                   # install session-start hooks for detected agents
claude mcp add --transport stdio archcore -- archcore mcp   # or add the server manually

How it works

1. Initialize — archcore init creates .archcore/ and installs agent integrations.
2. Capture — decisions, rules, plans, and guides are stored as typed Markdown documents with YAML frontmatter.
3. Reuse — agents read, create, update, and link documents through MCP tools while they work; hooks load context at session start.
4. Keep it in Git — review context changes like code, evolve them over time, keep them portable across tools.

.archcore/
├── settings.json
├── auth/
│   ├── jwt-strategy.adr.md
│   └── auth-redesign.prd.md
├── backend/
│   └── error-wrapping.rule.md
├── incidents/
│   └── connection-pool-exhaustion.cpat.md
└── notifications/
    └── notifications-implementation.plan.md

The structure is free-form — organize by domain, feature, or team. A document's type lives in its filename (slug.type.md): 19 types across three layers — knowledge (ADRs, rules, specs, guides), vision (PRDs, plans, ideas, requirements tracks), and experience (incident patterns, recurring tasks). This repo's own .archcore/ is a working example.

Ask your agent

"Before I touch the auth module, what decisions and rules apply here?"

Loads the ADRs and rules tied to that area before the agent edits a single line.

"We have a convention: always wrap errors with fmt.Errorf and %w. Make this a rule."

Creates backend/error-wrapping.rule.md with imperative guidance, rationale, and good/bad examples.

"Last week we had a connection-pool exhaustion incident. Document it so we don't repeat it."

Creates incidents/connection-pool-exhaustion.cpat.md with root-cause analysis and prevention steps.

For bigger flows, MCP prompts orchestrate whole document cascades — /product_track feature="user notifications" drafts an idea, derives a PRD, builds an implementation plan, and links them together.

How it compares

Not for — chat memory, a prompt library, or a one-shot spec-to-code generator. Archcore is a repo truth layer for coding agents, not a methodology kit.

Reference

What ships in the box: 19 document types, 4 relation types, 10 MCP tools, 5 multi-document prompts, hook integrations for 4 agents and MCP integrations for 8.

---
title: "Use PostgreSQL for Primary Storage"
status: draft
tags: [database, infrastructure]
---

## Context

...

curl -fsSL https://archcore.ai/install.sh | bash

irm https://archcore.ai/install.ps1 | iex

go install github.com/archcore-ai/cli@latest

git clone https://github.com/archcore-ai/cli.git
cd cli
go build -o archcore .

archcore config                    # show all settings
archcore config get <key>          # get a specific value
archcore config set <key> <value>  # set a value

Ecosystem

• Archcore Plugin — using Claude Code or Cursor? The plugin pairs with the CLI: same engine, plus skills, intent commands, and guardrails. One product, two entry points — the CLI on its own covers every other agent.
• docs.archcore.ai — full documentation.
• .archcore/ in this repo — a living example: the CLI is built with its own context layer.

Development

Requires Go 1.25+.

go build -o archcore .   # build
go test ./...            # run all tests

Links & license

• Documentation: docs.archcore.ai
• Website: archcore.ai
• Plugin (Claude Code, Cursor): github.com/archcore-ai/archcore-plugin
• Issues: github.com/archcore-ai/cli/issues
• License: Apache 2.0