70 posts · newest first · latest
Notes from the source.
Long-form pedagogy on Intent as Code: why useful AI work belongs in a file, why the language locks at four verbs, and what local-first actually buys you.
Reading paths
Posts that make one argument, in the order to read them.
6 steps · 24 min
The origin ledger
Six records, one honest beginning.
Read the path: The origin ledger5 steps · 14 min
The trace family
One recorded file, five jobs.
Read the path: The trace family
All posts
The archive runs from the first note to today. Retrospectives keep their story date and show when they were actually published.
- 70retrospective
A standing rule for a price nobody knows
Nika v0.124.4 lets a server operator admit runs on a model with no known price under one standing rule that bounds requests, tokens, time and runs.
Engine · Security6 min read - 69retrospective
Ask the route what it offers
Nika v0.124.2 lets a workflow ask its route for a service tier and refuses what it cannot confirm; v0.124.3 reads a route's offer without a prompt.
Sovereignty6 min read - 68retrospective
Three permissions, one refusal
Nika v0.124.0 follows untrusted content into child workflows and through files, so splitting a workflow no longer hides the lethal trifecta.
Security6 min read - 67retrospective
A contact sheet without a shell
Nika v0.124.0 lays PNG images out as one sheet and speaks text with the machine's own voice, so neither job needs permission to run a program.
Engine6 min read - 66retrospective
The agent app asks before it acts
From v0.123.2, an agent task on Codex, Claude Code or Gemini CLI is held to the workflow's permits as far as the seat allows, and pauses beyond them.
Security7 min read - 65retrospective
Finished enough to maintain
Nika 0.123.0 became the open-source reference release: what it did, the limits it listed in plain words, and what maintenance turned out to mean.
Manifesto · Engine7 min read - 64retrospective
A cut answer is not an answer
When a provider stops a model at its output limit, the task now fails with its own code and keeps the partial text instead of passing it on.
Engine6 min read - 63retrospective
The spec shows only what the parser reads
In one day the Nika spec removed the examples its own checker refused and made its schemas say what the parser actually accepts.
Language7 min read - 62retrospective
The file says how it reaches its model
A .nika file can now declare the route, protocol, fallback and reasoning effort for its model, first in a prerelease and stable in v0.123.0.
Sovereignty · Language7 min read - 61retrospective
Tried on a copy before you say yes
Nika 0.122.0 tries a proposed workflow on copies of your files and judges what it wrote against your request, before you say yes.
Engine6 min read - 60retrospective
Save is not run
Nika 0.121.0 made bare nika a session from a sentence to a saved workflow file, with the run kept as a separate, explicit decision.
Engine5 min read - 59retrospective
The file is called .nika now
In Nika 0.120.0 a workflow file ends in .nika and nika compile writes new ones; .nika.yaml and nika new are retired, with a message to rename.
Language5 min read - 58retrospective
A no has to stop the next step
From 0.120.1, nika check refuses a workflow where a step skipped after a human no still feeds a later write, when that skip is certain.
Security5 min read - 57retrospective
The same page, the same article
Nika 0.119.0 made article extraction give one text per page in every run, fixed pages it misread, and made the crawl read robots.txt per RFC 9309.
Engine7 min read - 56retrospective
The bill has two sides
Nika 0.119.0 records input, cached, output and reasoning tokens apart, so the run card and the trace export show both sides of a model call.
Engine6 min read - 55retrospective
One door, one verdict
First released in v0.118.6, the One Door work gives every Nika run one closing record that the terminal, the server and the trace all read.
Engine7 min read - 54retrospective
A retry is an effect
Since v0.118.6, Nika refuses a declared retry on a POST, PUT, DELETE or PATCH fetch that has no idempotency key: a blind retry can repeat a charge.
Security6 min read - 53retrospective
The catalog says what this build can run
Nika v0.115.0 split the providers a build can call from those it only lists, and counted a signed-in agent app as ready only with its adapter.
Sovereignty6 min read - 52retrospective
Not a workflow yet
Nika v0.115.0 moved mistakes that passed nika check and then failed the run into the check itself: numbers where text belongs, reasoning budgets, blanks.
Engine6 min read - 51retrospective
The server door opens on loopback
In v0.114.0, nika serve began taking jobs over HTTP: bound to loopback, with a token read from a file, running the bytes it accepted.
Engine · Security7 min read - 50retrospective
A recovered run is not a green tick
Nika v0.114.0 stopped painting repaired runs with a plain green tick and moved two failures from the run into the check, where they cost nothing.
Engine6 min read - 49
Clean is not ready to spend
A valid AI workflow can still waste money. Nika now separates legal files from workflows that are ready for a paid run.
Engine · Security6 min read - 48
AI workflows on ARM64 Linux servers, without the missing safety step
A practical path from a native ARM64 Nika binary to checked, sandboxed and traceable AI workflows on a headless Linux host.
Engine · Sovereignty6 min read - 47retrospective
The access layer is an operating contract
From v0.108.0 to v0.111.0, Nika separated the model you choose from the path that reaches it, cut the workflow language to its durable core, added an explicit scheduler and turned check into an authoring loop.
Engine6 min read - 46retrospective
A field guide to the Nika workflow ecosystem
Choose deliberately among model providers, local runtimes, builtins, MCP servers and coding-agent surfaces without turning the workflow into vendor glue.
Engine8 min read - 45retrospective
Let coding agents write plans, not policy
Codex, Claude Code, Cursor and other coding agents can author Nika workflows while the checker, the human review and the runner keep separate authority.
Agents7 min read - 44retrospective
The CI job should know its boundary
Run Nika in CI and on headless servers with the same checked workflow bytes, explicit authority, deterministic rehearsals and a hard launch budget.
Security8 min read - 43retrospective
Retire the prompt glue
A practical migration from brittle shell and Python prompt chains to a checked workflow whose graph, authority, cost and outputs are visible before it runs.
Language7 min read - 42retrospective
Intent as Code is an engineering discipline
The useful part of AI work is not the chat. It is the intent, boundary, plan and evidence that a team can review before and after a run.
Manifesto7 min read - 41retrospective
The run keeps its receipt
A trace is more than a log: it can replay without effects, resume verified work, expose one task, export to OpenTelemetry and assemble a redacted evidence pack.
Engine6 min read - 40retrospective
The two clocks behind a model string
A provider name can be part of the stable language while its models, prices and access paths keep changing. Nika resolves those truths on separate clocks and records the result.
Language6 min read - 39retrospective
One workflow, three local model lanes
Ollama, LM Studio and vLLM expose different operating experiences, but Nika keeps the workflow contract unchanged: one model string selects the local seat.
Sovereignty6 min read - 38retrospective
MCP with a blast radius
An MCP tool is executable foreign capability. Put its server, network, environment, tool ids and schema pin under separate review, then let the trace record the call.
Security6 min read - 37
The registry re-proves everything
A workflow registry where nothing is taken on faith: every entry is content-pinned to an exact source revision and re-proven by CI (hash, certificate, advisories). The npm-of-workflows, minus the trust-me.
Engine4 min read - 36
Written by agents, reviewed by you
nika init teaches the language to whatever agent you already run. Then two real agents write the same workflow: one invents a schema the audit refuses, one goes green first shot. The human review is a two-line diff.
Agents5 min read - 35
The pipeline is a file
An llm pipeline is a graph of model calls, tools and processes. A graph is declared, not programmed: forty lines of YAML replace the orchestration framework. Diffable, auditable, replayable.
Language3 min read - 34
The MCP server you didn't have to build
Everyone is learning how to build an MCP server. For your workflows, skip the tutorial: the nika binary already is one. Read-only tools let any agent audit a plan and learn the language from the thing that enforces it.
Engine3 min read - 33
The forecast is local
explain --forecast computes duration and cost priors from your own recorded runs: stats over .nika/traces/, honest ranges at two runs, percentiles at five. Never a model call, never the network.
Engine3 min read - 32
The generative ai workflow, minus the mystery
Strip the buzzword and a generative ai workflow is three things: inputs you name, a model step, and effects you can point to. Declare all three in one file and the mystery evaporates. Rehearsed offline, every asset with provenance.
Language3 min read - 31
The chain of custody
A recorded run is a text file, and text files can be edited. nika trace verify recomputes the hash chain: one changed word in history breaks every line after it, and the run's printed head closes the loop.
Engine3 min read - 30
The agent workflow spectrum
An ai agent workflow is any pipeline where a model chooses some of the steps. Every design sits between a declared graph and a free loop. Where yours lands decides which safety you can even ask for.
Language4 min read - 29
The run that waits for you
The approval gate is a task in the file, not a Slack thread: a plan fails closed on nika:prompt, and the human's answer rides the resume.
Engine3 min read - 28
The resume story
kill -9 a run mid-flight, then resume it: finished work never runs twice. Durability as a file property, shown from the real journal.
Engine3 min read - 27
The one-task re-run
Regenerate one block without re-running the world: --task scopes a fresh run to a task and its upstream, --from re-rolls what the hashes cannot see.
Engine3 min read - 26
Prompts are code now
Prompt versioning without a platform: the prompt lives in the workflow file, so git diffs it, a PR reviews it, git reverts it. The engine itself names an edited prompt when two runs diverge.
Language2 min read - 25
The prompt injection that goes nowhere
Prompt injection examples usually end with the agent taking a new action. Here the plan is authored before the model runs: the hostile note becomes data, never an action, and the boundary is checked before a token is spent.
Security3 min read - 24
The run becomes evidence
Every journal line now carries a hash chain: verify names the first broken link, reproduce classifies every task, and the journal attests which engine wrote it. Trust, but verify. Then verify.
Engine3 min read - 23
Time travel, for real
Every debugger replays the past by re-running it. Nika's past is a file, so stepping backward is free, breakpoints live in your YAML, and F5 debugs a run that already happened.
Engine2 min read - 22
The editor tells the truth
A green badge is a claim. We audited the editor extension against the engine the way you'd audit a client against a server, and found the badge lying. Here is the contract that keeps it honest now.
Engine3 min read - 21
The credentials your pipeline was breaking
OpenAI and Google sign the images their APIs return. Almost every pipeline that touches those files silently converts the signature into evidence of tampering. That included ours, until this week.
Security4 min read - 20
One wire, five servers
The self-hosted media world quietly standardized on OpenAI's wire shapes. That accident of history is the best sovereignty news in years, and Nika's media builtins are built on it.
Sovereignty3 min read - 19
Media are workflow citizens
Images and speech now render inside workflows under the same discipline as everything else: permit-gated saves, sha256 provenance, honest warnings, real cost on the ledger, and the sovereign path first.
Engine3 min read - 18
The trace you can replay
Every run leaves a flight recorder: a deterministic AI audit trail you can replay like a film, never re-execute by accident.
Engine2 min read - 17
The secrets line
Information-flow, audited before it flows: how the checker proves a secret cannot leak into a prompt, a file, or a host.
Security3 min read - 16
The cost line
The audit prices every token before it is spent: ceilings on generations, budgets on loops, and a $0.00 that means it.
Engine2 min read - 15
Anatomy of a verb
infer, exec, invoke, agent: what makes the four verbs genuinely different execution models, in the engine's own verdicts.
Language2 min read - 14retrospective
No cloud needed
One Rust binary, your models, your files. Run LLMs locally and see what local-first actually buys you.
Sovereignty2 min read - 13retrospective
Intent as Code: why your AI work should be a file
Chats evaporate, files compound. The case for writing AI work down as source you own: your best prompts, versioned like code.
Manifesto3 min read - 12retrospective
The plan you get for free
The wiring is all you write: with: for data, after: for order. The plan falls out of the file: parallel waves, drawn before anything runs.
Engine3 min read - 11retrospective
The blast radius is part of the file
The workflow declares its effect boundary before execution. Static checks explain the fit; runtime sinks enforce what the host can prove.
Security3 min read - 10retrospective
A standard library, not a plugin store
Builtins ship with the engine and stay separate from the four verbs. External tools remain explicit dependencies, not new grammar.
Language3 min read - 09retrospective
An open spec, a copyleft engine
The language contract is Apache-2.0. The reference engine is AGPL-3.0-or-later. The split keeps adoption and implementation custody separate.
Sovereignty3 min read - 08retrospective
Four verbs are enough
A verb is a distinct execution model, not a feature. Why the language locks at four, forever.
Language3 min read - 07retrospective
Starting over, on purpose
We had a working prototype. We rebuilt from scratch anyway: craft, not extraction, one gate at a time.
Origins3 min read - 06retrospective
Naming the drum
Why a local workflow engine carries the name of a liberation figure, and why a butterfly signs the work.
Origins4 min read - 05retrospective
The part Git cannot prove
Then the public record goes quiet. An honest origin story keeps the missing months visible instead of inventing a montage.
Origins4 min read - 04retrospective
What survived the first version
Strip away the early claims and four technical bets remain: file, graph, model choice and a local engine.
Origins · Engine4 min read - 03retrospective
The first page was too sure
On December 30, Nika became public and immediately overclaimed. The first page preserves both the idea and the correction.
Origins4 min read - 02retrospective
The file came before the language
The first durable Nika decision fit in two words: a file. Syntax, graphs and providers came later.
Origins · Language4 min read - 01retrospective
The note that started it
Nika did not begin with a parser. It began with an objection: useful AI work should not disappear when a chat closes.
Origins4 min read