# io.github.vlad-public-code/valem (remote · valem.run)

Valem - Deterministic reactive state models. Create your own calculators/forms with AI

- Trust score: 83/100 (high trust)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-22

## Components

- remote · `valem.run`: 83/100 (this document), [markdown](https://verifymcp.io/servers/vlad-public-code-valem/valem.md), [page](https://verifymcp.io/servers/vlad-public-code-valem/valem)

## Channel facts

- Endpoint: `https://valem.run/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, 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-09-22.

- **Endpoint Security**: 63/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation check failed: no authorisation is required to call this server, and it exposes a tool marked destructive (restore).
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 89/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Tool/resource definitions use about 4335 tokens (~80/item across 54 items; 27 tools + 27 resources), lean.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 100/100
  - No destabilizing schema changes in the last 30 days.
- **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.
  - Structured output schemas are declared (74% of tools); any adoption earns full credit.
- **Tool Safety**: 88/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 1 of 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "eval_expression" implies "eval" and declares readOnlyHint instead, contradicting what its own name says it does.
  - An AI judge read all 29 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the io.github.vlad-public-code/valem MCP server?

io.github.vlad-public-code/valem is a hosted endpoint at https://valem.run/mcp, so there is nothing to install locally. 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 --transport http vlad-public-code-valem 'https://valem.run/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "vlad-public-code-valem": {
      "url": "https://valem.run/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "vlad-public-code-valem": {
      "type": "http",
      "url": "https://valem.run/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.vlad-public-code-valem]
url = "https://valem.run/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "vlad-public-code-valem": {
      "type": "remote",
      "url": "https://valem.run/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add vlad-public-code-valem --url 'https://valem.run/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  vlad-public-code-valem:
    url: "https://valem.run/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "vlad-public-code-valem": {
      "Transport": "http",
      "Url": "https://valem.run/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add vlad-public-code-valem -t streamable-http -u 'https://valem.run/mcp'
```

### Other

```json
{
  "mcpServers": {
    "vlad-public-code-valem": {
      "type": "http",
      "url": "https://valem.run/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## 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-09-21 (score 83, +1)

- [security] Stability: 0.97 → pass

### 2026-09-19 (score 82, +1)

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

### 2026-09-17 (score 81, +1)

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

### 2026-09-15 (score 80, +1)

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

### 2026-09-13 (score 79, +1)

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

### 2026-09-11 (score 78, +1)

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

### 2026-09-10 (score 77, +8)

- [security improvement] Judged manipulation: unverified → pass
- [functional improvement] Schema quality: unverified → excellent

### 2026-09-09 (score 69, −7)

- [security regression] Judged manipulation: pass → unverified
- [functional regression] Schema quality: excellent → unverified

## MCP tools (27)

### `list_models` (~22 tokens)

List models

List the ids of all currently registered Valem models (alphabetical).

### `create_model` (~185 tokens)

Create model

Create a new model from a declarative ModelSpec. The spec carries the JSON schema plus derivations (computed fields), constraints (invariants), and optional effects. Returns the created id. Fails (isError) on an invalid spec. If the requested id is already taken, a numeric postfix (-2, -3, …) is appended so the create still succeeds — always read the returned id, it may differ from the one you sent. When paired with a browser (remote_with_browser mode), ALWAYS include a viewDefinition in the spec so the model is immediately visible/usable in the sandbox — do not omit it and wait to be asked for one afterward. See the valem://guide/view-system resource for the component catalog.

Input parameters:

- `spec` (object, required): A full ModelSpec document (id, schema, derivations, constraints, effects, defaultValues, views).

Output parameters:

- `constraintCount` (integer): Number of constraints.
- `derivationCount` (integer): Number of derivations.
- `effectCount` (integer): Number of effects.
- `id` (string): The model id.
- `metaDerivationCount` (integer): Number of meta-derivations.
- `version` (string): The spec version.

### `get_model_info` (~40 tokens)

Get model info

Get summary info for a model: id, version, and derivation/meta/constraint/effect counts.

Input parameters:

- `id` (string, required): The model id.

Output parameters:

- `constraintCount` (integer): Number of constraints.
- `derivationCount` (integer): Number of derivations.
- `effectCount` (integer): Number of effects.
- `id` (string): The model id.
- `metaDerivationCount` (integer): Number of meta-derivations.
- `version` (string): The spec version.

### `get_spec` (~29 tokens)

Get model spec

Get the full stored ModelSpec JSON for a model.

Input parameters:

- `id` (string, required): The model id.

### `get_library` (~80 tokens)

Get model library

List the JSONata functions and values a model's library exports — what an expression in this model may call, with signature, arity and originating layer. Call it before writing an expression so you reuse the model's existing vocabulary instead of re-deriving it. Returns null when the model declares no library.

Input parameters:

- `id` (string, required): The model id.

Output parameters:

- `description` (string): The library's prose description, if any.
- `exports` (array): One entry per exported name: {name, kind ('function'|'constant'), signature, arity, origin}.

### `get_state` (~242 tokens)

Get state

Get a model's merged state (base fields plus all computed derived fields). On a large model this is the biggest context cost — narrow it: pass 'paths' to project only specific subtrees (canonical addresses, each spliced back into a pruned document at its address), and/or 'depth' to cap nesting (deeper containers collapse to a '<object: N fields>' / '<array: N items>' marker). Pass an optional ISO-8601 'at' timestamp for a point-in-time read from mutation history.

Input parameters:

- `at` (string): Optional ISO-8601 instant (e.g. 2026-07-03T12:00:00Z) for a point-in-time read; omit for current state.
- `depth` (integer): Optional max nesting depth; containers deeper than this collapse to a size marker. Applied after 'paths'.
- `id` (string, required): The model id.
- `paths` (array): Optional canonical addresses to project, e.g. ["$.order", "$.totals"]. Only these subtrees are returned, spliced back into a pruned document at their addresses; absent addresses are skipped.

### `get_field` (~69 tokens)

Get field value

Get the value of a single field by its JSON Path address (e.g. "$.order.total"). Evaluates a LAZY derivation on demand.

Input parameters:

- `id` (string, required): The model id.
- `path` (string, required): A canonical JSON Path address, e.g. "$.order.total".

### `mutate` (~194 tokens)

Apply mutations

Apply field mutations to a model and run the reactive pipeline (derivations recompute, constraints enforce, effects dispatch). 'mutations' is a flat map keyed by canonical JSON Path address, e.g. {"$.order.qty": 3}. A ROLLBACK constraint violation returns isError with the structured list of violated constraints. Returns the actionable summary (derivedUpdated / flaggedConstraints / dispatchedEffects); pass includeTraces:true for the full derivation/constraint trace (the same payload 'explain' serves — omit it and call explain only when a value looks wrong).

Input parameters:

- `id` (string, required): The model id.
- `includeTraces` (boolean): Include the full derivation/constraint trace in the result (default false).
- `mutations` (object, required): Map of canonical JSON Path address to new value, e.g. {"$.order.qty": 3, "$.order.discount": 0.1}.

Output parameters:

- `derivedUpdated` (array): Derived paths recomputed.
- `dispatchedEffects` (array): Ids of effects dispatched.
- `flaggedConstraints` (array): Ids of FLAG-policy constraints that fired.
- `metaUpdated` (array): Meta paths recomputed.
- `mutatedPaths` (array): Base paths written.
- `success` (boolean): True when the mutation committed.
- `traces` (array): Full derivation/constraint traces (only when includeTraces:true).

### `patch_model` (~197 tokens)

Patch model

Apply an RFC 6902 JSON Patch document to a model and run the reactive pipeline. Unlike 'mutate' (a flat address→value map), a patch expresses array insert/remove/move and test/copy ops, e.g. [{"op":"add","path":"/order/items/-","value":{...}}, {"op":"remove","path":"/order/items/0"}]. 'path' fields use RFC 6901 JSON Pointer (slash-separated, '-' for array append), NOT the $.-rooted address form. Same result shape and ROLLBACK/schema error handling as 'mutate'.

Input parameters:

- `id` (string, required): The model id.
- `includeTraces` (boolean): Include the full derivation/constraint trace in the result (default false).
- `patch` (array, required): An RFC 6902 JSON Patch: an array of {op, path, value?, from?} operations applied in order.

Output parameters:

- `derivedUpdated` (array): Derived paths recomputed.
- `dispatchedEffects` (array): Ids of effects dispatched.
- `flaggedConstraints` (array): Ids of FLAG-policy constraints that fired.
- `metaUpdated` (array): Meta paths recomputed.
- `mutatedPaths` (array): Base paths written.
- `success` (boolean): True when the mutation committed.
- `traces` (array): Full derivation/constraint traces (only when includeTraces:true).

### `get_effective_schema` (~101 tokens)

Get effective schema

Get the effective JSON Schema for a field: the static schema overlaid with LIVE meta-derived constraints (current min/max/required/…). Check this BEFORE writing a value to learn what the reactive pipeline will accept, instead of discovering an invalid mutation only by trying it and getting a schema-violation error.

Input parameters:

- `id` (string, required): The model id.
- `path` (string, required): A canonical JSON Path address, e.g. "$.order.total".

### `snapshot` (~72 tokens)

Snapshot state

Capture an immutable point-in-time snapshot of a model's state (base document + derived/meta caches). A natural safety step before a risky evolve_spec: keep the returned snapshot and, if the change goes wrong, hand it back to 'restore' to roll the state back.

Input parameters:

- `id` (string, required): The model id.

### `restore` (~77 tokens)

Restore state

Restore a model's state from a snapshot previously returned by 'snapshot' (pass it back verbatim as 'snapshot'). Overwrites the model's current base state. The snapshot must be for the same model.

Input parameters:

- `id` (string, required): The model id.
- `snapshot` (object, required): A snapshot object as returned by the 'snapshot' tool.

### `explain` (~119 tokens)

Explain field

Explain why a field is what it is: returns the recent derivation/constraint trace records for a path from the in-memory ring buffer (inputs, expression, result). For a constraint use the synthetic path "$constraint:<id>". Trace records can be bulky — pass 'limit' to return only the most recent N.

Input parameters:

- `id` (string, required): The model id.
- `limit` (integer): Optional cap; return only the most recent N trace records.
- `path` (string, required): A canonical JSON Path address, e.g. "$.order.total".

### `get_history` (~37 tokens)

Get history

List the ISO-8601 timestamps of a model's committed mutations (most recent 100).

Input parameters:

- `id` (string, required): The model id.

### `get_audit` (~208 tokens)

Get audit trail

Query a model's durable, append-only audit trail (newest-first): one record per committed reactive cycle (mutations, derivedUpdated, traces, flaggedConstraints, dispatchedEffects, source, sequence). This is the queryable superset of get_history/explain — it survives the in-memory ring buffer rolling over. Filter with an optional 'pathPrefix' (canonical address), an ISO-8601 'from'/'to' window, and 'limit'. (Embedded mode keeps this in memory for the session; remote/paired mode reads the server's durable store.)

Input parameters:

- `from` (string): Optional ISO-8601 lower bound (inclusive).
- `id` (string, required): The model id.
- `limit` (integer): Optional max records (default 100, newest-first).
- `pathPrefix` (string): Optional canonical address prefix; keep only records that touched a matching field/derivation/constraint.
- `to` (string): Optional ISO-8601 upper bound (exclusive).

### `verify_audit` (~75 tokens)

Verify audit trail

Verify the tamper-evidence hash chain of a model's durable audit trail. Returns {valid, recordsChecked, firstBrokenSequence, detail}; a false 'valid' points at the first altered/reordered/deleted record. (Embedded mode has no hash chain and reports valid.)

Input parameters:

- `id` (string, required): The model id.

Output parameters:

- `detail` (string): Human-readable explanation ('ok' when valid).
- `firstBrokenSequence` (integer): Sequence of the first broken record, or null.
- `recordsChecked` (integer): Number of records examined.
- `valid` (boolean): True when the whole chain is intact.

### `upload_blob` (~105 tokens)

Upload blob

Store binary content (base64-encoded in 'data') in the content-addressed blob store and get back a BlobRef {$blobId, $mediaType, $bytes} to embed in a model's binary field. Storage is content-addressed (SHA-256), so uploading identical bytes returns the same $blobId.

Input parameters:

- `data` (string, required): The blob content, base64-encoded.
- `mediaType` (string): Optional media type (default application/octet-stream).

Output parameters:

- `$blobId` (string): Content-addressed id (sha256:...).
- `$bytes` (integer): Size in bytes.
- `$mediaType` (string): The stored media type.

### `download_blob` (~102 tokens)

Download blob

Fetch a blob's bytes by id, base64-encoded in the result. Pass 'modelId' to fetch a blob referenced by a specific model (access-scoped); omit it for a direct store fetch. Large blobs may exceed the result-size limit — this channel suits small binaries only.

Input parameters:

- `blobId` (string, required): The blob id (sha256:...).
- `modelId` (string): Optional model id to scope the fetch to a referencing model.

Output parameters:

- `blobId` (string): The requested blob id.
- `bytes` (integer): Size in bytes.
- `data` (string): The blob content, base64-encoded.

### `evolve_spec` (~198 tokens)

Evolve spec

Apply an incremental SpecEvolution diff to a model, preserving live state. Returns the new version. Fails (isError) if the evolved spec is invalid, if expectedVersion no longer matches, or if a schema change would strand existing state. Prefer targeted diffs (upsertSchemaNodes/upsertSchemaDefs, upsertComponents, upsertConstants) over resending a whole section (newSchema/newViewDefinition/newConstants).

Input parameters:

- `evolution` (object, required): A SpecEvolution document: newVersion/expectedVersion plus per-section upsert/remove lists. Schema tiers: upsertSchemaDefs/removeSchemaDefs (by $defs name), upsertSchemaNodes/removeSchemaNodes (by can…
- `id` (string, required): The model id.

Output parameters:

- `id` (string): The evolved model id.
- `version` (string): The model's new version after evolution.

### `delete_model` (~38 tokens)

Delete model

Remove a model from the registry. Fails (isError) if the model does not exist.

Input parameters:

- `id` (string, required): The model id.

Output parameters:

- `deleted` (boolean): True when the model was removed.

### `get_view` (~71 tokens)

Get view

Evaluate a model's embedded view definition against current state and return the resolved component tree. Pass an optional 'viewId' for a named view; omit for the default view.

Input parameters:

- `id` (string, required): The model id.
- `viewId` (string): Optional named view id; omit for the default view.

### `get_domain_guidance` (~473 tokens)

Get domain guidance

Get vetted instructions for the hard modelling shapes this domain involves (progressive tax/fee charges, per-period schedules, classification, date math, group-by, …). Read the model description in ANY language, pick the matching topic ids, and call this BEFORE authoring the spec — then follow what it returns. Available topics:
  \- amortization_schedule — A computed array / per-period schedule: an amortization table, time series, or per-period breakdown (one row per period).
  \- group_by — Group-by / aggregation over an array: subtotals, counts, sums per category.
  \- date_math — Date arithmetic: days/months/years between dates, elapsed duration, age from a birth date.
  \- classification — Deriving a label / tier / band / risk level / status from data via thresholds.
  \- currency_conversion — Currency / FX conversion of an amount by an exchange rate.
  \- status_field — A status / state field with flags or labels derived from the current status.
  \- rank_percentile — Rank / percentile / leaderboard / quartile over an array of values.
  \- regulated_charge — An official published charge whose rates are set by an authority: a tax, duty, levy, tariff, fee, toll, excise, or customs charge.
  \- percentage — Percentages / ratios: percent-of, markup, discount, tax-inclusive vs exclusive, share-as-percent.
  \- unit_conversion — Unit conversion / dimensional consistency: cm-m, kg-lb, C-F, miles-km — one canonical unit per quantity.
  \- compound_growth — Compound growth / interest: future value, compound interest, exponential growth (the ** operator).
  \- weighted_average — Weighted sum / weighted average / score over an array of values and weights.
  \- eligibility — A boolean eligibility / qualification verdict derived from several criteria (and/or of conditions).
  \- proration — Prorating / allocating an amount across a count or period (per-unit share, partial-period).
  \- editable_items — A user-edited list of items the user adds, edits and removes: line items, debts, expen…

Input parameters:

- `topics` (array, required): Ids of the guidance topics that apply (usually 0-2).

Output parameters:

- `guidance` (string): Concatenated instructions for the requested topics.
- `topics` (array)

### `validate_spec` (~72 tokens)

Validate spec

Validate a ModelSpec WITHOUT creating it: returns a 'valid' flag plus structured findings (errors + warnings, each with a location and message). Use this to iterate on a draft — fix the reported errors, re-validate — before committing with create_model.

Input parameters:

- `spec` (object, required): The ModelSpec to validate.

Output parameters:

- `errors` (array): Blocking findings (each with location + message).
- `valid` (boolean): True when the spec has no errors.
- `warnings` (array): Non-blocking findings.

### `eval_expression` (~260 tokens)

Evaluate expression

Evaluate a single JSONata expression against a sample input document and return the computed value, or the exact compile/eval error. Write the expr exactly as in a derivation/constraint 'expr': bare dot-paths, no leading $ (e.g. "loan.amount * loan.annualRate / 1200"). Use this to verify an expression before putting it in a spec — it uses the same compiler the runtime validates against. If the expression calls a library function, pass the model's library definition as 'library' — without it every $myFn(...) call fails as undefined.

Input parameters:

- `constants` (object): Optional constants bound as $const while evaluating (and while defining the library).
- `expr` (string, required): A single JSONata expression (bare dot-paths, no leading $).
- `input` (object): Sample document the expression runs against (full nested shape, e.g. {"loan": {"amount": 20000}}). Optional; defaults to {}.
- `library` (string): Optional JSONata library definition expression whose exports are bound while evaluating, e.g. "( $money := function($n){ $round($n,2) }; [\"money\"] )". Pass it when the expression calls $myFn(...).

Output parameters:

- `error` (string): 'compile' or 'evaluation' when ok is false.
- `message` (string): The compile/eval error message when ok is false.
- `ok` (boolean): True when the expression compiled and evaluated.
- `undefined` (boolean): True when the result is JSONata 'undefined' (no match).

### `test_spec` (~112 tokens)

Test spec

Run a spec's embedded test cases (or ad-hoc given->expect cases) through the real reactive pipeline in a throwaway runtime, returning pass/fail plus per-field failures (path, expected, actual). Use this to certify domain behavior before create_model / promotion.

Input parameters:

- `spec` (object, required): The ModelSpec whose tests to run.
- `tests` (array): Optional list of test cases (each with 'given' inputs and 'expect' outputs); omit to run the spec's own embedded 'tests'.

Output parameters:

- `failed` (integer): Cases that failed.
- `passed` (integer): Cases that passed.
- `results` (array): Per-case results (with per-field failures on failure).
- `total` (integer): Total test cases run.

### `dry_run` (~107 tokens)

Dry run

Compile a candidate ModelSpec in an ISOLATED throwaway runtime, apply optional sample mutations, and return the resulting merged state (base + derived) — WITHOUT registering it in the live registry. Use this to preview the full reactive cascade of a draft spec.

Input parameters:

- `mutations` (object): Optional field mutations to apply, keyed by canonical JSON Path (e.g. {"$.price": 10, "$.qty": 3}).
- `spec` (object, required): The candidate ModelSpec.

### `pair_browser` (~203 tokens)

Pair with browser

Pair this MCP session with a browser tab on the hosted Valem sandbox so both drive the same live model session. Mints a pairing on first call (or resumes an existing not-yet-approved one) and waits up to a minute for the developer to approve it. Returns {status:"paired"|"already_paired", namespaceId} once done, or {status:"pending", verificationUri, verificationUriComplete, userCode, expiresInSec} if the developer hasn't approved yet — show them verificationUriComplete when present (it already carries the confirmation code, so they only click Approve) and mention that the code on that screen should read userCode; fall back to verificationUri, which requires them to TYPE userCode. Then call this tool again (it resumes the SAME pairing, it does not mint a new one). Every other model tool (create_model, mutate, evolve_spec, get_state, explain, ...) fails with a clear error until pairing succeeds.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/vlad-public-code-valem/valem#diagnostics

## Score history

- 2026-09-22: 83
- 2026-09-21: 83
- 2026-09-20: 82
- 2026-09-19: 82
- 2026-09-18: 81
- 2026-09-17: 81
- 2026-09-16: 80
- 2026-09-15: 80
- 2026-09-14: 79
- 2026-09-13: 79
- 2026-09-12: 78
- 2026-09-11: 78
- 2026-09-10: 77
- 2026-09-09: 69
- 2026-09-08: 76
- 2026-09-07: 76
- 2026-09-06: 76
- 2026-09-05: 75
- 2026-09-04: 75
- 2026-09-03: 74
- 2026-09-02: 74
- 2026-09-01: 73
- 2026-08-31: 73
- 2026-08-30: 72
- 2026-08-29: 72
- 2026-08-28: 71
- 2026-08-27: 71
- 2026-08-26: 70
- 2026-08-25: 70
- 2026-08-24: 69

## Common questions

### What is the io.github.vlad-public-code/valem MCP server?

io.github.vlad-public-code/valem is an MCP server listed in the public MCP registry as io.github.vlad-public-code/valem. Valem - Deterministic reactive state models. Create your own calculators/forms with AI. This page covers its hosted endpoint (https://valem.run/mcp).

### Is the io.github.vlad-public-code/valem MCP server safe to use?

io.github.vlad-public-code/valem scores 83 out of 100 on VerifyMCP. 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 io.github.vlad-public-code/valem MCP server expose?

io.github.vlad-public-code/valem exposes 27 tools: list_models, create_model, get_model_info, get_spec, get_library, and 22 more. Their descriptions and schemas cost roughly 3,488 tokens of context every time the server is loaded.

### Does the io.github.vlad-public-code/valem MCP server require authentication?

No. We connected to io.github.vlad-public-code/valem without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the io.github.vlad-public-code/valem MCP server still maintained?

io.github.vlad-public-code/valem is still listed as active in the MCP registry. We last reached this channel on 22 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://valem.run/mcp
- Repository: https://github.com/vlad-public-code/org.json-kula.valem
- Website: https://valem.run/
- Changelog RSS feed: https://verifymcp.io/servers/vlad-public-code-valem/valem.xml
- Changelog JSON feed: https://verifymcp.io/servers/vlad-public-code-valem/valem.json
- HTML version of this page: https://verifymcp.io/servers/vlad-public-code-valem/valem