mcpbeat Sign in

arifOS — Constitutional AI Kernel MCP Server

answering

arifOS — Constitutional AI Kernel is answering right now. Last checked 5 min ago. It exposes 9 tools. Last commit 1 Nov 2026.

Constitutional verdict layer for AI agents. SEAL/HOLD before mutation. F1-F13 floors; audit ledger.

Uptime history 91 days of history · worst day 20%
91 days agonow
100.0%
Uptime 24h
183 of 183 checks
9
Tools
read from the server
976 ms
Response time
average over 24h
54
Stars
last commit 1 Nov 2026

What changed 612

Every tool that appeared, vanished or quietly changed what it asks for. Recorded since 9 August 2026. No other catalogue keeps this.

3 Nov 4 tool descriptions were rewritten arif_forge, arif_init, arif_memory and 1 more
3 Nov a tool changed version4 times that day
2 Nov a tool changed version16 times that day
1 Nov a tool changed version4 times that day
31 Oct a tool changed version2 times that day
30 Oct a tool changed version10 times that day
29 Oct a tool changed version20 times that day
29 Oct 5 tools disappeared arif_delegate, arif_recall, arif_research and 2 more
29 Oct a tool changed the parameters it asks for arif_observe
28 Oct 8 tool descriptions were rewritten arif_forge, arif_init, arif_judge and 5 more
and 588 more, back to 9 August 2026

What the code does

We read the source, 6 h ago · tools taken from the live server · rules 995398eba69f

A tool parameter reaches a dangerous call

A value the model can set ends up inside a file or shell call. That is not a flaw by itself — for a terminal server it is the job — but it is where things go wrong when it is not.

A tool parameter reaches a dangerous call oracle_world.path → arifosmcp/tools/reality.py:121, oracle_world.path → arifosmcp/tools/reality.py:133, arif_kernel_check.action → commands/arif-systemctl.py:86
                result = subprocess.run(
Evidence

Things with no honest explanation: a promise that contradicts the code, code that runs at install time while hiding what it does, data leaving the machine.

Capabilities

What this server is able to do. For an MCP server this is often the job itself — a terminal server runs commands because that is what it is for. Listed so you know what you are plugging in, not as an accusation.

Installs itself into autostart arifosmcp/tools/judge.py:1576
        "/etc/cron.d",
        path = os.path.join(OUT_DIR, f"{component}.md")
    Path("/root/.ssh/operator_did_ed25519.pub"),
Sends data to a third-party sink arifosmcp/integrations/telegram_bridge.py:37
TELEGRAM_API_BASE = "https://api.telegram.org"
    for d in Path(APPROVED_VENV_SITE_PACKAGES).iterdir():
Image downloads and pipes straight to shell Dockerfile:99
RUN curl -fsSL https://deb.nodesource.com/setup_22.x | bash - && \
In the project's build, not in the package

Found in continuous integration, deployment or infrastructure files, or in a neighbouring package of the same monorepo. None of this is installed when you add the server: it describes how the project is built and released. We list it because a leaked key in a build pipeline is still a real problem, but it is not something this server does on your machine.

CI pipeline leaks secrets outward .github/workflows/prune-images.yml:41
          TOKEN=$(curl -s -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" \
      - /var/run/docker.sock:/var/run/docker.sock:ro

Is this your server and something here is wrong? Tell us — corrections are free and do not require a plan.

A tool parameter here reaches a dangerous call

That is not a flaw by itself — but it is where things go wrong when it is not the job. We re-read this code on every release. Watch it and you hear from us the day another one appears.

Three servers free · no card

Connect this server

Endpoint below is the one we actually reach during checks — not the one copied from a README. Last verified 5 min ago.

run in your terminal
claude mcp add arifos --transport http https://arifos.arif-fazil.com/mcp
Settings → Connectors → Add custom connector, then paste this address
https://arifos.arif-fazil.com/mcp
~/.codex/config.toml
[mcp_servers.arifos]
url = "https://arifos.arif-fazil.com/mcp"
.cursor/mcp.json
{
  "mcpServers": {
    "arifos": {
      "url": "https://arifos.arif-fazil.com/mcp"
    }
  }
}
.vscode/mcp.json
{
  "servers": {
    "arifos": {
      "type": "http",
      "url": "https://arifos.arif-fazil.com/mcp"
    }
  }
}

This server publishes 1 more address. The block above uses the one we reach during checks; the full list is under Endpoints below, and the author may intend a particular one for your client.

Available tools 9

Read directly from the server with tools/list, grouped by what they act on. If a tool disappears, we record the date.

arif
arif_forge
Execute an action arif_judge has already SEALed — nothing runs without seal_verdict_id and approved_action_hash matching the judged action. Modes: engineer (default; plan and apply — requires manifest), dry_run (preview, no side effects; manifest or query), query (read-only), write (write files), generate (generate code/content), commit (commit prepared work), recall (retrieve past forge artifacts). Irreversible judged actions additionally require ack_irreversible=true. On missing seal or hash mismatch the call returns REFUSED with no change made. Outputs: execution receipt (receipt_id, status, actor_id, timestamp).
arif_init
Ignite or resume a governed session. Returns session_id and session_token required for subsequent operations. Modes: init (default new session), preflight (inspect existing session state), resume (continue active session), validate (re-check credentials), canary (transport probe), triage (read session state), epoch_open/epoch_seal (bracket a long working window), light (minimal session), opt_out (privacy opt-out). Outputs: session credentials and allowed next tools. To END a governed session, call arif_seal(mode=session_close) — session closure is a ledger event, not an init mode.
arif_judge
Evaluate proposed operations against policy and safety constraints. Weighs blast radius, reversibility, and permission level. Returns binding verdict (SEAL for approved, HOLD for blocked, SABAR for awaiting conditions). Approval verdict is required prior to calling arif_forge. Outputs: evaluation verdict and authorization receipt.
arif_memory
Access and maintain persistent institutional knowledge across sessions. Modes: recall (retrieve relevant context), inspect (read one memory in full), attest (vouch for a memory's accuracy), remember (store new text), promote (move a memory up a tier), revise (replace a memory's text), forget (remove a memory, gated), audit (integrity scan), metabolize (compact and consolidate tiers). Writes to permanent tiers require explicit approval. Outputs: scoped memory entries.
arif_observe
Collect evidence, reality observations, and operational facts with provenance. Modes: search (web literature queries), fetch (targeted URL retrieval), vitals (system metrics). Requires valid session credentials. Outputs: structured facts, source attribution, and epistemic tags.
arif_report
AGENT REPORT LANE · File or read reports between agents without involving the human. Use when your work is done, when you are blocked by another agent, or when you need to tell peers a fact. modes: report (file), inbox (read peers), ack, flush, stats. kind=fyi|peer|done|claim stay in the peer lane; ONLY kind=decision or kind=blocked reach the sovereign, and only in one coalesced message. Reports are SELF_REPORTED — probe before relying on one.
arif_route
Classify intent and route tasks to domain organs (GEOX for Earth science, WEALTH for capital markets, WELL for human vitality, A-FORGE for execution). Requires valid session credentials. Outputs: organ dispatch envelope.
arif_seal
Appends a receipt to the VAULT999 immutable ledger. This is NOT a verdict and does not authorize anything — verdicts come only from arif_judge. Modes: seal (default; permanent append, requires payload and seal_purpose), verify (check one entry), ledger (read the ledger head), changelog (recent appends), audit (integrity check), session_close (close out a session into the ledger). Write modes require ack_irreversible=true. Outputs: immutable ledger entry receipt.
arif_think
Execute structured reasoning and plan formulation. Decomposes inquiries into verified derivations. Modes: reason (inquiry breakdown), plan (drafting multi-step execution steps), verify (logical proof check). Requires valid session credentials. Outputs: structured reasoning record.

Tools removed

Tools this server used to expose. Anything built against them stopped working on the day they went.

arif_delegate
removed 29 Oct 2026
arif_recall
removed 29 Oct 2026
arif_research
removed 29 Oct 2026
read_resource
removed 29 Oct 2026
search_resources
removed 29 Oct 2026

Endpoints

URLTransportStateLatencyChecked
https://arifos.arif-fazil.com/mcp streamable-http answering 621 ms 5 min ago
https://mcp.arif-fazil.com/mcp streamable-http answering 820 ms 5 min ago

Alternatives to arifOS — Constitutional AI Kernel

same job, measured the same way
Ac Jobs
by wchampe

Admission gate for AI agents: submit a step, get admit/hold/reject vs your constitution.

145 installs/wk local only
aictrl
by vasparshin

Governance layer for AI coding agents: knowledge-graph grounding, session audit, policy controls.

answering
Agent Guard
by mdfifty50-boop

Constitutional guardrails and loop detection for AI agents

69 installs/wk local only
Firekeep
by kapella-hub

Self-hosted operating layer for AI agents: knowledge, continuity, coordination, and governance.

474 installs/wk local only
Aaa MCP
by ariffazil

Constitutional AI Governance with 13 enforced floors (F1-F13) and tri-witness consensus for LLMs.

local only
Haldir
by exposureguard

Guardian layer for AI agents: identity, secrets, audit via MCP.

127 installs/wk local only
Glassbox Framework
by thebarmaeffect

Runtime constitutional verification for AI answers — claim reasoning, ECS, red team, audits.

55 installs/wk local only
Co Eli MCP
by matematicsolutions

MCP server for Colombian Constitutional Court case law (datos.gov.co), citation verification.

118 installs/wk local only

arifOS — Constitutional AI Kernel — questions

Answers built from our own checks of this server.

What can arifOS — Constitutional AI Kernel do?
It exposes 9 tools, read directly from the server on our last check. Among them: arif_forge, arif_init, arif_judge, arif_memory, arif_observe, arif_report and 3 more. The full list with descriptions is on this page — we take it from the server itself via tools/list, not from a README. How MCP servers expose tools in the first place →
Is arifOS — Constitutional AI Kernel working right now?
We send a real MCP handshake every 15 minutes. Over the last 24 hours 183 of 183 checks got a reply (100.0%), average response time 976 ms. The bar chart above shows every period we have measured.
Did arifOS — Constitutional AI Kernel ever remove tools?
Yes. arif_delegate, arif_recall, arif_research, read_resource and 1 more are no longer exposed — we recorded the date each one disappeared. A tool vanishing usually means a breaking change for anything that depended on it.
How do I connect arifOS — Constitutional AI Kernel?
Copy the ready config from this page. We generate it for Claude Code, Claude Desktop, Codex, Cursor and VS Code, each in the form that client actually reads. It is a remote server, so there is nothing to install — the client connects to the address.
Does arifOS — Constitutional AI Kernel need an API key?
No. arifOS — Constitutional AI Kernel completed a full MCP handshake with us as an anonymous client and listed its tools without asking for anything. All 9 of them are readable on this page. This is what we observed, not what the docs claim.
How fast is arifOS — Constitutional AI Kernel?
It answers our handshake in 976 ms on average, which is faster than 7% of all working MCP servers we measure. That is on the slow side — worth knowing if the tool sits inside an interactive loop. The comparison comes from our own checks across the whole registry, every 15 minutes.
Is arifOS — Constitutional AI Kernel open source?
The code is open source: it is published under the AGPL-3.0 licence, written in Python, 54 stars on GitHub and 5 open issues. The licence covers the code in the repository, not the hosted service at arifos.arif-fazil.com, which runs on its operator's own terms.