Artificer Core

What you get

What your assistant gets from Core.

Your definitions and your documents are yours, and they stay with you. Core provides what is the same for everyone: how the work is done.

01

The method

How the work is done: who does each step, in what order, and where to stop and wait for a person.

02

The rules

The gate rules, and the ones that can never be skipped: no record, no entry; nothing is deleted; a person signs off on what is approved.

03

The processes

Four ready-to-use jobs: bring in a document, split a long one into pieces, change a program, and turn table documentation into a data model that follows the Data Vault methodology.

04

The templates

Blank templates for the plan, the report and each document’s record. Your assistant fills them in with your content.

What it does not do

Your documents stay with you.

It does not receive your documents

Your assistant does the review, with your documents, in your folders. Core only provides the instructions.

It does not store your definitions

What a customer means to you is written by your organization and lives in your repository, not in Core.

It does not run anything on your machine

It is read-only. Your assistant does the work, and a person approves it.

Works with any MCP-compatible AI assistant.

Why it works: “The fix for your AI already existed” →

User guide

How to use it, step by step.

With Artificer Core you don’t learn a new tool. You ask your AI assistant for the work in plain language, and your assistant follows the process Core gives it.

01

Connect your assistant

Just once: you add the connector address to your assistant (see below for Cursor and Claude).

02

Ask for the work

“Bring in this document,” “split this long document,” “change this program” or “convert the documentation for these tables.”

03

It analyzes and proposes

Your assistant asks Core for the process, checks the material against the gate rules and your definitions, and tells you what it found.

04

You approve the plan

Before touching anything, it shows you the plan. If you don’t approve it, it does not go on. If you reject it, it starts over with your reasons.

05

It does the work and checks it

It does exactly what the plan says and, when it finishes, compares what it did with what you approved.

06

You accept the report

It hands you a report of what was done and what was checked. Only when you accept it does the result go into the approved archive, with its record.

For technical teams

How it works inside.

Here we do use the technical names. Each one is explained the first time it appears.

The flow

A document’s journey: from intake to the approved archive.

Nothing jumps straight from raw material to public access. Every artifact travels the same governed path, and every step leaves evidence.

Staging: the intake desk. All raw material lands on an ungoverned workbench. What is discarded does not cross over: the Despensa only receives raw material that has been reviewed and accepted.
Despensa (the pantry): the approved archive. A storage layer, not doctrine: it keeps the accepted raw material with its quarantine and its provenance data (who brought it, when and from where).
Each document’s record: code, version, which documents it comes from (lineage) and who approved it. Every artifact is born with a unique code, an immutable physical version, declared lineage and a human signature. It is insert-only: a new version replaces the previous one, which leaves the archive and stays in the Git history.
Projection: the reading list. Each use reads only the files declared in its list, which is versioned and signed. Nothing is served without a projection that declares the exact paths and the reason for each. Either the projection exists, or the access does not.
MCP (Model Context Protocol, an open standard): the read-only connector to your assistant. People and agents query what is servable. The full repository is never exposed.

Who does the work

Who does what.

01

Your AI assistant

Proposes and prepares each step, following the instructions Core serves.

02

A person

Approves the plan before anything is done and accepts the report at the end. Nothing happens without that sign-off.

03

Serves instructions, rules and blank templates, read-only. It does not receive your documents or run anything on your machine.

The validation layer

The intake review.

A validation rule is a versioned file in the corpus — it does not live on a screen or in anyone’s memory. And whoever wrote the document is not the one who checks it.

01

No identity, no entry

A header with code, version, status, date and provenance. What cannot be identified does not get in.

02

It is compared with the definition

The AI checks whether the document truly describes the concept in your organization’s catalog, not whether it repeats the words.

03

What was done is checked against what was approved

At the end, what was produced is compared with the approved plan before it is accepted.

The golden rule of access

Either the signed projection exists, or the access does not.

A projection is the declared list of what a use can read: exact paths, reason and signature. This channel serves Core’s public projection; your project defines its own. Editing content from the channel is not a permission you can ask for: it is a stop.

What you see through MCP is the projection, not the corpus. The projection points to files versioned in Git: what is served today can be reproduced tomorrow. Your assistant follows the list. Core does not control what else it opens on your machine.

The workflows

Processes: templates, not executors.

Core runs nothing. It serves each process with its steps, who does each one, and where it stops to wait for a person. Your assistant applies it in your repository.

01

`ingestar-documento`

A new document moves from the intake desk to the approved archive, with its record.

02

`destilar-documento`

A long document that is already approved is split into several smaller ones, each with its own purpose and traced back to the original.

03

`cambiar-codigo`

A program change is analyzed, planned, approved, carried out and checked against the plan.

04

`ingestar-tabla`

Table documentation becomes a model following the Data Vault methodology (hubs, links and satellites); loading with an engine is in development.

05

`montar-corpus`

Sets up a project's own corpus in its own repository: catalogue, anchor and start-up rule.

List as of 2026-09-28. The source is the connector itself: listar_procesos.

Connection

Connect your assistant

Artificer Core connects through MCP (Model Context Protocol), an open standard for connecting AI assistants to information sources. The connector is read-only and does not require authentication.

The connector address

https://mcp.coreartificer.com/mcp

Connect

// Settings → MCP, or edit ~/.cursor/mcp.json (all your projects)
// or .cursor/mcp.json (this repository only):
{
  "mcpServers": {
    "artificer-core": {
      "type": "http",
      "url": "https://mcp.coreartificer.com/mcp"
    }
  }
}

Settings → Connectors → Add custom connector
Paste the URL: https://mcp.coreartificer.com/mcp

Available on Free (one connector), Pro, Max, Team and Enterprise plans.

Sample trace

→ initialize
{ "serverInfo": { "name": "artificer-core", "title": "The Artificer by Loopit", "version": "1.3.4" } }
→ man                                  ✓ the connector manual
→ obtener_metodologia                  ✓ how the work is done
→ listar_procesos                      ✓ ingestar-documento · destilar-documento · cambiar-codigo · ingestar-tabla · montar-corpus
→ obtener_proceso "cambiar-codigo"     ✓ the full process, in one response
→ obtener_oficio "analizar-documento"  ✓ template + doctrine, in one response
→ obtener_plantilla "plan"             ✓ a blank template, not one of your instances

The thirteen tools

Version 1.3.4, as of 2026-09-28. The live source is the connector itself (tools/list). If the manual (man) and tools/list disagree, tools/list wins.

man

The connector manual: who it is, which tools it has and their limits.

obtener_metodologia

How to work with Core.

listar_reglas_oro

Golden rules and stop signals.

consultar_concepto

A concept from the shared catalog, by code, name or alias.

listar_procesos

Process ids.

obtener_proceso

A full process: its steps, who does them and where it stops to wait for a person.

obtener_carta

Structured definition of the processes, for integrations.

obtener_receta

Deprecated alias of obtener_carta.

listar_oficios

Craft ids (who does each step).

obtener_oficio

A full craft: template and doctrine. It does not execute.

listar_plantillas

Template ids.

obtener_plantilla

A blank template, not one of your instances.

listar_hubs_vigentes

Reminds you that the Hub catalog belongs to your project: Core does not serve it.

Check that it works

When you connect, The Artificer introduces itself and invites you to call man.
Call listar_procesos: you will see ingestar-documento, destilar-documento, cambiar-codigo, ingestar-tabla and montar-corpus.
Call obtener_proceso with "cambiar-codigo": it arrives complete, in one response.
Call obtener_plantilla with "plan": you get a blank template.