archcore
Star Install
Menu
Verified in part

FPF + Archcore

Every Archcore document gets the checks an FPF pattern asks for: how to verify it and when to revisit it.

How FPF + Archcore work together

FPF + Archcore lets your agent write project documents that a later reader can check. Archcore keeps the project’s decisions, plans and specs in Git and shows the agent what is already settled. FPF, the First Principles Framework, gives the agent a pattern for each kind of document, read from the public FPF library over MCP.

Say you ask for an ADR. The template covers what was decided. The FPF pattern adds how to verify it and when to revisit it, and the agent writes those sections in plain words. The benchmark note says what was measured.

FPF is published by Anatoly Levenchuk under CC BY 4.0. The agent cites pattern IDs and does not copy FPF text into your documents. This recipe is not endorsed by the FPF author. See FPF Library and the FPF repository.

Archcore ↗
Keeps the project's decisions, plans and specs in Git, so the agent checks them first and saves every new document as a draft.
FPF ↗
Serves the First Principles Framework library by Anatoly Levenchuk over a read-only MCP server: a pattern for each kind of document and for making a choice.

From a request to a document you can check later

The instructions ask your agent to:

  1. Check what is already decided

    Before it chooses or writes, the agent reads the Archcore records on the same subject. An accepted record limits the options.

  2. Read the FPF pattern

    The agent reads the FPF pattern for the choice or the document type, such as C.32.ADR for an ADR. If an unknown input could reverse a choice, it defers or asks instead of guessing.

  3. Save a draft with the missing parts

    The agent adds what the template misses, such as How to verify or When to revisit, and saves a draft in .archcore/ with the pattern IDs. You accept it in review.

Both Archcore and the FPF MCP server must already be set up; the recipe also works inside /archcore:plan and /archcore:document.

See an example → See benefits and limits →

One request, start to finish

Request German and French partners start ordering next quarter. Legal answers how VAT applies to partner quotes in six weeks. Decide what to do in the quotation library now, keep the tests passing, and record the decision.

  1. Archcore: The agent searches Archcore and finds the integer-cents rule and no record about VAT.

  2. FPF: Pattern C.38 tells the agent that an unknown input which could reverse the choice is a reason to defer.

  3. Agent: The agent defers, keeps quote() as it is and runs the tests.

  4. FPF: Pattern C.32.ADR lists what a later reader must be able to recover from the record.

  5. Archcore: The agent writes a draft ADR with How to verify, When to revisit and Open questions, linked to the integer-cents rule.

  6. Agent: When Legal answers, a later session finds the draft ADR and picks the decision up from When to revisit.

This is what the instructions ask for, not a recorded run. This request passed 2 of 2 benchmark runs with claude-sonnet-5; the later-session step was not run.

Connect the two tools

1. Install Archcore and FPF

Install Archcore and FPF in the agent you use for this project.

2. Add instructions

CLAUDE.md / AGENTS.md / GEMINI.md 
### Archcore + FPF Library

Applies when you create an Archcore document, make an engineering choice, or draw a conclusion from data.

1. Before you decide or write, call `search_documents` with `content` naming the subject. Read each matching record with `get_document`. An accepted record limits the options.
2. When the request asks you to choose between options, read FPF pattern `C.38` with `read_pattern`, and sections `C.11:1` and `C.11:4.6` with `read_section` (publication `p_85ab6107537eb867`). Do not call `read_pattern` for `C.11`; it is too large. When an input that could reverse the choice is still unknown, "probe again" and "defer" are valid outcomes.
3. When a document draws a conclusion from data, tests or sources, read FPF pattern `B.3`. State what the evidence supports, what it does not support, and what would reopen the conclusion.
4. Before you create a document, read the FPF pattern for its type:
   - `adr` `C.32.ADR`; `rfc` `PSDA.14`; `rule` `A.11.OP`; `guide` `A.3.2.DE`; `spec` `A.6`
   - `prd` and `idea` `C.40.PC`; `plan` `A.15.2`; `research` `F.1`; `evidence` `A.10`; `rnd` `B.5`
   - `scenario` `SYSE.54`; `journey` `MKT.8`; `task-type` `SYSE.48`; `cpat` `A.10.1`; `mrd` `MKT.1`; `brd` `STR.1`
   - `doc`, `urd`, `brs`, `strs`, `syrs`, `srs`: no pattern. Use the Archcore template only.
5. For `A.6`, read sections `A.6:1` and `A.6:7` with `read_section` (publication `p_85ab6107537eb867`) instead of the whole pattern. For a pattern outside that publication, take `publication` from a `search` result.
6. Find the pattern's adoption test (usually in section `:1`) and its conformance checklist (usually in section `:7`). Start from the Archcore sections of the type. For each item that no section covers, add a short section.
7. Name every heading in plain developer words, for example "How to verify", "When to revisit", "Open questions", "Out of scope". Do not use FPF names such as "Publication Boundary", "Work Split", "Eval Exit" or "Forces and Architecture Characteristics".
8. Keep every new record a draft, also when the request states the decision or rule as settled.
9. Name each FPF pattern ID you used and the Library snapshot from `get_corpus_status`. Do not cite a pattern you could not read. Do not copy FPF text.
10. Link the new record to the records it depends on with `add_relation`. Do not change an accepted record.

3. Check in a new session

Start a new session in this project and ask your agent:

Confirm you can use Archcore and FPF, and have read this project’s cooperation instructions.

If the agent reports a missing tool or instruction file, finish that setup before starting work.

Benefits & limits

Documents a later reader can check.

With these instructions, 24 of 33 documents covered every graded item. With Archcore alone, 6 of 34 did.

The effect comes from the FPF library

The same instructions without the FPF server passed 9 of 34 documents, close to Archcore alone.

Plans and market analyses failed in every setup.

A choice made before an answer arrives

Asked about VAT before Legal answered, no run hard-coded a rate, and with FPF both records named the open input and when to revisit it.

Every setup waited in code, so FPF changed the record more than the choice.

Start with Archcore.

Keep your project decisions ready for the next task.

Install Archcore →See how it works

FPF + Archcore

Source & verification

Category
Engineering methods
Instruction revision
0d6f75d93f78
Source
Landing repository · src/recipes/fpf/cooperation.md · This revision is not published yet.
Maintainer
Archcore maintainers
Page updated
October 22, 2026

Verification

Date Agent Model Scenario Outcome
October 22, 2026 Claude Code 2.1.306 claude-sonnet-5 17 requests across Archcore document types and one open choice, 2 runs per setup each passed
October 22, 2026 Claude Code 2.1.306 claude-sonnet-5 A choice that depends on a legal answer due in six weeks passed
October 22, 2026 Claude Code 2.1.306 claude-sonnet-5 An implementation plan and a market analysis failed
  • Measured with Claude Code 2.1.306, claude-sonnet-5, Archcore CLI v0.13.1 and one FPF library snapshot. The library cannot be pinned, so a later snapshot can change a pattern.
  • FPF is a remote service that receives each call's arguments; in these runs, only pattern IDs.
  • Nothing enforces the instructions. Review each draft before you accept it.

Update or disconnect

To update, review changes to the instructions before replacing your copy. To disconnect, remove the added instructions from your project file. Both tools and their documents stay in place.