Semantic Arkiv — Stop Guessing Arkiv's Schema

F-7

The documentation produces silent zeros

Arkiv's data-modeling guide says project + entity_type scopes an application's data. Follow it exactly on live Tiramisu and the query runs, succeeds, and returns nothing.

Silent Failure

0 rows returned

Resolved

64 rows returned

Live Walk

What is actually on chain

25,000+ entities, 37 namespaces, 415 real attributes — and no global schema. Attribute names are invented per project; the same name can mean different types in different projects.

Entities on Tiramisu

Project namespaces

Real attributes

Multi-type names

type2,220 observations

entity_type386 observations

Resolver

Ontology-powered resolution

The resolver grounds natural language in live on-chain vocabulary. It emits the exact grammar the node requires. What you see emitted is what gets executed.

The Gap

What the markdown skill gives you. What it doesn't.

The arkiv skill teaches the alphabet. Semantic Arkiv knows the words. Neither alone is enough.

Markdown Skill static knowledge

Grammar: no &&, use str('x'), dec(4.5) not dec('4.5')
Discriminator lesson: use type, not entity_type
Infix STARTSWITH, no subqueries, no EXISTS
No per-project vocabulary
No type values for mandi_board_v1
No attribute names or types

Gets you from a syntax error to a valid query.

Semantic Arkiv live knowledge

mandi_board_v1 uses type with values price_report, price_vote
price_report carries crop, mandi, price (as dec), state
price_vote carries voter, verdict, voted_at_ms — no price
Every name attested by observation counts from the live chain
Refuses to invent a name it cannot attest

Gets you from a valid query to the right answer.

Watch the agent get stuck. Watch the resolver finish.

1 in 41,500

chance of guessing the right type value AND attribute names AND types

Measured

The numbers

Markdown-only baseline vs. the ontology resolver, measured on 10 real prompts against live Tiramisu.

100%

Grammar-valid

70%

Silent-zero risk

90%

Real rows returned

52,534

2,367

Guidance bytes (95.5% reduction)

Scoped Queries

Query by provenance and authority

Arkiv exposes two system attributes for scoped reads: $creator (original publisher, use for provenance) and $owner (mutation authority, changes on transfer). Both are addr typed.

Provenance

-- all entities created by this address
$creator = addr('0xd5055b36ad00d54dacffb2340da0962f16207b30')
        

100 entities by this creator on mandi_board_v1

Mutation Authority

-- all entities currently owned by this address
$owner = addr('0xd5055b36ad00d54dacffb2340da0962f16207b30')
        

100 entities owned (same unless transferred)

Write Path

Create your own ontology on Arkiv

Arkiv entities are created via a native system address — no contract deployment, no Solidity. The execute function takes an array of operations and returns the created keys.

Native write interface

address ARKIV_SYSTEM = '0x44000000000000000000000000000000044'

function execute(uint8 operation, bytes operationData) returns (bytes32[] keys)

// operation tags
// 1 = create    2 = patch    3 = extend
// 4 = transfer  5 = delete
      

Create an entity

// operationData = abi.encode(attributes)
struct Attribute { string name; string type; string value; }

bytes data = abi.encode(Attribute[](
  Attribute("project", "str", "my_ontology"),
  Attribute("type",    "str", "definition"),
  Attribute("triples", "u64", "2705")
));

execute([1, data]);  // create → returns [key]
      

Note. This project is read-only by design. The write path is shown for completeness — a natural extension is a write-side resolver that grounds mutations in the same vocabulary used for reads.

Build

What ships

Zero-dependency MCP server

4 tools. MCP stdio over newline-delimited JSON-RPC. Nothing to install, nothing to compile.

Ontology

2,705 triples, 14 SHACL constraints. Every emitted filter is grounded in vocabulary read off the live chain.

Tests

11/11 checks pass on a clean clone. Zero install.

Filed upstream before submission

#58F-7 — entity_type documented as discriminator; type is used 5.8× more often

#59F-1 — camelCase attribute names parse on read, can never match a stored cell

#60F-6 — 20 attribute names carry multiple types across projects

#61STARTSWITH — infix syntax undocumented; function form rejected

Stop guessing Arkiv's schema.