blazie

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.

join waitlist

github

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

one operation, and this is all of it. every run hands back the name of the snapshot it read, so what you got is something you can hand to somebody else and they get the same answer.

it is just lua

no query language and no schema. an entity is a table, a field is a field, and an edge is a field holding another entity.

every answer has a name

a run tells you which snapshot it read. ask again at that name next month and the answer is identical.

nothing is overwritten

a correction is a later fact. `at(42)` still answers what was true then, so “what did it believe on tuesday” is a question.

one door

send lua, get back what it returned. there is no second endpoint to learn and no client library to keep in step.

the whole api

# the whole api. send lua, get back what it returned.
curl -X POST https://api.blazie.dev/run \
  -H "Authorization: Bearer $BLAZIE_TOKEN" \
  -d '{"world":"main","source":"
        ada.height = 180
        ada.friend = grace
        return ada.height
      "}'
 
{"value":180,"name":{"main":42},"wrote":5}
 
# that name is the answer's receipt. it does not change again.
curl -X POST https://api.blazie.dev/run \
  -H "Authorization: Bearer $BLAZIE_TOKEN" \
  -d '{"world":"main","name":{"main":42},"source":"
        return ada.friend.height
      "}'
 
{"value":175,"name":{"main":42},"wrote":0}
 
# find things. lua is the query language, so counting needs nothing new.
curl -X POST https://api.blazie.dev/run \
  -H "Authorization: Bearer $BLAZIE_TOKEN" \
  -d '{"world":"main","source":"
        local n = 0
        for p in each { height = 180 } do n = n + 1 end
        return n
      "}'
 
{"value":1,"name":{"main":43},"wrote":0}

the same from a terminal: blazie run main 'ada.height = 180', or blazie run main -f setup.lua to send a file.