json-chamber-mcp
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@json-chamber-mcpseal the JSON: {"user":"alice","tier":"gold"}"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
json-chamber-mcp
Chamber MCP — seal / open JSON. Slid Phi Labs.
Cloak (seal new JSON) needs a live license. Open of an already-sealed blob is both keys, no extra payment. Ciphertext does not expire.
Install / run
npx -y json-chamber-mcp{
"mcpServers": {
"json-chamber": {
"command": "npx",
"args": ["-y", "json-chamber-mcp"],
"env": {
"CHAMBER_MASTER_SECRET": "your-high-entropy-secret"
}
}
}
}Related MCP server: json-validate
Discovery
Surface | URL |
Official registry id |
|
Lab well-known | |
Lab llms.txt | |
npm |
|
Server schema | |
Product |
Hosted lab MCP (PCC + catalog): POST https://www.slidphilabs.com/mcp · Smithery: https://smithery.ai/servers/slidphi/lab
Pricing
SKU | What | Price |
Chamber try | cloak new JSON | 24 hours free |
Chamber month | cloak license | $9 |
Chamber year | cloak license | $99 |
Open | already-sealed blob | keys only |
Prices live on https://www.slidphilabs.com/chamber
Tools
Tool | Purpose |
| cloak try remaining / dead / purchased |
| pointer to live prices |
| seal JSON / text (licensed) |
| open sealed blob (keys only) |
| admit/reject hop (gate only) |
| live sanitized reject log |
Hop-gate (ScanChunk / Rider SoT)
Admission layer in front of seal/open. Seal/open APIs are unchanged. No SettleHop / x402.
Wire is exact text (Agent-Rider agent-rider-c / PR #22), not JSON:
CUNI ScanChunk
url=https://example.com/
etag="abc"
hash=sha256:…
agent_id=agt_1Fields (allowlist): url · etag · hash · agent_id. Gate result wire is a single exact-text code string (not a JSON body).
Code | Meaning |
| hop allowed |
| Chamber-local only (Rider does not emit) |
| unknown keys or wrong kind — fail-closed; do not bind; never rehydrate |
| empty / invalid hash |
| hash already seen |
| agent allowlist fail |
| empty / missing required fields ( |
Live reject.log is TSV ISO\tcode\tpreview (mirrors agent-rider-c/reject.log); preview truncates ~120 and flattens newlines. Extra-key values never rehydrate as next machine input.
PCC ≠ payment — PCC is the compression/storefront face; hop-gate codes are admission control, not billing.
MCP tools: chamber_hop_gate, chamber_hop_reject_log.
Related
Python SDK: https://github.com/ceedot-rock/json-chamber-sdk
Product: https://www.slidphilabs.com/chamber
Contact: corey@slidphilabs.com
Available Tools
7 toolsbenefit_checkC
Entropy + bias gate for $1900 tier. Always available. No TRU8.
| Name | Required | Description | Default |
|---|---|---|---|
| data | Yes | UTF-8 text or base64 binary | |
| encoding | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'Entropy + bias gate' and 'No TRU8' but does not explain what these mean, what side effects occur, or what the tool returns. The description is too vague to inform an agent about the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short, which is concise, but it lacks structure and front-loaded clarity. Every word is cryptic and does not earn its place by adding useful information. It is under-specified rather than efficiently concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 2 parameters, no output schema, and no annotations, the description is severely incomplete. An agent cannot determine what the tool does, what inputs are expected, or what the output will be. The cryptic references to '$1900 tier' and 'TRU8' are unexplained and likely meaningless to the agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 50%, with only the 'data' parameter described in the schema. The description adds no parameter-level detail, leaving the 'encoding' parameter and the meaning of 'data' ambiguous. The cryptic phrase 'Entropy + bias gate' does not clarify how to use the parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Entropy + bias gate for $1900 tier. Always available. No TRU8.' is cryptic and does not state a clear verb or resource. It does not explain what the tool actually does, making it difficult for an agent to understand its purpose. The sibling tools (chamber_status, chamber_info, etc.) suggest a domain, but the description fails to differentiate benefit_check from them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool versus alternatives. Phrases like 'Always available' and 'No TRU8' are vague and do not clarify usage context. There is no mention of when to prefer benefit_check over sibling tools like chamber_hop_gate or chamber_status.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
chamber_cloakC
Seal JSON/text with φ-split + AES-256-GCM. Requires live license.
| Name | Required | Description | Default |
|---|---|---|---|
| data | Yes | JSON string or plain text | |
| is_json | No | Validate as JSON (default true) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must carry the behavioral disclosure burden. It mentions the license requirement, which is a key operational constraint, but it does not disclose side effects, whether the operation is destructive or read-only, what the return value looks like, or error behavior. This is insufficient for a tool without annotation support.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that begins with the core action and resource. It includes the algorithm and the license requirement without unnecessary words. It is concise and efficiently structured, though it could be slightly more informative without losing brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with two parameters and no output schema, the description provides the essential purpose and a critical constraint (license), but it omits what the tool returns, any side effects, and the meaning of 'seal' in this domain. Given the sibling set, an agent might infer the output, but the description alone is not fully complete for confident invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters (data as a string, is_json as a boolean). The description's mention of 'JSON/text' loosely aligns with the data parameter but adds no new semantic detail beyond the schema. Since the schema is thorough, a baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (Seal) and the target resource (JSON/text), and specifies the algorithm (φ-split + AES-256-GCM). It is distinguishable from sibling tools like chamber_open (likely unsealing) and chamber_status/info (likely metadata). However, it does not explicitly contrast with alternatives, so it's not a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a prerequisite ('Requires live license') but gives no guidance on when to use this tool versus siblings, nor any conditions or exclusions. There is no mention of when sealing is appropriate or when to prefer another tool, leaving the agent to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
chamber_hop_gateA
Evaluate Chamber hop-gate (exact-text code). Gate only — does not seal/open/SettleHop. Wire: CUNI ScanChunk + url/etag/hash/agent_id. Result: single code string. PCC ≠ payment.
| Name | Required | Description | Default |
|---|---|---|---|
| hop | Yes | Exact-text CUNI ScanChunk wire (not JSON). Fields: url etag hash agent_id. Extras → reject.extra. | |
| allowed_agents | No | Optional agent allowlist |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses that the tool only gates (does not seal/open/SettleHop), which is a key behavioral trait. It also mentions that extras lead to reject.extra, which is a useful behavioral detail. However, it doesn't describe side effects, permissions, or what happens on success/failure beyond returning a code string.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, using telegraphic style to pack essential information into a few lines. Every sentence adds value: scope, wire format, result type, and a critical caveat (PCC ≠ payment). The structure is front-loaded with the core purpose and then details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a gate-evaluation tool with no output schema, the description covers the input format, required fields, result type, and a key exclusion (PCC ≠ payment). It doesn't explain the return code semantics or error handling beyond reject.extra, but given the tool's narrow scope and the schema's 100% coverage, it is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents both parameters. The description adds meaning by specifying the exact wire format (CUNI ScanChunk, not JSON) and the required fields (url etag hash agent_id), which clarifies the 'hop' parameter beyond the schema. It also notes that extras cause reject.extra, adding behavioral context for parameter handling.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as evaluating a Chamber hop-gate with exact-text code, and explicitly states it is a gate only, not seal/open/SettleHop. It distinguishes itself from sibling tools by naming the wire format and result type. However, it doesn't explicitly name a sibling alternative, so it's clear but not fully differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context: it evaluates a gate, does not perform other actions, and specifies the wire format (CUNI ScanChunk) and required fields. It also notes that PCC ≠ payment, which helps avoid misuse. It doesn't explicitly state when to use this tool versus alternatives, but the gate-only scope and wire format imply the usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
chamber_hop_reject_logC
Live hop-gate reject.log as TSV ISO\tcode\tpreview (Rider SoT). Extra values never rehydrate.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max recent entries (optional) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden. It does disclose that the log is 'Live' and that 'Extra values never rehydrate', which hints at real-time current data and no enrichment/backfill. However, it never explicitly states that this is a read-only operation or explains what 'rehydrate' means, leaving important behavior ambiguous.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short and front-loads the output format, but the second sentence 'Extra values never rehydrate' is cryptic and costly in clarity. Brevity is achieved at the expense of plain-language comprehensibility, making it appropriately sized but poorly tuned for an AI agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-optional-parameter read tool, the description provides the output shape (TSV with three columns) and a limitation. Yet it does not clarify what 'Rider SoT' refers to, what a 'hop-gate reject' is, or how the limit interacts with 'Live', leaving room for misinterpretation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter, limit, is fully described in the schema as 'Max recent entries (optional)', so schema coverage is 100%. The description adds no additional meaning about limit behavior, staying at the baseline 3 because the schema already does the work.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific resource (hop-gate reject.log) and the TSV format with columns ISO, code, preview, which distinguishes it from siblings like chamber_status or chamber_hop_gate. However, it lacks an explicit verb such as 'returns' or 'lists', and uses unexplained jargon like 'Rider SoT' and 'rehydrate', so an agent must infer the tool's core function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus chamber_hop_gate, chamber_status, or benefit_check. The phrase 'Rider SoT' hints at authority but does not explain a decision procedure for selecting this tool, and no alternatives or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
chamber_infoC
Package info, cloak license ($9/mo · $99/yr), open is keys-only.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals a licensing detail and a keys-only constraint for 'open', but it does not explain what 'package info' includes, whether the tool performs any side effects, or what the response looks like. The behavior is only partially transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short and front-loaded, which is good, but it is fragmented and lacks a clear subject-verb structure. It reads like a set of notes rather than a coherent tool description, so while it is concise, it sacrifices clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with no output schema and no annotations, the description should provide a fuller picture of what the tool returns and how it behaves. The current description gives only fragments: package info, cloak license pricing, and a keys-only note about open. It is not complete enough for an agent to confidently know what calling this tool will yield.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there is no parameter semantics burden on the description. The schema is empty and coverage is 100%, meaning there is nothing for the description to clarify about inputs. The description's content about package info and license is contextually useful even though it is not parameter-related.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description is telegraphic but does convey that this tool provides package info, cloak license details, and notes that 'open' is keys-only. It does not use a clear verb like 'get' or 'retrieve', and it does not explicitly distinguish itself from siblings such as chamber_status or chamber_cloak, though the mention of package info and license pricing gives some differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit guidance on when to use this tool versus chamber_status, chamber_cloak, or chamber_open. The phrase 'open is keys-only' hints at a caveat for the open operation, but it does not state when to choose this tool over alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
chamber_openB
Open a sealed chamber blob. Keys only — no license, no clock.
| Name | Required | Description | Default |
|---|---|---|---|
| sealed | Yes | Sealed blob from chamber_cloak |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It adds one meaningful trait — this operation relies on keys and does not require license or clock checks — but it does not disclose side effects, failure behavior, validation steps, or whether the operation is read-only. This is minimal transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely compact: one opening sentence naming the operation and one short clause giving the key requirement. Every phrase earns its place, and the core action is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema and no annotations, so the description must explain what the agent gets back and what the tool does beyond the single input. It does not describe the return value, error conditions, or whether the operation mutates anything. The 1-parameter schema reduces complexity, but the missing behavioral and output context makes this incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the only parameter, 'sealed', is already described as 'Sealed blob from chamber_cloak.' The description mostly restates the operation rather than adding new parameter-level meaning, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific action and resource: 'Open a sealed chamber blob.' It also links the input to chamber_cloak, which helps distinguish this tool from the sibling chamber_* tools. It loses a point because it never says what 'open' concretely produces or what state change, if any, occurs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'Sealed blob from chamber_cloak' implies this tool is meant to be used on output created by chamber_cloak, and 'Keys only — no license, no clock' gives a clear prerequisite. However, it does not explicitly state when to choose this tool over alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
chamber_statusB
License status: eval remaining hours, purchased, or dead.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It mentions the possible output values but does not explicitly state that the operation is read-only or side-effect-free, nor does it mention any permissions or rate limits. This is a minimal disclosure that leaves safety posture implicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded phrase that packs the core resource and possible states into eight words without any filler. Every token earns its place, and the structure leads with the topic 'License status'.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with no output schema, the description conveys the essential return values, which is adequate for basic invocation. However, it omits context about when to choose this over chamber_info and leaves terms like 'eval' and 'dead' under-specified, making the completeness only partially sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema coverage is 100% (empty object), so there are no inputs to document. Per the baseline for 0 parameters, this is fully adequate; the description adds no parameter semantics but none are needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the resource (license status) and enumerates the possible states (eval remaining hours, purchased, or dead). It conveys a query-like purpose and distinguishes itself from siblings like chamber_info by being specifically about license status, though it lacks an explicit verb like 'get' or 'check'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use when license status is needed, but it provides no explicit when-to-use guidance, no exclusions, and no comparison to sibling tools such as chamber_info or benefit_check. An agent is left to infer when this tool should be selected over alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
7 tool updates
v1.2.0- First observed
benefit_check - First observed
chamber_cloak - First observed
chamber_hop_gate - First observed
chamber_hop_reject_log - First observed
chamber_info - First observed
chamber_open - First observed
chamber_status
TDQS
Scored across 7 tools
The tools have distinct roles: status/info for licensing, cloak/open for sealing/unsealing, and two separate gate checks (hop_gate vs benefit_check) plus a log. There's minor overlap between status and info (both about license state), but they serve different details. Overall, an agent can tell them apart with clarity.
Most tools follow a 'chamber_' prefix with a noun or verb (status, info, cloak, open, hop_gate, hop_reject_log), but 'benefit_check' breaks the pattern. The verbs are inconsistent (some are nouns like status, others are imperatives like cloak), though the naming is still readable and mostly predictable.
With 7 tools, the server is well-scoped for its purpose: managing sealed JSON chambers, checking license status, and evaluating gates. Each tool has a clear function, and the count is appropriate for the domain without being overwhelming or too sparse.
The core lifecycle is covered: sealing (chamber_cloak), opening (chamber_open), status (chamber_status), and license info (chamber_info). Gate evaluation and logging are also included. A minor gap is no tool to list or manage multiple chambers, but for the given purpose, the surface is largely complete.
Maintenance
Related MCP Connectors
Experimental MCP server for current empirical verification of explicit public HTTPS endpoint claims.
MCP server for mandates, delegation, policy-gated execution, credential grants, and audit.
MCP server for Boson Protocol — on-chain agentic commerce for physical & digital goods.
MCP server for progressive tool usage at any scale (see https://klavis.ai)
Related MCP Servers
- MIT
- FlicenseNot gradedqualityDmaintenanceMCP server for validating JSON against JSON Schema and repairing malformed/invalid JSON.2 npm1-
- AlicenseAqualityBmaintenanceMCP server for verifying high-impact decisions with Trust OS.2MIT
- AlicenseAqualityCmaintenanceMCP server for sealing, verifying, and reading KNOBE Protocol v1 documents with human-confirmed authorship, ensuring document provenance and integrity.5Apache 2.0