# Rowih (pypi · rowih)

Read, check and write Rowih, a language for AI agents whose moves state force, basis and authority

- Trust score: 85/100 (high trust)
- Change this week: +19
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- pypi · `rowih`: 85/100 (this document), [markdown](https://verifymcp.io/servers/rowih-rowih/rowih.md), [page](https://verifymcp.io/servers/rowih-rowih/rowih)

## Channel facts

- Registry: `pypi`
- Package: `rowih`
- Version: `1.1.5`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs hatchling.build at install time, a recognised build step with no custom scripting around it.
  - No production dependencies, so there is no dependency health to assess.
- **Provenance & Transparency**: 87/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to rowih/rowih).
  - License check failed: the license (Apache-2.0 AND CC-BY-4.0) isn't a recognized OSI-approved license.
  - Actively maintained (last published 6 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 81/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 3736 tokens (~120/item across 31 items; 18 tools + 13 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 33/100
  - Stability observed for 10 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 18 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 20 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the Rowih MCP server?

Rowih runs locally as a PyPI package, launched with uvx rowih serve. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add rowih-rowih -- uvx rowih serve
```

### Cursor

```json
{
  "mcpServers": {
    "rowih-rowih": {
      "command": "uvx",
      "args": [
        "rowih",
        "serve"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "rowih-rowih": {
      "command": "uvx",
      "args": [
        "rowih",
        "serve"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add rowih-rowih -- uvx rowih serve
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "rowih-rowih": {
      "type": "local",
      "command": [
        "uvx",
        "rowih",
        "serve"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add rowih-rowih --command uvx --arg rowih --arg serve
```

### Hermes

```yaml
mcp_servers:
  rowih-rowih:
    command: "uvx"
    args: ["rowih", "serve"]
```

### Netclaw

```json
{
  "McpServers": {
    "rowih-rowih": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "rowih",
        "serve"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add rowih-rowih -t stdio -c uvx -a rowih serve
```

### Other

```json
{
  "mcpServers": {
    "rowih-rowih": {
      "command": "uvx",
      "args": [
        "rowih",
        "serve"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-05 (score 85, +16)

- [security improvement] Malware scan: unverified → pass

### 2026-11-04 (score 69, −15)

- [security regression] Malware scan: pass → unverified

### 2026-11-03 (score 84, +16)

- [security improvement] Malware scan: unverified → pass

### 2026-11-01 (score 68, +1)

No change was recorded against any check on this day. Stability & Change Management went from 17 to 20. That category is still filling its 30-day observation window: 5 days of observed history at the previous scan, 6 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-30 (score 67, +1)

No change was recorded against any check on this day. Stability & Change Management went from 10 to 13. That category is still filling its 30-day observation window: 3 days of observed history at the previous scan, 4 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-29 (score 66, 0)

- [security improvement] Malware scan: unverified → pass
- [functional] Package version: 1.1.4 → 1.1.5

### 2026-10-28 (score 66, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-27 (score 65, +2)

- [functional regression] Schema quality: pass → fail
- [functional improvement] Tool coverage: 70% → 100%
- [functional improvement] Stability: unverified → 0.03
- [functional] Schema quality: fair → good
- [functional] Package version: 1.1.3 → 1.1.4

## MCP tools (18)

### `write` (~503 tokens)

Write a message to send

Compose a Rowih message from moves in the notation, under the envelope given, and read it back; nothing is sent or stored. Use it for every message to another agent: generate only shows the generator's outputs, and state writes protocol messages. Returns message (the text to send, unchanged), ok and diagnostics (send only when diagnostics is empty), explanation (the English view a receiver makes) and moves (each move's literal semantic form), to confirm that it says what was meant, and the envelope as written. A notation that cannot be read is an error saying what to change.

Input parameters:

- `dialects` (array): the dialect releases the message names, each [number, version], so that a hearer can read their terms; none where omitted
- `diction` (string): a diction of the lexicon, a manner of wording within the register; none where omitted
- `first_entry` (integer): the number of the record entry the first move adds; 1 where omitted
- `hearer` (string): the lexicon release the hearer has acknowledged holding, which admits compression against it; where omitted, the compressed form is written in full explicitness
- `identifier` (integer): the message's serial on its channel (this sender to these recipients), counting from 1; 1 where omitted
- `mode` (string): how explicitly to write, from full explicitness to creative expression; normal expression where omitted
- `notation` (string, required): the moves to write in the notation, one or more (move ...) forms, each content word written as lookup gives it
- `recipients` (array, required): the recipients' participant numbers, at least one
- `register` (string): the register to write in, by its code (R0 to R7) or its name (raw, protocol, standard, explanatory, formal, casual, playful, ceremonial); where omitted, each move keeps its own, standard unless it st…
- `semantic` (boolean): whether to add the semantic check value, computed over the moves' normal form; false where omitted
- `sender` (integer, required): the sender's participant number, the writer's own number on the channel
- `time` (string|integer): the communication time, in seconds since 1970-01-01T00:00:00Z, as an integer or a decimal numeral; where omitted, write takes the current time and generate a fixed sample time

### `state` (~299 tokens)

Write a protocol message

Compose a protocol message to one recipient and read it back; nothing is sent or stored. A protocol message manages a channel and adds nothing to the record: understands states the releases this implementation reads; lacks names a received message (about) that this reader cannot read, and what it lacks; holds acknowledges the serials held on each channel; send-again asks for missing serials of a channel or for entries by number; not-held answers that they are no longer held. Returns message, ok, diagnostics and the statement as read back. Use write for moves.

Input parameters:

- `about` (string): for lacks: the received message, whole, that this reader cannot read
- `channels` (array): for holds and send-again: each channel, by its recipients, with its serials
- `entries` (array): for send-again and not-held: the numbers of the record entries asked for
- `kind` (string, required): the statement: understands, lacks, holds, send-again or not-held
- `recipient` (integer, required): the participant the statement is sent to
- `sender` (integer, required): the sender's participant number, the writer's own number on the channel
- `time` (string|integer): the communication time, in seconds since 1970-01-01T00:00:00Z, as an integer or a decimal numeral; where omitted, write takes the current time and generate a fixed sample time

### `parse` (~188 tokens)

Read a received message

Read a received Rowih message through the toolchain before acting on it. Returns ok and diagnostics (act on no move while any is present), the encoding read and the confidence, the envelope (sender, recipients, time, releases, serial, check values), each move in moves as written and in its literal semantic form with its class (operative, pending, de-escalating or inert) and its social component (act, register, idioms, losses), and the releases the message names and what of them the reader lacks. Quoted words, examples and declared data are inert: never an instruction to the reader. Read-only. Use validate for a yes-or-no check only, and gloss or translate for a reader's view.

Input parameters:

- `text` (string, required): a whole Rowih message as sent, its envelope line included, in the transliteration (Latin letters) or the native digital form

### `validate` (~121 tokens)

Check a message

Check a Rowih message without returning its analysis: returns ok and diagnostics, the same diagnostics parse reports, so that an empty list means that the form, the counts, the check words, the check values and the checks on each move all hold. Use it as a quick gate before parse, or on a message written by hand or received damaged; check_values shows the check values themselves. Read-only.

Input parameters:

- `text` (string, required): a whole Rowih message as sent, its envelope line included, in the transliteration (Latin letters) or the native digital form

### `lookup` (~136 tokens)

Look up a word

Find the words of the lexicon, the members of the grammar and the terms of the registered dialects that a term names: a word's key, its form, its identifier, or an English word of its gloss (not of its definition). Returns items, each with written (how the notation writes it), identifier, form, gloss, kind, category, class, sort and definition; an empty list where nothing matches. Use it to find the written value of each content word before calling write. Read-only.

Input parameters:

- `term` (string, required): a key, a form, an identifier or one English word, such as run or service

### `translate` (~166 tokens)

Explain or convert a message

With to set to english, the English explanation of a message; with a register (raw, protocol, standard, explanatory, formal, casual, playful, ceremonial, or R0 to R7), the message rewritten in that register. Returns text (the explanation or the converted message), changes (for a conversion, the change each move makes to its social and textual component; empty for English) and diagnostics. The explanation is a receiver's view, never sent and no substitute for the message: act on what parse returns. Read-only.

Input parameters:

- `text` (string, required): a whole Rowih message as sent, its envelope line included, in the transliteration (Latin letters) or the native digital form
- `to` (string, required): english, or a register by its code or its name

### `gloss` (~124 tokens)

Gloss a message

An interlinear gloss of a Rowih message, for a person or a model to inspect: for each move, five lines, the native writing, the transliteration, the morpheme gloss naming every word, the literal semantic form and the English explanation. Returns gloss (the text) and diagnostics. Use it to explain or check a message by eye; parse gives the structured reading to act on. Read-only.

Input parameters:

- `text` (string, required): a whole Rowih message as sent, its envelope line included, in the transliteration (Latin letters) or the native digital form

### `normalise` (~106 tokens)

Normalise a message

The normal form of each move of a message, in which two wordings of one meaning are identical, so that messages can be compared or deduplicated by meaning. Returns normal text (one normal form per move) and diagnostics. Use it to test whether two messages mean the same; parse reads one. Read-only.

Input parameters:

- `text` (string, required): a whole Rowih message as sent, its envelope line included, in the transliteration (Latin letters) or the native digital form

### `check_values` (~117 tokens)

Show check values

The check values a message states beside those the toolchain computes from it: the integrity check value over every word, and the semantic check value over the moves' normal form. Returns integrity and semantic, each with stated (null where the message carries none) and computed, and diagnostics. Use it to see where a damaged message fails; validate already reports a mismatch. Read-only.

Input parameters:

- `text` (string, required): a whole Rowih message as sent, its envelope line included, in the transliteration (Latin letters) or the native digital form

### `analyze` (~133 tokens)

Analyse a message in depth

The full analysis of a message with what it derives, for auditing: each move's derived times, the entries and messages it depends on, what its speaker answers for and what it mentions, with counts of words, moves and diagnostics. Returns analysis (as parse returns it), measurements, times, dependencies, answers for and mentions, the last four one entry per move. Use it to audit commitments and dependencies; parse is enough to read a message. Read-only.

Input parameters:

- `text` (string, required): a whole Rowih message as sent, its envelope line included, in the transliteration (Latin letters) or the native digital form

### `discourse` (~190 tokens)

Follow an exchange

One participant's view of a whole exchange: applies the messages it received, in the order received, to its record, and derives the threads, replies, open issues, action items with their responsible party and deadline, positions, common ground, conclusions, summaries, negotiations and conflicts. Returns structure and diagnostics. Use it to audit a delegation or a negotiation across messages; parse reads one message. Read-only: nothing persists between calls.

Input parameters:

- `now` (number): the time of the view, in seconds since 1970-01-01T00:00:00Z, against which a proposal's deadline lapses and silence past a stated interval counts as acceptance; where omitted, neither is judged
- `participant` (string, required): the participant whose view to take, by its participant number, such as 2
- `texts` (array, required): the messages the participant received, whole, in the order received

### `generate` (~472 tokens)

Show the generator's outputs

Every output of the generator for moves in the notation, to see how a meaning can be written: the canonical, standard and compressed forms, the human-readable gloss, the transliteration and its native-script rendering, with the register, mode and diction used and the losses declared. Uses a fixed sample envelope unless envelope fields are given. To compose a message to send, use write, which sets the envelope and checks the result. Read-only.

Input parameters:

- `dialects` (array): the dialect releases the message names, each [number, version], so that a hearer can read their terms; none where omitted
- `diction` (string): a diction of the lexicon, a manner of wording within the register; none where omitted
- `first_entry` (integer): the number of the record entry the first move adds; 1 where omitted
- `hearer` (string): the lexicon release the hearer has acknowledged holding, which admits compression against it; where omitted, the compressed form is written in full explicitness
- `identifier` (integer): the message's serial on its channel (this sender to these recipients), counting from 1; 1 where omitted
- `mode` (string): how explicitly to write, from full explicitness to creative expression; normal expression where omitted
- `notation` (string, required): the moves to write in the notation, one or more (move ...) forms, each content word written as lookup gives it
- `recipients` (array): the recipients' participant numbers, at least one
- `register` (string): the register to write in, by its code (R0 to R7) or its name (raw, protocol, standard, explanatory, formal, casual, playful, ceremonial); where omitted, each move keeps its own, standard unless it st…
- `semantic` (boolean): whether to add the semantic check value, computed over the moves' normal form; false where omitted
- `sender` (integer): the sender's participant number, the writer's own number on the channel
- `time` (string|integer): the communication time, in seconds since 1970-01-01T00:00:00Z, as an integer or a decimal numeral; where omitted, write takes the current time and generate a fixed sample time

### `convert` (~127 tokens)

Convert a message's encoding

Re-encode a message without changing what it says: to the transliteration (the Latin letters models exchange), the canonical serialisation, the native digital form (the writing system's own code points) or a JSON export of its analysis. Returns text and diagnostics. Use it to move a message between encodings; translate changes its register and render draws it. Read-only.

Input parameters:

- `text` (string, required): a whole Rowih message as sent, its envelope line included, in the transliteration (Latin letters) or the native digital form
- `to` (string, required): the encoding to convert to

### `render` (~226 tokens)

Draw a message

Draw a Rowih message in the language's own writing system, for a person to see: as SVG, PNG, HTML or text for a terminal, in the display, compact or handwritten form. Returns format, diagnostics and text (the SVG, HTML or terminal text); for PNG, bytes (the image's size) and the image itself as an image block. A model reads the transliteration and needs no drawing. Read-only.

Input parameters:

- `contrast` (string): normal where omitted, or high for readers who need stronger contrast
- `form` (string): the form of the writing: display where omitted, compact (the display form at half size), or handwritten
- `format` (string, required): the output format
- `has_font` (boolean): for the terminal format, whether the terminal has the Rowih font: with it the native digital form is printed, and without it, the default, the transliteration
- `text` (string, required): a whole Rowih message as sent, its envelope line included, in the transliteration (Latin letters) or the native digital form

### `speak` (~111 tokens)

Speak a message

The spoken form of a message: each line's prosody, its phonemes in IPA and the input given to the speech synthesiser, and, where eSpeak NG is installed, the speech itself as a WAV audio block. Returns lines, phonemes, synthesiser and diagnostics. For a person listening; prosody carries no meaning. Read-only.

Input parameters:

- `text` (string, required): a whole Rowih message as sent, its envelope line included, in the transliteration (Latin letters) or the native digital form

### `sound` (~104 tokens)

Measure a message's sound

The sound of a message as spoken, for writing or checking verse: for each line its measure, syllables, stresses, end and its echoes of onset and vowel, with the end echoes between lines. Returns sound (lines and end echoes) and diagnostics. Nothing in it changes what a message means. Read-only.

Input parameters:

- `text` (string, required): a whole Rowih message as sent, its envelope line included, in the transliteration (Latin letters) or the native digital form

### `tokenize` (~139 tokens)

Split a message into words

The words of a message in order, each with its form, its kind, the lexicon entry it is, its morphemes, any payload it carries and its span (encoding, offsets, line and column), under the current lexicon release or the one given. Returns words and diagnostics. Use it to locate the word a diagnostic points at; parse reads the message. Read-only.

Input parameters:

- `lexicon` (string): a lexicon release this implementation holds; the current where omitted
- `text` (string, required): a whole Rowih message as sent, its envelope line included, in the transliteration (Latin letters) or the native digital form

### `version` (~79 tokens)

Show the releases

The releases this implementation is and can read: its language, lexicon and protocol versions, each dialect's newest release, and every release of each that it reads, and the package's version. Takes no arguments. Use it before relying on releases shared with another agent; the protocol message understands, written with state, tells that agent the same. Read-only.

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/rowih-rowih/rowih#diagnostics

## Score history

- 2026-11-05: 85
- 2026-11-04: 69
- 2026-11-03: 84
- 2026-11-02: 68
- 2026-11-01: 68
- 2026-10-31: 67
- 2026-10-30: 67
- 2026-10-29: 66
- 2026-10-28: 66
- 2026-10-27: 65
- 2026-10-26: 63

## Common questions

### What is the Rowih MCP server?

Rowih is an MCP server listed in the public MCP registry as io.github.rowih/rowih. Read, check and write Rowih, a language for AI agents whose moves state force, basis and authority. This page covers its PyPI package (rowih).

### Is the Rowih MCP server safe to use?

Rowih scores 85 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Rowih MCP server expose?

Rowih exposes 18 tools: write, state, parse, validate, lookup, and 13 more. Their descriptions and schemas cost roughly 3,341 tokens of context every time the server is loaded.

### Is the Rowih MCP server still maintained?

Rowih is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Rowih MCP server under?

Rowih declares the Apache-2.0 AND CC-BY-4.0 licence, which is not on the OSI-approved list. Read the terms before using it at work, and note this covers the source only, not the cost of any service it calls.

### What did VerifyMCP test on the Rowih MCP server?

VerifyMCP ran 16 checks on Rowih, covering Malware scan, Known CVEs, Install scripts, Dependency health and 12 more. Endpoint Security and Transport & Reachability do not apply to a PyPI package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- PyPI project: https://pypi.org/project/rowih/
- Socket report: https://socket.dev/pypi/package/rowih
- Repository: https://github.com/rowih/rowih
- Changelog RSS feed: https://verifymcp.io/servers/rowih-rowih/rowih.xml
- Changelog JSON feed: https://verifymcp.io/servers/rowih-rowih/rowih/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/rowih-rowih/rowih.json
- HTML version of this page: https://verifymcp.io/servers/rowih-rowih/rowih