These are small, single-purpose tools for building with coding agents. Every one of them works on its own, with whatever you already use. There is no platform to adopt and no order to learn them in — find the problem you actually have, take that one, and ignore the rest.
awnix already carries the capabilities; adding an agent is three lines in a Dockerfile, and your skills and credentials layer on top of that. The point of the order is that the guarantees live in the base, so swapping the agent keeps them.
What an agent needs to perceive things outside its own process — search and pages.
Prove what an artifact is, who acted on it, and that nothing was quietly removed from the record.
Several agents editing one codebase without sweeping each other's work or re-deriving what the last one already learned.
Who may come in at all, before anything asks who they are: a human check whose verdict is bound to one door and one use, the identity it names, the authority it feeds, and a record of every refusal. Named because the four already existed as four separate answers to one question a stranger asks first.
The three questions every access decision needs answered separately: who is this caller, what may they do, and what did they actually do. Kept apart on purpose -- one component that answers all three is one component that can quietly answer all three wrongly.
OWNER DECISION 2026-08-19, recorded because it was made in a transcript and would otherwise be re-litigated: stop hand-maintaining a web UI per app. The Living Desktop is the shell; an "app" is a dynamic agent panel rendered from a tool result (awkit), scoped by the identity plane, driven by intent rather than clicking. veil/portal keep serving pages and APIs where genuinely needed -- the UI, widgets and apps are what collapses, not the hosting. WHY, measured that day on ONE tenant: 18 apps listed and 0 deployed; AitherOne showing "Service Unavailable" while healthy, because all 11 of its GET routes require a body and answer 422 to every caller alive; 189 catalogue routes against 105 registered panels; and 2 of 6 declared panels were ids with NO component -- rendering nothing, with no error, no boundary and no log line. Every one of those is the same shape: declared in one place, not real in another, and nothing comparing the two. THE TRAP THIS MUST NOT INHERIT, stated here so the stack is judged on it: collapsing six surfaces into one does not fix that shape, it reduces how many places it can happen. A panel spec a renderer cannot honour is a stale component one layer up. The parity gate (RB001-RB005's shape: producer ids == renderer ids, asserted by something that fails) comes FIRST, or this becomes the seventh island. DONE means: one previously-broken app rebuilt as an agent panel end to end with real scope and real data; the entitlement plane answering once instead of a catalogue and a backend disagreeing; and surfaces retired by the EC009 ratchet, one at a time, each with its consumers moved in the same commit -- never by decree.
The thinking core, kept apart from the senses and the hands on purpose. A hard question becomes a session with phases you can inspect (awreason); a failure inside it becomes ranked hypotheses with a falsifying check for each (awprism); and the check is actually RUN against live state rather than recalled (awrepl). Those three are the loop. It composes with `agent-senses` for what is outside the process and with `shared-worktree` for what is in the codebase — which is why neither set is repeated here.
A research question answered against real sources, where the report names what it read (awresearch), the sources are found and actually opened rather than hallucinated (awfind, awbrowse), and what was learned survives the session (awm). The one failure this set exists for is the plausible document: fluent, well-formed, citing pages nobody fetched.
Build AI agent fleets — 3 lines, any backend, local or cloud.
Running one agent is easy and running fifty is a different job: budgets, retries, which model, whose machine. Most frameworks make you adopt their whole world to find out.
Start here: Point it at a backend you already pay for and run one agent loop.
pip install awdk
The agentic web — agents host a mesh, and agents join one.
Agents are islands. Every deployment reinvents how a peer is found, addressed and trusted, so two agents on two machines cost more to introduce than either cost to build — and the answers (port forwards, a VPN per pair, public IPs, a broker somebody has to run) all become permanent maintenance.
Start here: Host a mesh on one machine and join it from another.
pip install awnet
A lightweight local gateway — bridges your apps to the AI backends you chose.
Every app hardcodes a different provider SDK, so switching backends means editing every app.
Start here: Run it once and point one app at it instead of a vendor URL.
pip install awnode
A priority-aware queue and dispatcher for agentic runs and ad-hoc CI builds.
A shared runner pool serves whoever asked first, so an urgent one-line fix waits behind a queue of speculative work — and the only lever anyone has is asking people to stop pushing.
Start here: Queue two runs at different priorities and watch the urgent one overtake.
pip install awrun
Browser extension — federated AI search, page context, and the Living OS overlay.
Your agent cannot see the page you are looking at, so you paste it in by hand.
Start here: Install it and ask an agent about the tab you are on.
load unpacked — see the repo
Near-optimal KV cache quantization for LLM inference — sub-byte compression.
KV cache, not weights, is what runs a GPU out of room during real serving, and it grows with every token of every concurrent request.
Start here: Quantize the cache on one model you already serve and measure the headroom.
pip install aither-kvcache
Put two agents head to head and get a verdict you can check.
Everyone claims their agent is better and nobody can settle it. The comparisons that exist are a screenshot of two chats, or a leaderboard whose numbers arrived from somewhere nobody can name -- so "which of these is actually better at this" stays an argument. And the moment a result is worth something, the vote is worth gaming: an audience score with no check on who is voting is a bot flood with extra steps, and a verdict nobody signed can be edited afterwards by whoever owns the database.
Start here: Run one judged head-to-head between two agents and read the scored verdict.
pip install awarena
Your agent asks you a question — and acts on your answer.
A decision buried in terminal prose is a stream event — it scrolls past, and the agent either stalls waiting for someone who is not reading, or guesses and does days of the wrong work. Every agent framework can print a question; almost none can carry the ANSWER back into the run that asked it, so the human is a bottleneck exactly when they are least able to be one.
Start here: Ask a human a question from a script, and keep working on their answer.
pip install awask
Role-based access control that fails closed and explains itself.
Most authz answers "no" without saying why, so every denial becomes a debugging session — and the ones that fail OPEN never announce themselves at all.
Start here: Gate one endpoint and read the explanation it gives for a denial.
pip install awbac
A portable browser client — navigate, console, network, DOM, screenshot.
Handing an agent a screenshot makes it read a picture of text; handing it raw DOM makes it read a megabyte of markup. Neither of those is the page.
Start here: Drive one page and get back what is on it in a form worth reasoning about.
pip install awbrowse
An append-only audit trail whose gaps are DETECTABLE.
An audit log you can silently delete from is decoration. Most are. The property that matters is not "it records" but "a missing record is visible".
Start here: Write one sensitive action to it and then try to remove the record.
pip install awdit
Point an agent at a file and a command that scores it, and let it improve.
Automated improvement loops fail silently and look identical while doing it. A run that explored honestly and found nothing produces the same logs, the same records and the same stop reason as a run that changed nothing at all -- there is no exception to catch and no failing request, so the loop keeps running and a human periodically concludes the search space is just hard. And the loops that DO work are usually one-shot generators: the model is asked for a candidate, handed no history, and never allowed to test its own idea before committing it.
Start here: Point it at a file and a command that scores that file, and watch an agent improve it -- keeping every version and the score it earned.
pip install awevolve
A portable search client — query, results, ranking.
An agent with no search guesses from training data; an agent handed a raw web API gets ten blue links and burns its context reading them.
Start here: Ask one question and get ranked answers back instead of a page of results.
pip install awfind
Semantic version control on top of git — edit-ops and leases.
Several agents editing one worktree silently sweep each other's work; a diff tells you WHAT changed but not who meant it or whether they were mid-edit.
Start here: Take a lease on a file before you edit it in a shared checkout.
pip install awgit
A semantic code graph for agents — AST + tree-sitter, call graphs.
"Who calls this?" answered by grep is a guess. Agents burn enormous context re-reading files to rebuild a graph the parser already knows.
Start here: Index one repo and ask it who calls one function.
pip install awgraph
Who is this caller? A directory and session store that fails honestly.
Deactivation that takes effect "eventually" is not deactivation, and a store that cannot be read reports zero users — which every caller reads as "nobody is authorised" or, worse, as an empty directory to helpfully repopulate.
Start here: Deactivate one session and watch it stop working immediately.
pip install awiam
Render an agent panel from a tool result — one component, any React app.
Every agent surface re-implements the same panel by hand, so each one rots separately: a catalogue lists an app the renderer cannot draw, a tab is declared with an id no component answers to, and nothing compares the two. Measured 2026-08-19 on ONE tenant: 18 apps listed and 0 deployed, and 2 of 6 declared panels were ids with no component — they rendered NOTHING, with no error, no boundary and no log line, which is indistinguishable from a feature nobody wanted.
Start here: Point it at one MCP tool result and get a panel you can put in your own page.
npm i @aitherium/awkit
The man page for the Aither World — every brick, stack and law, offline.
The family is only useful if you can find it. Its registry lives in one yaml in one monorepo and the laws live in a public skills pack, so a stranger with a terminal and no browser can reach neither — which makes "what exists and what should this talk to" a question asked of a person instead of a tool.
Start here: Ask it what a brick does and get the answer with your network cable out.
pip install awkno
A portable, scoped agent memory.
An agent that forgets everything between sessions re-derives the same facts forever; one that remembers everything globally leaks context across projects.
Start here: Give one agent a memory scoped to one project and watch it stop re-asking.
pip install awm
Give an agent an email address — send, and actually receive.
An agent that cannot send email cannot finish most real errands: it drafts the invitation, the receipt, the reply, and then hands a human a block of text to paste somewhere. The usual fix is a transactional provider, which means a domain, DNS records, a paid account and a warm-up period before the first message — an afternoon of setup to send one email from a mailbox you already own. Receiving is worse: almost nothing gives an agent an inbox, so agents are write-only and cannot close a loop that a person answers by replying.
Start here: Send one email from an agent using a mailbox you already own, in about a minute.
pip install awmail
A front gate you can put in front of anything, and hand someone the key to.
Letting one specific person reach one specific thing is still, in 2026, either a whole identity deployment or a link anyone who sees it can use. So everybody ships the link: an unguessable URL in an email, no expiry, no audience, no record of who walked through it -- and no way to take it back without breaking it for everyone.
Start here: Put a gate in front of one URL and let exactly one person through it with a code you sent them.
pip install awnboard
Prove there is a human before you let them into the nest.
Any surface an agent can use, a bot can flood. CAPTCHA is hostile to the humans it is meant to serve and is beaten by the machines it is meant to stop, so the check has to be something other than a puzzle -- and every check that does exist fails OPEN, because "we could not tell" and "it is fine" reach the caller as the same empty value.
Start here: Gate one action behind a human check and watch an automated caller fail it.
pip install awnest
Predict what your environment does next, and how surprised you were.
An agent that cannot anticipate its environment can only react. Every framework that offers this makes you adopt its whole training stack to find out whether a learned model beats the lookup table you already have.
Start here: Wrap an environment you already have and ask it what happens next.
pip install awpredict
Turn a failure into ranked hypotheses — and say what would confirm each one.
Debugging with an agent collapses onto the first plausible story, because nothing forces a second. The cost is not the wrong guess, it is the hours spent proving it — measured repeatedly here, where five hypotheses were spent on a service that was genuinely correct, and where a symptom named the wrong component so consistently that "the symptom names the INNOCENT service" had to be written down as a standing rule.
Start here: Hand it a failure and get back ranked candidate causes, each with the one observation that would rule it in or out.
pip install awprism
A portable reasoning client — sessions, phases, thoughts, and the chain that produced the answer.
An agent that reasoned well and an agent that reasoned badly return the same shape: one paragraph. So a wrong answer is indistinguishable from a right one until it has been acted on, and the only available debugging tool is asking again. The structure exists inside the model turn and is discarded at the boundary, which is why nothing downstream can ever check it.
Start here: Run one hard question as a session you can open up afterwards — the phases, the thoughts, the tool calls — instead of a paragraph you have to take on faith.
pip install awreason
Labelled snapshots with an all-or-nothing restore.
A restore that half-succeeds is worse than one that fails, because you now have a state that never existed.
Start here: Snapshot one directory, break it, restore it, diff it.
pip install awrecover
Answer a question over a context far larger than the window — recursively, with the trace kept.
A context window that overflows does not raise. The middle is dropped, the model answers fluently from the ends, and the reply looks exactly like one drawn from the whole document. The failure is a SILENCE — no error, no truncation warning, no shorter answer — and the only signal is that it is quietly wrong about the part nobody checked.
Start here: Ask a question about a document far bigger than your model's context, and get an answer that names which parts it actually read.
pip install awrecurse
Portable agent messaging — findings, alerts, coordination.
One agent's transcript is invisible to every other agent, so a conclusion reached once gets re-derived by the next session that hits the same symptom.
Start here: Have one agent post a finding to a channel a human can also read.
pip install awrelay
A REPL an agent can actually use — state that survives between turns.
An agent given one-shot shell commands rebuilds its whole world on every call, so it guesses instead of looking — and in a transcript a guess is indistinguishable from a reading. Every variable it wanted is gone the moment the command exits, which is why agents describe state rather than inspect it.
Start here: Give an agent a live session it can keep poking at, so the next question is asked of the object instead of of its own memory.
pip install awrepl
Ask a research question, get a cited report you can check.
An agent asked to research something returns a fluent report whose citations were never read. The failure is not a refusal and not an error — it is a plausible document, which is the most expensive possible output, because checking it costs more than writing it did.
Start here: Ask one question and get back a report where every claim carries the source it came from.
pip install awresearch
Sign an artifact so a stranger can verify it.
"Download this and run it" is a request for trust with nothing behind it.
Start here: Sign one release file and hand someone the verify command.
pip install awseal
Your terminal answers you -- type a question where a command would go.
A shell has exactly one response to a line it does not recognise: command not found. So the moment you want to look something up you leave the terminal for a browser and lose the directory, the environment and the session you were already in -- when everything needed to answer you was right there.
Start here: Type a question at your prompt and get an answer instead of "command not found".
npm i -g awsh
Publish an artifact and fetch it back verified.
Publishing is easy; proving the bytes that arrived are the bytes you sent is the part everyone skips.
Start here: Publish one file and fetch it on another machine with verification on.
pip install awshare
Keep one client in step with a platform — and never confuse "cannot tell" with "fine".
A deployment that drifts is worse than one that breaks: it is silently out of sync, reporting success while the platform has moved on. Every sync daemon hides this by collapsing network failures into empty results, so "could not tell" reads as "in step".
Start here: Send a heartbeat up and receive pack updates down, and know exactly what changed.
ships inside AitherConnect
Reach a service that has no public address.
Everything an agent runs is behind NAT on somebody's laptop, and every workaround (a port forward, a public IP, a broker somebody maintains) becomes permanent.
Start here: Expose one local port to one remote caller and take it away again.
pip install awtunnel
PowerShell 7+ automation framework — numbered, self-describing scripts.
Ops knowledge lives in people's shell history, so the same recovery gets improvised differently every time it is needed.
Start here: Run one numbered script and read what it says it did.
git clone https://github.com/Aitherium/AitherZero
How to run a coding agent so the result survives — the laws, with evidence.
Everyone learns the same lessons about agent-written code the same expensive way, and writes none of them down where the next person looks.
Start here: Read one law and apply it to the next thing you ship.
read it — https://aitherium.github.io/awskills/codex.html
Portable agent skills — self-contained procedures an agent loads on demand.
Prompt knowledge dies in a transcript. A skill is a procedure written once, in a file, that any agent can load when the situation calls for it.
Start here: Copy one .md into your agent's skills dir and tell it to use that skill.
git clone https://github.com/Aitherium/awskills
A Linux you can hand to an agent — immutable base, capabilities included.
An agent with root on a mutable host eventually produces a machine nobody can reproduce.
Start here: Boot one throwaway box and try to make a change you cannot reproduce.
see the repo — image builder