#MAKED

#Features

• A five-domain ring
  Model → Data → Experience → Attack → Knowledge, in that order, each domain initialising independently; the starting domain is one request away.

• Drive slots from the transition table
  Of the 272 position/slot pairs, 228 are Block; the loop reports "no way out" instead of pretending to move.

• Undecided branches stay undecided
  When the table offers several successors and none is preferred, MAKED lists them and lets the caller choose, and says which kind of edge each one is.

• The reader chooses how the loop runs
  The panel says which mode is in force (structured, which follows the ring, or free, which lets any slot drive) and lets the reader change it; a run can also be started again from any domain of the ring.

• Your own records, and your own corrections
  A record in the workspace can be written, corrected in place and removed; a correction keeps the record's number, its time and its place in the workspace's order.

• The pages say what you say
  A page can be corrected in place: the page keeps its place in the navigation, the correction is in the language you wrote it in, and it is still there after the server restarts.

• The machine is a file
  A model file (JSON or YAML) with its own domains, positions, slots and rules; MAKED_MODEL names it.

• The mapping table is a file
  The rules that say what a document means, read top down, first match wins; MAKED_RESEARCH names it.

• The corpus is yours
  A corpus of arxiv, of an RSS feed, or of your own folder of .txt, .md, .markdown, .pdf and .json files; MAKED_CORPUS names it.

• The corpus says what it did not read
  A corpus of two hundred read as twenty is not a corpus of twenty, so the panel, the drive and the causal estimate all say how many the corpus holds and how many were read.

• The collective
  The Society layer, with its 13 positions, 28 transitions and 8 phases; the English words are a file, so MAKED_SOCIETY can change them.

• The collective's words are checked
  A vocabulary that names a position the machine does not have is a gap, and the gaps are reported rather than papered over.

• Causal estimates that say what they rest on
  DoubleML, with the treatment, the outcome, the controlled variables, the balance table, the overlap and the sensitivity all reported.

• Explorations you can take away
  Named sessions whose every step records why it was possible; replay, branch, rename, and export as Markdown or JSON.

• Two languages, written not translated
  The loop, the timeline, the measures, the exported document and the pages themselves all answer in English or Chinese; the Chinese is the table's own wording.

• An agent's server
  The Model Context Protocol (2026-07-28) over stdio or HTTP, seven tools, every answer in sentences.

• A discovery document
  GET /api/agent, for an agent that does not speak the protocol: the same seven tools, the instructions, and the plain HTTP endpoints.

• A browser front end
  A rabbita single-page app served by the same process as the API; no second web server, no CORS configuration.

• A file that cannot be read stops the start-up
  A half-read machine answers every request confidently and wrongly, which is the worst thing a server can do.

#What you get

#Installation

#As a MoonBit package

moon add riantr/MAKED

///|
import {
  "riantr/MAKED/backend@0.1.8" @maked,
}

#As an application

docker compose up --build

docker run --rm -p 8080:8080 -v maked-data:/data ghcr.io/riantr/maked:latest

A package on ghcr.io is private until someone says otherwise, and only the owner can say it: Settings → Package settings → Change visibility → Public, once, for riantr/maked.

#Command-Line Usage

# The web server: the API and the browser app, one process.
moon run --release --target native cmd/server

# The agent's server, over stdio. Spawn this; speak MCP to it.
moon run --release --target native cmd/mcp

# The agent's server, over HTTP, on the port you name.
MAKED_MCP_PORT=8735 moon run --release --target native cmd/mcp

.\build.ps1
moon run --release --target native cmd/server

#Quick Start

#Run the loop

docker compose up --build

#Run it from another agent

curl -s http://127.0.0.1:8080/api/agent

moon build --release --target native cmd/mcp

{
  "mcpServers": {
    "maked": {
      "command": "/path/to/MAKED_moonbit/_build/native/release/build/cmd/mcp/mcp.exe"
    }
  }
}

The agent's server is not in the published release artifacts yet — those carry the web server and the browser bundle. It is built from this repository, and it will join the release when it is worth shipping.

• There is no handshake. initialize is not a method in 2026-07-28; the server answers it with -32601 Method not found. The entry point is server/discover.
• Every request carries its own version. Each request's params._meta must contain io.modelcontextprotocol/protocolVersion (a string) and io.modelcontextprotocol/clientCapabilities (an object). A request without them is refused with -32602.

#Write a machine of your own

MAKED_MODEL=models/product-iteration.json \
MAKED_RESEARCH=research/product-iteration.yaml \
moon run --release --target native cmd/server

#API Reference

#The HTTP API

#The language

GET  /api/loop/status?lang=zh
GET  /api/loop/slots?lang=zh
GET  /api/loop/continuations?lang=zh
POST /api/loop/step?lang=zh
GET  /api/sessions/1?lang=zh
GET  /api/pages?lang=zh
GET  /api/pages/model?lang=zh
GET  /api/bootstrap?lang=zh

GET  /api/sessions/1/export?format=md&lang=zh
GET  /api/sessions/1/export?format=json&lang=zh

#The language in the browser

#The agent's server

#The discovery document

curl -s http://127.0.0.1:8080/api/agent

#The four files

#Environment Variables

#Error handling

• A refused request is an answer, not a crash. A slot that does not exist comes back as 400 with the name of the slot that was asked for. A step that cannot move comes back with the reason it cannot, in words.
• A file that cannot be read stops the start-up. The reason is printed on stderr, and the server does not serve. Unset the variable that names it to run the built-in one.
• A rule that names a slot the machine does not have is refused. It is a rule about nowhere, and reading it would mean inventing a slot to hold it.
• A vocabulary that names a position the collective does not have is a gap. The gaps are reported, in the panel and in the API.

#Examples

#A machine of your own

{
  "format": "maked.model.v1",
  "name": "One small machine",
  "domains": [
    { "id": "idea", "letter": "I", "title": "Idea", "role": "the idea", "anchor": "raw" }
  ],
  "positions": [
    { "id": "raw", "label": "Raw idea", "gloss": "Nobody has built it yet.", "domain": "idea" },
    { "id": "asked", "label": "A question asked", "gloss": "Somebody was asked.", "domain": "idea" }
  ],
  "slots": [
    { "id": "ask", "designation": "Ask", "gloss": "Talk to somebody who would use it." }
  ],
  "rules": [
    {
      "from": "raw",
      "slot": "ask",
      "outcome": { "kind": "moved", "edge": "A customer said no", "to": "asked" }
    }
  ]
}

#A mapping table of your own

format: maked.research.v1
mapping:
  - label: A question worth asking
    keywords:
      - question
      - why
      - unclear
    slot: ask
    notes: The document opens a question rather than answering one.
fallback:
  label: Anything else
  slot: ask

#A corpus of your own

format: maked.corpus.v1
source:
  kind: local
  path: ./notes
  max_results: 20

#A vocabulary of your own

#A record of your own

curl -X POST http://127.0.0.1:8080/api/entries \
  -H 'Content-Type: application/json' \
  -d '{"domain": "M", "title": "The failure I want to keep", "body": "The loop reached a position it could not leave."}'

curl -X PUT http://127.0.0.1:8080/api/entries/1 \
  -H 'Content-Type: application/json' \
  -d '{"domain": "M", "title": "The failure I want to keep, corrected", "body": "The loop reached a position it could not leave."}'

#Correcting a page

curl -X PUT http://127.0.0.1:8080/api/pages/model \
  -H 'Content-Type: application/json' \
  -d '{"title": "The model I read it as", "body": "What the model is, in my own words."}'

curl -X PUT 'http://127.0.0.1:8080/api/pages/model?lang=zh' \
  -H 'Content-Type: application/json' \
  -d '{"title": "我读出来的模型", "body": "用我自己的话说。"}'

#Driving it from another agent

$ MAKED_MCP_PORT=8735 moon run --release --target native cmd/mcp &
$ curl -s http://127.0.0.1:8735/mcp \
    -H 'MCP-Protocol-Version: 2026-07-28' \
    -H 'Mcp-Method: tools/list' \
    -H 'Content-Type: application/json' \
    -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientCapabilities":{}}}}'

#Project Structure

MAKED_moonbit/
├── backend/                          # the loop, the API and the storage (native)
│   ├── model.mbt                     # the machine: domains, positions, slots, rules
│   ├── loop.mbt                      # the subject loop and the group states
│   ├── society.mbt                   # the collective
│   ├── step.mbt                      # one step, shared by the API and the agent
│   ├── agent.mbt                     # the agent's payloads, in sentences, and the discovery document
│   ├── bootstrap.mbt                 # the start-up: plan → read → install
│   ├── version.mbt                   # the version the agent reports
│   ├── api.mbt                       # every HTTP route
│   ├── app.mbt                       # the Flask-style app: the route table and the middleware chain
│   ├── maked_app.mbt                 # the app, assembled
│   ├── request.mbt                   # the request wrapper
│   ├── response.mbt                  # the response helpers
│   ├── pages.mbt                     # the content model, and the ten public pages
│   ├── entries.mbt                   # the workspace: the things the reader brings
│   ├── research_config.mbt           # the mapping table
│   ├── research.mbt                  # what a document means
│   ├── corpus.mbt                    # the corpus
│   ├── corpus_sources.mbt            # where the documents come from: arxiv, a feed, a folder
│   ├── datafile.mbt                  # a file that may be JSON or YAML
│   ├── causal.mbt                    # the causal estimate
│   ├── narration.mbt                 # the sentences
│   ├── i18n.mbt                      # the language switch
│   ├── export_words.mbt              # the exported document's words, in both languages
│   ├── metrics.mbt                   # the measures, in both languages
│   ├── session.mbt                   # explorations, timelines, exports
│   ├── database.mbt                  # SQLite
│   ├── *_test.mbt                    # 447 tests
│   └── *_wbtest.mbt                  # 16 tests
├── frontend/                         # the single-page app (js)
│   ├── app.mbt                       # the TEA loop and the messages
│   ├── i18n.mbt                      # the words the client owns
│   ├── loop_state.mbt                # the loop's state, and why a step may do nothing
│   ├── society.mbt                   # the society panel
│   ├── session.mbt                   # the explorations panel
│   ├── entries.mbt                   # the workspace panel
│   ├── causal.mbt                    # the causal panel
│   ├── page.mbt                      # the page, and how it is decoded
│   ├── logo.mbt                      # the ring
│   ├── views.mbt                     # the views
│   └── frontend_test.mbt             # 173 tests
├── cmd/
│   ├── server/main.mbt               # the web server
│   ├── mcp/main.mbt                  # the agent's server
│   └── web/main.mbt                  # the browser bundle
├── models/                           # example machines
│   ├── product-iteration.json
│   └── product-iteration.yaml
├── research/                         # example tables, corpora and vocabularies
│   ├── product-iteration.yaml
│   ├── society.yaml
│   ├── corpus-arxiv.yaml
│   ├── corpus-local.yaml
│   └── notes/                        # the corpus the local example names
│       └── failed-launch.md
├── tools/
│   ├── integration-test.ps1          # 447 checks against a running server
│   ├── mutate-backend.ps1            # 148 mutations of the backend
│   ├── mutate-frontend.ps1           # 65 mutations of the frontend
│   ├── mutate-loop.ps1               # 16 mutations of the loop
│   ├── check-mutation-anchors.ps1    # 229 anchors, and whether any is dead
│   ├── check-readme.ps1              # the claims this document states, against the tree
│   ├── check-readme.sh               # the same gate, in bash
│   ├── check-docs.ps1                # the other documents' claims, against the tree
│   └── check-docs.sh                 # the same gate, in bash
├── .githooks/                        # the pre-commit hook, and the note beside it
│   ├── pre-commit                    # the hook itself
│   └── README.md                     # what it runs, and how to install it
├── AGENT.md                         # how to drive MAKED from another agent
├── AGENTS.md                        # how to work on MAKED
├── maked.png                        # the logo
├── moon.mod  moon.pkg
├── build.ps1                         # build the bundle, check, test, build the server
├── ci.sh                             # 18 gates
└── Dockerfile  docker-compose.yml

#Usage Tips

#Start the loop anywhere

curl -X POST http://127.0.0.1:8080/api/loop/reset/knowledge

#Ask before you move

#Read the run as numbers

#Keep the table and the machine together

#Development Status

#Test and gate counts

#Running the tests

moon check --target native          # type-check the backend
moon fmt --check                    # the formatter is a gate
moon test --target native backend   # the backend
moon test --target js frontend      # the frontend
bash ci.sh                          # everything, including the slow gates

#Common Pitfalls and Best Practices

#✅ DO:

1. Give the machine and the table together. A table whose rules name slots the running machine does not have is refused at start-up, on purpose.

   MAKED_MODEL=models/product-iteration.json \
   MAKED_RESEARCH=research/product-iteration.yaml \
   moon run --release --target native cmd/server

2. Ask what the table offers before taking a move. maked_options lists the slots that can move and the ones that cannot, and says why. A slot with no road out of a position is not a failure of the caller.

3. Let an undecided branch stay undecided. When the table offers several successors and none is preferred, take the target as an argument rather than picking one for the subject.

4. Read a refusal as an answer. A refused request comes back with the reason, in words, and names the thing that was asked for.

#❌ DON'T:

1. Don't treat the ring order as evidence that anything moved. The ring order M → D → E → A → K is the order the logo draws. It is presentation, not state.

2. Don't mix the protocols on one stream. The agent's server speaks MCP on stdout. Diagnostics belong on stderr — a line of prose in the middle of a protocol stream is a line the client cannot parse, and the reason MAKED refused to start is lost in the noise.

3. Don't read a file you cannot read whole. MAKED refuses a file it cannot read rather than half-reading it, and the start-up stops. Keep that: a half-read machine answers every request confidently and wrongly.

4. Don't hand a table to a machine it does not fit. A rule that names a slot the machine does not have is a rule about nowhere, and reading it would mean inventing a slot to hold it.

#Roadmap

• The five-domain ring, with the drive slots taken from the transition table
• The machine as a file
• The mapping table as a file
• The corpus as a file
• The collective, and its words as a file
• Causal estimates that report what they rest on
• Explorations: replay, branch, rename, export
• The agent's server — Model Context Protocol over stdio and HTTP
• A discovery document at GET /api/agent, for agents that do not speak MCP
• A Chinese front end
• The measures and the exported document in two languages
• The pages in two languages, and no longer describing a program that is not this one

#Contributing

1. Fork the repository
2. Create a feature branch
3. Add tests for new behaviour
4. Ensure all gates pass with bash ci.sh
5. Submit a pull request

#License

#References

• pyroduct — the state machine, the group states and the collective
• rabbita — the single-page front end
• moonback — the HTTP server the micro-framework sits on
• moonbit_doubleML — the causal estimate
• Model Context Protocol — the agent's server, version 2026-07-28
• MoonBit Language Guide