blazieblazie
blazieblazie

the backend agents run on

durable memory that records where every fact came from, a graph you did not have to model, and sandboxes to run agent code in. deploy an agent, give it a cadence, and read back everything it did.

canary — pre-release, and the shape still moves. read the source before you depend on it.

what an agent gets

not a database with an agent story bolted on. the parts an agent needs, in one runtime, where they already agree with each other.

every fact knows what made it

provenance is a slot in the row, not a convention. an answer either came from outside or names the code that produced it, and there is no third option to forget.

one line touches the outside world

a formula gets no clock, no network and no filesystem — isolation is the absence of anything to reach. a job is the only thing handed the world, and the only thing a schedule attaches to.

a graph you did not have to model

an edge is a fact whose value is another id. no node type, no edge type, and no second store to keep in step with the first.

memory that keeps being wrong

nothing is ever rewritten. a correction is a later fact, and the earlier one still answers where it was written — so “what did it believe on tuesday” is a question, not a log search.

it tells you when something changed

watch a question and it answers again as facts land — the same question, not a different mechanism. an agent reacts instead of polling.

erasure that actually erases

a value is sealed under a key belonging to whoever it is about. erasing destroys the key, so the bytes become noise, nothing is rewritten, and backups are covered because the key was never in them.

an answer you can cite

four operations, and this is all of them. a caller holds the snapshot's name, never its bytes — so what it read is something it can hand to somebody else, and they get the same answer.

write, and get a name back

the name is the snapshot your facts landed in, so you read your own write without polling for it.

ask at that name, forever

the same question at the same name gives the same facts next month. cache on the pair and never invalidate.

`by` says what made it

null means it came from outside and cannot be reproduced. anything else names the code that produced it.

a token names ledgers

authorization is a list of ledgers you may name — not row rules, not predicates, and readable in one glance.

the whole api
# write one fact. it came from outside, so nothing produced it.
curl -X POST https://api.blazie.dev/write \
-H "Authorization: Bearer $BLAZIE_TOKEN" \
-d '{"ledger":"tenant-7","facts":[
{"id":"ada","attribute":"height","value":180}]}'
{"name":{"tenant-7":42}}
# ask at that name. this answer does not change again.
curl -X POST https://api.blazie.dev/ask \
-H "Authorization: Bearer $BLAZIE_TOKEN" \
-d '{"name":{"tenant-7":42},"pattern":{"attribute":"height"}}'
{"facts":[
{"id":"ada","attribute":"height","value":180,"tx":42,"by":null}]}
# a later fact corrects it. the old name still answers 180.
curl -X POST https://api.blazie.dev/write \
-H "Authorization: Bearer $BLAZIE_TOKEN" \
-d '{"ledger":"tenant-7","facts":[
{"id":"ada","attribute":"height","value":181}]}'
{"name":{"tenant-7":43}}

the same four from a terminal: blazie write tenant-7 ada height 180, then blazie ask tenant-7 --attribute height, and blazie watch tenant-7 to be answered again as facts land.