Skip to content

ArchLang MCP server

io.github.ChanMeng666/archlang-mcpChanMeng666streamable-httpv0.2.49Scanned

Floor plans as code: compile, lint and repair ArchLang (.arch) floor plans to SVG, DXF and PDF.

13 tools: 8 change things and 5 only read.

Tools: 0 delete, 0 irreversible, 8 write, 5 read.
  • Reads private data · 0
  • Reads text others write · 1
  • Can send data out · 0
  • 3 findings

Tools listed without sign-in. Remote posture

With Anlyon

8 tools here change things. Govern them.

  • Anlyon lists the tools and adopts none.
  • Each tool you adopt gets approvals and receipts.
  • Your agent never holds the key.
Govern this server →

A tool your agent calls directly is not routed through Anlyon and is not governed by it. Anlyon Radar only lists and labels, and these labels are the same either way.

What the ArchLang MCP server can do

The ArchLang MCP server is published by the GitHub account ChanMeng666. It has 13 tools. It can create or change data (8 tools: compile, score, repair, fix and 4 more), but cannot delete data. 5 tools only read.

1 tool brings in text other people can write (read_me).

The fixed checks matched 3 findings (annotation-conflict). Each one comes with the text it matched.

Its remote endpoint lists its tools without sign-in, and its tools changed 3 times since Anlyon Radar first saw them.

Last scanned Nov 21, 2026, version 0.2.49.

Tools

Grouped by what each tool does, most consequential first. Open one for its reasons and full description; descriptions are the publisher's own words.

13 tools

Changes things 8Claude Code: ask
  • compileCompile ArchLang `.arch` source (or a Plan-JSON object) to an SVG floor plan, or with `format` to a plain-text ASCII plan ("txt"), Plan JSON ("json") or an image ("png").No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Compile ArchLang `.arch` source (or a Plan-JSON object) to an SVG floor plan, or with `format` to a plain-text ASCII plan ("txt"), Plan JSON ("json") or an image ("png"). Format "json" returns the plan as an object, with `schema` naming its JSON Schema; passed back as `plan_json` it compiles to the same drawing, unless the plan uses a part of the language Plan JSON does not carry (sheet tables, styles, circular rooms, roofs, storeys, `place`, accessibility metadata). Returns the output plus diagnostics; a diagnostic usually carries a byte span with line/col and an E_/W_ code, and often a fix, sometimes one the `fix` tool can apply. Errors come back as data, never as exceptions: read `diagnostics` and correct the source. A multi-storey plan (`level <n> { … }`) returns the lowest storey in `output` and every storey in `pages[]` ({ level, name, output }); pass `level` to render just one. format "png" is unavailable on the hosted server, which has no image renderer: use format "svg", or GET /svg/<payload> on the hosted server for an image URL.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • explainLook up an E_/W_ diagnostic code in the catalogue: what it means, why it is raised and how to resolve it, with an example that raises it and, for most codes when the installed core…1 finding

    Why it is in this group

    • The name "explain" says "explain": a word for reading.
    • The input takes a statement or command to run (input.code), which can change anything it can reach.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "explain" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false}; The name "explain" says "explain": a word for reading.

      What this check looks for
    Description, as the server wrote it
    Look up an E_/W_ diagnostic code in the catalogue: what it means, why it is raised and how to resolve it, with an example that raises it and, for most codes when the installed core has them, `fixed`, the same example corrected. Returns { ok:true, code, entry: { code, severity, message, cause, fix, example, fixed? } }, the `explain --json` of the CLI; an unknown code returns { ok:false, code }. The code is matched case-insensitively.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • finishComplete a plan for export by adding what it lacks; run it once `lint` is clean.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Complete a plan for export by adding what it lacks; run it once `lint` is clean. Two stages. `furnish` puts furniture, by room use, in each rectangular room that holds none, on every storey (a furnished room is never touched, and one that lacks a piece its use requires is named in `unresolved` with the missing pieces, not filled; placement is `against wall` / `in <room> anchor`, never absolute). `sheet` adds the sheet statements the plan lacks (`paper`, `scale`, `dims auto`, `title`, `schedule rooms`, `legend`), choosing the finest standard scale on the smallest sheet that holds the drawing. It fills only what is missing and deletes nothing; `only` runs one stage; `reissue:true` may replace `paper`/`scale` (only those) when the drawing does not fit them. Returns { ok, changed, changes, unresolved, source }; a plan that does not compile comes back untouched with `ok:false`, and every room left empty (its use has no furniture row or is unknown, or furnishing it would raise a new diagnostic) and every sheet statement left out is named in `unresolved` with the reason; a note with `scope` set (`outside-table`) asks nothing of you unless that room should hold furniture.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • fixApply the machine-applicable fixes attached to a plan's compile diagnostics and return the edited source.1 finding

    Why it is in this group

    • The description's first verb is "apply": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "fix" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false}; The description's first verb is "apply": a word for a change.

      What this check looks for
    Description, as the server wrote it
    Apply the machine-applicable fixes attached to a plan's compile diagnostics and return the edited source. It corrects source-level faults (an opening off its wall becomes the attachment form, an out-of-range position is clamped, …); furniture geometry is `repair`'s job. It runs at most 4 passes and rolls back a pass that raises the error count. `unsafe:true` also applies `maybe-incorrect` fixes. Returns { ok, passes, applied, skipped, source }.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • repairCorrect furniture placement and return the corrected `.arch` source with a change log.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Correct furniture placement and return the corrected `.arch` source with a change log. It pushes furniture out of walls, doorways and door swings, separates overlapping pieces, moves fixtures that sit in the wrong room, and snaps floating pieces to walls. A piece it may not rewrite is listed in `unresolved` with the reason. It never adds doors or windows (that is a design choice); use `suggest` for those.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • scoreMeasure how much of a brief's intent JSON a plan satisfies, without gating.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Measure how much of a brief's intent JSON a plan satisfies, without gating. Returns { ok, satisfied, total, score, subscores, violations }, where `score` is satisfied/total in [0,1] (an empty intent scores 1); call it across edits to watch a plan approach the brief. The intent's shape is the `archlang://intent-schema` resource. A malformed intent returns `{ ok:false, intentErrors }` as data, never an exception.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • suggestSuggest the doors and windows a plan's room graph needs, as data; nothing is applied.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Suggest the doors and windows a plan's room graph needs, as data; nothing is applied. For a room with no path back, a building with no entrance, a bath reachable only through a bedroom, or a windowless bedroom, it returns ready-to-paste `door`/`window` statements with a rationale, for you to choose among and insert. Each names its wall by an authored id or a unique wall category, else by absolute `at (x, y)` coordinates. Door candidates avoid furniture in the door's approach; window candidates do not consider furniture. On a plan of `level` blocks each suggestion also carries `level` (its storey) and `insertAt` (the offset of that storey's closing `}`, where its statements go), and no door to the outside is offered on a storey reached only by a stair or lift, nor onto the roof of a storey below.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
Only reads 5Show 5 read-only tools
  • completeList the completion items in scope at a source byte offset: keywords, element names, ids and enum values, the same items an editor's language server offers.No findings

    Why it is in this group

    • The description's first verb is "list": a word for reading.
    Description, as the server wrote it
    List the completion items in scope at a source byte offset: keywords, element names, ids and enum values, the same items an editor's language server offers. For structured or assisted authoring.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • describeReport a plan's facts without rendering, so you can check it against the brief without looking at an image.No findings

    Why it is in this group

    • The name "describe" says "describe": a word for reading.
    Description, as the server wrote it
    Report a plan's facts without rendering, so you can check it against the brief without looking at an image. Returns rooms (`area_m2`, measured on the wall centrelines; `net_area_m2`, the floor no wall stands on, absent when it cannot be computed exactly; bbox, adjacency, use, and the exact shape: `floor_polygon` for a `room polygon`, `floor_circle` for a `room circle`, whose area is exactly πR²), doors (what each connects), windows, circulation (walk distance, bottleneck width, detour), zones, storeys (`levels[i]` carries the same facts per floor) with the shafts that join them and which storeys stay reachable (`vertical`), the drawing extent (`bbox`, `bbox_outer`), `freedom` (which positions are hand-authored and which are derived), and totals (`floor_area_m2` on centrelines, `net_floor_area_m2` beside it, absent when any room's net area is).

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • lintList advisory architectural-soundness warnings (`W_*` codes) as data: unreachable room, windowless bedroom, too-narrow door, blocked doorway, furniture through a wall, circuitous p…No findings

    Why it is in this group

    • The description's first verb is "list": a word for reading.
    Description, as the server wrote it
    List advisory architectural-soundness warnings (`W_*` codes) as data: unreachable room, windowless bedroom, too-narrow door, blocked doorway, furniture through a wall, circuitous path, and more. `profile` selects a ruleset ("residential-basic", "accessibility-advisory", …).

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • read_meExplain this hosted ArchLang server in one short page: the authoring loop, the size cap, what is unavailable here, how to get an image URL for a plan, and what the server keeps (no…Reads text others writeNo findings

    Why it is in this group

    • The name "read_me" says "read": a word for reading.

    What it can reach

    • untrusted-inputThe description's first sentence says "explain" and "url": it reads web pages, which anyone can write.
    Description, as the server wrote it
    Explain this hosted ArchLang server in one short page: the authoring loop, the size cap, what is unavailable here, how to get an image URL for a plan, and what the server keeps (nothing). Call it first when unsure.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false
  • validateCheck a plan in one pass without returning a drawing (parse, resolve and lint): the gate a plan passes before it ships.No findings

    Why it is in this group

    • The name "validate" says "validate": a word for reading.
    Description, as the server wrote it
    Check a plan in one pass without returning a drawing (parse, resolve and lint): the gate a plan passes before it ships. `strict:true` makes advisory warnings fail too. Optional `graph` checks the plan's interior-door adjacency against an intended room graph (`{ room: [neighbours] }`); a mismatch fails. Optional `intent` (a brief's expectations, shaped as the `archlang://intent-schema` resource describes) is checked against the plan: a missed gating assertion (room count, existence, area, total area, windows) fails, while adjacency and reachability are advisory and only score. `profile` lints under a named ruleset as well, and its warnings are the ones reported; `taste` scores the plan under a taste profile, which never fails it. `next` is the one item to fix first, chosen in a fixed order (an error, a compile warning, a validity warning, a drafting warning, the brief and the graph, a profile-only warning, then the lowest taste score), or null when nothing is left; a broken `soft` keep is not weighed here yet, so where the CLI's `validate` names it this returns a later item, or null. A malformed intent returns `{ ok:false, intentErrors }` and an unknown profile `{ ok:false, error }` as data, never an exception. Returns { ok, diagnostics, graph?, intent?, next }.

    Annotations the server declares

    • readOnlyHint: true
    • destructiveHint: false
    • idempotentHint: true
    • openWorldHint: false

This is not a safety rating, and no finding is not a safety guarantee. The groups and findings come from fixed checks of the tool definitions the server returned on the date shown, not from its code or what it does when called. How the checks work.

Exfil surface

Which tools read private data, which read text someone else can write, and which can send data out. One of each is a path a prompt injection can use.

No private-data, untrusted-input, outbound path in this server alone: no tool is tagged private-data or outbound.

Reads private data0
Reads files, mail, messages, databases, secrets, calendars or repositories.
Reads text others write1
Brings in text someone else can write: web pages, inbound email, messages, issues and comments.
Can send data out0
Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL.

Other servers in the same agent add their own tools to these paths. Audit your whole setup to see them together.

Remote posture

What anyone on the internet sees at the remote endpoint: an anonymous initialize and tools/list, and the public OAuth metadata.

Tools listed without sign-in

Looked at Nov 18, 2026, 16:21 UTC, unchanged since Nov 11, 2026. No credentials were sent and no tool was called. What is looked at.

Reachable
yes
HTTP status of an anonymous initialize
200
tools/list served without credentials
yes
Tools that change things, listed without credentials
7
Protocol version
2025-06-18
WWW-Authenticate on 401
not observed
resource_metadata in WWW-Authenticate
not observed
RFC 9728 protected resource metadata
not observed
Authorization servers
not observed
Legacy HTTP+SSE transport
no
Dynamic client registration
not observed
Client ID metadata documents
not observed
  • WarnThe whole server

    The endpoint served tools/list without credentials, and the list has 7 tools that change things (7 write). Whether a call also works without credentials was not tested: tools are never called.

    Matched text

    https://mcp.archlang.uk/mcp: tools/list returned 12 tools to an anonymous client, including compile (write), score (write), repair (write), fix (write), finish (write) and 2 more

    What this check looks for

Findings

Matches of fixed checks, with the text they matched.

3 warn
  • Warnfix

    The server marks "fix" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false}; The description's first verb is "apply": a word for a change.

    What this check looks for
  • The server marks "explain" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false}; The name "explain" says "explain": a word for reading.

    What this check looks for
  • Warnlink

    The server marks "link" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"destructiveHint":false,"idempotentHint":true,"openWorldHint":false}; The name "link" says "link": a word for a change.

    What this check looks for

History

Changes to its tool definitions and to its remote endpoint, newest first.

  1. Tools1 added, 1 changed.+1 added~1 changedView diff
  2. Tools1 changed.~1 changedView diff
  3. Tools2 changed.~2 changedView diff
    • Changed:compileChanges thingsdescription
    • Changed:validateOnly readsdescriptioninputSchema

Install

Pinned to version 0.2.49. Values in angle brackets are yours to fill in.

claude mcp add --transport http archlang https://mcp.archlang.uk/mcp
claude mcp add --transport http archlang https://mcp.archlang.uk/mcp

Run in a terminal.

Claude Code permissions

Allow the reads, ask before a change or a way out, deny the deletes. Paste into .claude/settings.json.

.claude/settings.json
{
  "permissions": {
    "allow": [
      "mcp__archlang__describe",
      "mcp__archlang__lint",
      "mcp__archlang__validate",
      "mcp__archlang__complete",
      "mcp__archlang__read_me"
    ],
    "ask": [
      "mcp__archlang__compile",
      "mcp__archlang__score",
      "mcp__archlang__repair",
      "mcp__archlang__fix",
      "mcp__archlang__finish",
      "mcp__archlang__suggest",
      "mcp__archlang__explain",
      "mcp__archlang__link"
    ],
    "deny": []
  }
}

Tools that only read are allowed, tools that change things ask first, tools that delete or cancel are denied. A read that can send data out (it takes a URL, say) asks first too. It assumes the server is installed as archlang. Review it before you use it.

Capability tags behind 1 rule
  • mcp__archlang__read_me untrusted-input

Pin

Keep the decision: fail CI when the tools change, follow every change, or show a badge.

Pin in CI

Fail a build when the tools you reviewed are not the tools the server serves today.

curl -s "https://radar.anlyon.com/api/v1/servers/io.github.ChanMeng666/archlang-mcp/verify?hash=58971dede587cdd842c5785fc22adf5978bcf4521a32e7725520310e1044b748" | jq -e '.changed == false'

Pinned hash 58971dede587, from Nov 21, 2026, 03:18 UTC.

Watch

Get told when its tools change: a new tool, a new description, a new class.

https://radar.anlyon.com/servers/io.github.ChanMeng666/archlang-mcp/changes.xml

An Atom feed. Works in any feed reader or Slack's RSS app.

Badge

Anlyon Radar badge for io.github.ChanMeng666/archlang-mcp
[![Anlyon Radar](https://radar.anlyon.com/badge/io.github.ChanMeng666/archlang-mcp.svg)](https://radar.anlyon.com/servers/io.github.ChanMeng666/archlang-mcp)

Source: MCP Registry · repository. Synced Nov 21, 2026, 03:17 UTC.

ArchLang MCP server: questions and answers

Answered from the scan above, not from the publisher's description.

Is the ArchLang MCP server safe?

No scan can promise that. What its definitions show: 13 tools, 8 of which can change, send or delete something, and 3 findings from fixed checks. Allow the reads, ask before each change, and deny the deletes; the permissions block on this page does that.

Can the ArchLang MCP server delete data?

No tool is classed as destructive: going by their definitions, none of them deletes, cancels or revokes anything.

Can the ArchLang MCP server do things that cannot be undone?

No tool is classed as irreversible: none of them sends, pays, publishes or merges, going by their definitions.

What tools does the ArchLang MCP server have?

13 tools: 8 write, 5 read. compile, score, repair, fix, finish, suggest, explain, link and 5 more.

Does the ArchLang MCP server need sign-in or OAuth?

Its remote endpoint listed its tools to an anonymous client, without sign-in.

Does the ArchLang MCP server send data to outside services?

None of its tools sends, posts or publishes, or takes a recipient, channel or URL.

Has the ArchLang MCP server changed its tools?

Yes, 3 times since Anlyon Radar started tracking it, most recently on Nov 21, 2026. Every change is on this page and in its Atom feed.