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.
What a creative turn needs, on hardware the operator already owns: a way to find things, a way to read a page, a way to research with citations, and a way to actually render and master the result. Named because these kept being proposed as ONE product, and the measurement said they are three INPUT surfaces and one OUTPUT surface -- which composes and does not merge. Every member is adoptable alone; the stack is a suggestion.
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 are the two it has; voice, vision and the screen in front of it are the three it does not, and they are named here so they stop being rediscovered as absences.
Spawn more than one Persona-driven avatar at once, bind each to a distinct awdk agent persona (its own Library/pack, its own model), render them together in one shared scene, and let them hold a live concurrent conversation with each other and the owner -- steered from awsh as the cockpit. Registered 2026-08-24 per EC003: "give an avatar a face and a mind, then let several of them talk" cannot be said without naming the companion, the agent runtime and the shell that steers it, so this is a stack over existing bricks, not a new brick (same reasoning as `awsprite`, which this stack composes with directly).
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.
Owner directive 2026-08-24: someone with a laptop, a desktop and a phone should be able to join their OWN devices into one pool and have a model stay warm and servable across whichever of them is on, without joining the platform's shared AitherNet compute market. Registered here because it does not exist yet, and the three pieces that would compose into it are each individually real: `awnet` is a peer REGISTRY + three-valued TCP reachability check ("is anyone listening") -- explicitly not a VPN and not a placement/pooling primitive, by its own README; `awnode` is the local gateway that would route a request to whichever peer has the model warm; `awdk` is the runtime that would run on each device. None of the three knows about model PLACEMENT or WARM-KEEPING across peers today -- that logic is the actual gap, not the transport (mesh-deploy/WireGuard already exists for that) and not per-node serving (node-bootstrap already detects hardware and stands up a local backend). The closest existing precedent is the platform's own DGX+5090+RTX ggml-RPC pooled-inference stack, run at fleet scale and never packaged as something a customer's own device fleet can stand up for itself. NOT `aithernet-provider` (that joins the PLATFORM's community pool with settlement -- a different shape) and NOT a rename of the fleet's pooled-inference stack (EC003/client-not-lift: that stack is thousands of lines of fleet-specific orchestration; a personal-pool brick would be a small client speaking to whichever peers `awnet` says are reachable, same relationship as `awrelay` to `AitherRelay.py`). SHARPENED 2026-08-24, owner asked to "start serving all of our model stack from the mesh pool for flexibility": the ggml-RPC precedent is NOT a general placement layer and generalising it directly would be the wrong move -- it does TENSOR-LEVEL SPLIT serving for ONE model too large for any single box (DeepSeek-V4-Flash, 97-108 GB, routed experts pinned to the DGX's 121 GB by design), hand-tuned per model (custom RPC server build, per-backend thread counts, a dedicated watchdog/alerting stack -- see `pooled-inference-ops` skill). Bonsai/Qwen3.8/gemma4 do not need splitting, they fit one GPU each; what they need is PLACEMENT (which box, right now) plus WARM/PARK lifecycle across many small models competing for few GPUs -- a different problem the RPC pool was never built to solve. The real placement layer already exists in shape (`AitherCompute`'s `gpu_power_state` -- hot/parked/on_demand, idle-reap) but is currently DEAD fleet-wide (D-2158: no docker socket reachable from its container) -- so today NEITHER the platform's own stack nor a customer's personal pool has a working dynamic-placement layer; the gap is the same gap at two scales.
Owner directive 2026-09-21, the day Meta announced Muse: the same journey has to compose HERE from bricks a stranger can install -- a desk body (awdesk) that hosts the aitherium.com Living Desktop over the real desktop and embodies an agent as an avatar; the browser body (AitherConnect) that puts the same overlay over any page; a companion (awsprite) that grows a knowledge base from what its owner teaches it, remembered in awm, built and grown with awdk packs; self-service self-hosting (awnix / awnode / awsh) so the whole thing runs on the owner's own box; device registration through a front gate (awnboard + awiam); and tunnels between those devices that the PLATFORM cannot read. Every seam was measured, not assumed: awdesk already loads aitherium.com/?mode=overlay and reuses AitherConnect's overlay-mode protocol; awdesk registers a local MCP server so awsh/adk can drive it; device enrolment lives in a tenant backend (`devices.py`) and the tenant node table (`/tunnel/tenant/{t}/nodes`). What did NOT hold on 2026-09-21: every tunnel enrolment path minted the device's WireGuard private key SERVER-SIDE and `_save_peers` persisted it to the vault, so the platform could read any device's tunnel -- fixed the same day (bring-your-own public key on every enrolment endpoint, device private keys never persisted; `test_tunnel_key_custody.py`). Owner-blind device-to-device tunnels already exist and are the DEFAULT: `adk join` (awdk/adk/commands/join.py) brings the node up on the headscale tailnet (`hs.aitherium.com`, /health 200 on 2026-09-21) with a mesh key minted by Identity -- node keys are generated on the device, traffic is peer-to-peer WireGuard, and the control plane sees public keys only. The AitherTunnel hub VPN is the lane for reaching platform services and dev workspaces; it terminates at the hub by design. Still `partial` because awsprite is `planned` and mobile chat is Discord-only.
awdesk AitherConnect awsprite awdk awm awkno awknowledge awnboard awiam awtunnel awnet awnode awnix awsh
Owner directive 2026-08-24, reinforcing the existing AitherSprite Phase 2/3 roadmap (the product architecture doc and the knowledge-companion program doc): AitherSprite today is playable but shallow -- flat per-sprite knowledge rows, titles-only in the talk prompt, server-side inference only, and "download it" is a paid pack with no guided path to actually WIRE it to real local tools and data. The directive is four upgrades composed together, and none of the four pieces is new -- the gap is that nothing connects them for this product: teaching should build a real personal knowledge GRAPH (`awgraph` is a CODE graph today -- CodeChunk/CodeGraph/CodeGraphStore -- and `awm` is scoped FACTS, not a traversable graph; a per-user knowledge graph does not exist as a brick yet); the companion should run and be TRAINABLE fully in-browser on `awbonsai`, not only through a server round trip; and graduating a companion should walk the owner through a real self-service CONNECT of `awdk` + `awsh` + `awnode` on their own machine -- the same shape as the self-host guide's stranger-to-provider flow, but ending in "your companion can now use your files/tools" instead of "your GPU now serves the mesh". NOT a rewrite of the companion engine -- its deterministic core (needs/mood/evolution, no I/O) is correct and stays the server-authoritative source of truth even for a browser-trained companion, so growth cannot be forged client-side (a fail-closed gate is not optional). What changes is WHERE teach/talk execute (in-tab via `awbonsai` when offline or pre-account, server via MicroScheduler when connected) and how knowledge is stored (a graph, not a flat table).
Owner directive 2026-09-01: decentralise storage and inference across the aw* stack so anyone's node can join the mesh, share models and resources, and pool inference -- including cross-model KV-cache sharing across nodes. Registered because each plane is real INSIDE the fleet and absent at the public boundary: the overlay (AitherMesh + Conductor onboarding) is deployed and `awnet` fronts it; `awnode` routes to a warm peer; same-model warm-prefix sharing exists as llamacpp_connector + kv_catalog (Nexus) + Strata as the cold tier; cross-model maps exist as lib/gpu/kvtransfer; `awswarm` holds the sub-layer placement math; `aitherkvcache` quantises the cache; `awrtifact` ships the packs; `awnix` is the box a contributor boots. What no brick does yet is let a STRANGER'S node discover a warm prefix, receive a mapper pack, or get settled for serving -- `awcache` is the first of those three; settlement is the external OmniNode plane described in .AITHEROS/35-OPEN-WEIGHT-FRONTIER-MOE-SERVING.md (Phase 4). Phasing and the measured numbers: .AITHEROS/36-PLAYGROUND-ROULETTE-AND-COMPUTE-COMMONS.md Part D.
awnix awnode awnet awcache awswarm awpool aitherkvcache awrtifact awtunnel awwall
The searching tools are only as good as the vectors under them. awembed trains the embedder on your corpus and proves it on held-out directories; awgraph, awfind and awm then search, rank and remember over vectors that know your code instead of someone else's. awdk agents consume all of it as tools. awdata carries the labelled corpora the proving is done against -- the half that usually never ships, and the half that decides the answer: the same compression measured -0.006 macro-F1 on source files and -0.10 on real Reddit comments.
Procedurally generate a playable, persistent-realm 3D world -- zones, quests, living NPCs on a decide-door mind stack, creatures, their bodies, rigs, clips and style renders -- from Saga narrative and Prometheus balance, hosted by the Dark Matters engine (the CoC story engine grows the world; owner decision 2026-09-21) with the World of ClaudeCraft-derived realm as the PG public world and sim donor, and the same character carried into awdesk and a Space.
One world that runs, not a text box that continues — with a story graph, typed mechanics, a continuity checker, MCTS branch explorer, simulation backend, and persistent memory. One creative studio with 357 routes and 137 named ops — character rigs, animation, LoRA, comics, VN, production loops with human gates — all agent-callable. One visual artist that plans, enhances, calls the studio in a real loop, evaluates and refines. Run it all on your box with awdk + awnode + Bonsai, or on the cloud with the same key. Sold as credits and subscriptions; created work published to the marketplace with revenue share.
awsaga mediaforge awiris awsprite awdesk awbonsai awdk awnode AitherConnect awrtifact
What a scheduled agent needs so that "it ran" is a fact and not a hope: a host clock that wakes it (awrise), a durable queue it hands work to (awrun), a line a human can read when a wake goes wrong (awrelay), a card when a wake needs a decision (awask), and the agent that gets woken (awdk). Named 2026-09-18 (plan .AITHEROS/39) because every member exists and every one was proposed as the place the schedule should live; the measurement said the clock is the OS's and the brick's job is the memory.
MicroScheduler for someone else's agents, as three bricks a stranger adopts alone: awrouter decides which backend serves model X right now (the STATELESS routing plane extracted from AitherMicroScheduler.py -- 19,535 lines / 107 imports, never lifted), awrun is the durable priority queue, awrise is the clock that wakes work and records what happened. awnode is the local gateway an app points at instead of a vendor URL; awdk is the loop that runs on top. The stateful platform half (budgets, heartbeats, throttling, agents) stays inside the fleet and CONSUMES these. Registered 2026-09-19 because the owner asked 'how are we open-sourcing MicroScheduler' and the answer was already three registered bricks that no stack named together.
The substrate a cluster orchestrator gives agent workloads, as bricks a stranger adopts one at a time on one machine: awrun is the unit of work (priority, suspend, resume, declarative apply, limits and egress that FAIL CLOSED); awflow is why a resumed run continues instead of restarting (the journal is the checkpoint, finished model calls replay); awrise is the clock; awrouter and awnode decide which model answers; awdk is the agent loop and awrepl its live session; awnix is the machine. Governance is not a later phase: awiam says who, awbac says whether, awdit records it before it happens, awseal signs a run that leaves the machine and awshare verifies the one that arrives. Registered 2026-09-21 when a cluster-native agent orchestrator was announced and the question "did we already build this" had no single place to be answered from.
awrun awflow awrise awrouter awnode awdk awrepl awnix awiam awbac awdit awseal awshare
Every wake becomes evidence: on start, awm recall hands the job its own history (what failed last, what fixed it); before an expensive wake fires, awpredict reads the ledger as an environment and says whether it will time out again; on finish, the row is remembered, and awevolve may tune interval/timeout under AVO006 (the scorer is never the mutable file). Registered 2026-09-19 at planned: fleet-gates timed out twice in its first day and both were predictable from row one; nothing was watching.
The closed learning loop (pillar 6) scheduled by the thing it improves. Every utterance->intent->tool->outcome and every ledger row (prediction vs what happened) is harvested (AitherHarvest /import/batch -- 5,151 lines / 32 imports, so a SINK on awrise, never a brick); the trainer fine-tunes the intent router and the decide door on it (AitherTrainer, 4,902 / 56, a consumer whose training routines become wakes); awlab scores it on a leaderboard the loop cannot edit; awevolve keeps or reverts (AitherEvolution's client) under AVO006; the result lands back in awdk intent.py and awrise's timeouts and intervals. Registered 2026-09-19, partial: every seam exists in-fleet, none is wired to a wake, and awlab is not yet a package.
The owner's ask, 2026-09-20: mine Claude Code and other agent terminal sessions automatically and turn what they contain into agent packs, skill packs, tool packs, RL outcomes, world-model and awpredict training, AitherCNS state and ARC-solver evidence. awmine reads the transcripts (it is the miner AitherHarvest never had for this source -- measured that day: 954 transcripts changed, zero mined); awtoll prices them; awm keeps the lessons; awdata holds the labelled corpora; awdecide is taught every tool outcome; awskills and the awdk toolpacks are where a repeated procedure becomes a pack; awrise is the wake that runs it on a schedule and records that it ran. The fleet's AitherHarvest, Trainer, Evolution and CNS are CONSUMERS of what awmine emits, never the miner.
Using every agent, skill and fleet tool from a terminal without Claude Code. awsh is the door, the awdk harness daemon (:8362) is what it opens onto, awnode is the fleet behind it, awdesk's Console is the same door with a face, and the skills are read where they already live. Done when: `adk harness new --harness awdk --agent saga --skill gauntlet` answers as Saga following the protocol (LIVE 2026-09-21, 26 agents generated from config/identities); saga/vera/iris appear in awsh and the desk menu with no hand patch (LIVE); `awsh> /skills` prints host N | genesis N | gateway N | drift 0 (code landed, deploy pending); the desk Command pane routes @agent /skill through the daemon (not started).
Claude Code with the family wired in, each piece taken on its own: a plugin that makes any harness a native subagent, scoped memory recalled at session start, peer findings delivered in-turn, a code graph and a finder as MCP servers, a shared-worktree git that commits only your paths, a spoken reply on Stop, a settings preset that keeps portable and machine-local settings apart, and the doctrine and skills an agent loads on demand. Every surface is listed per brick under `In Claude Code` and is generated from this registry.
awdk awsh awsettings awskills awknowledge awkno awgit awrelay awm awgraph awfind awfocus awprism awdecide awvoice
One integration, every surface. awsuite holds the Google Workspace client and one tool table; awdk loads it as a toolpack, awsh and Claude Code reach it as an MCP server, awskills carries the playbooks, and awpack ships the bundle to a tenant. Swapping the harness keeps the tools and the confirm gate.
One file you run, and the machine has a local AI stack.
Every part of the stack ships on its own lane -- a shell on npm, two runtimes on PyPI, a desktop app on GitHub Releases, an extension in a browser store -- so a person who wants the STACK has to find six things, install them in the right order and make them agree on ports and models. Measured 2026-09-10: every one of those lanes was live and the thing that joins them was published nowhere.
Start here: Run one file on a fresh box and open the URL it prints.
see the repo — one binary per OS from the `aitheros-v*` release
Stream a multi-gigabyte model onto a device that cannot hold it all at once.
Getting weights into a browser is a PEAK MEMORY problem wearing a download's clothes. Every loader materialises a whole tensor before it uploads it, so the largest tensor -- not the model -- decides which devices can run it, and the device finds out only after it has spent the bytes. The limits are knowable first: the GPU adapter publishes them, and a side-car manifest can publish the largest tensor a file contains.
Start here: Stream one GGUF from any Range+CORS URL into a bounded buffer, resumable from the device's own cache.
builds in-tree
Run a real model in the visitor's own browser — no server round trip, no upload.
Every in-browser LLM demo either phones home for the real answer or downloads a few hundred MB unasked. Getting BOTH right -- genuinely local inference, and a consent gate that runs BEFORE the fetch instead of after -- is the part nobody ships, so most "runs in your browser" claims are marketing for a server call.
Start here: Load one page and get an answer from a model that never left the tab.
git clone https://github.com/Aitherium/awbonsai
Your history as a wiki of linked markdown — claims pinned to the evidence.
Every AI memory system sells you a black box: sessions vanish into a vendor cloud, and "it remembers" means "the vendor's model was prompted with a blob". Memory should be files you can read, claims you can check against the session or file that produced them, and retrieval that never dumps your whole history into a prompt.
Start here: Point it at a folder of notes or sessions; ask a question your context never held.
pip install awbrain
In Claude Code:
/awbrainLet a second node skip its prefill because a first node already paid for it.
Two nodes serving the same model both pay full prefill for the same document, and two DIFFERENT models cannot share a cache at all. Measured 2026-08-31 on this fleet, KV accumulates at 0.515 Mbps -- a 5,061-token cache moves in 0.42 s over 1 Gbps against 819 s to recompute -- so bandwidth is not the constraint; discovery (who has this prefix warm?) and trust (is this map safe to load?) are. The failure mode of a WRONG cache is the worst one in inference: no error, fluent, confidently-wrong text.
Start here: Serve one prompt prefix from one node and have a second node skip its prefill by fetching the cache by content digest.
builds in-tree -- not on PyPI yet; `pip install awcache` 404s today
The AitherOS daemons as one file — no Python, no signing, no install.
Shipping the agent loop and the shell harness means shipping a Python environment, and freezing the whole CLI to get them drags in the entire ML stack: 694 MiB and 164+ PyInstaller hooks to obtain two subcommands.
Start here: Run it on a box with no Python and curl its /health.
see the repo — built by awdk/packaging/build_executable.py --narrow
Aither World Desk -- the desktop body of AitherOS Online: tray, avatars, decision cards, the Living Desktop as an overlay.
Every surface an agent has on a laptop lives in a browser tab that can be closed, minimized or forgotten. The desk is the one that stays: an always-on presence that can interrupt you with a decision card, embody an agent as an avatar, and hold the Living Desktop over your real desktop.
Start here: Run it, and the next decision card an agent raises pops on your desktop instead of scrolling past in a log.
see the repo -- Electron app (npm install && npx electron .)
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
In Claude Code:
awsh@awshadk claude setupadk claude doctor/awdkA deterministic workflow runtime — chain agent calls with journal replay and budget control.
Workflows need deterministic orchestration with journaled execution so every call, every branch decision, and every result can be captured and replayed from any point. Agents running a workflow need to see the same progression whether they are in the middle of a live run or resuming from an earlier checkpoint.
Start here: Chain parallel and sequential agent calls with deterministic ordering, a persistent journal, and hard budget enforcement. Replay from the journal at any breakpoint.
pip install aitherium-awflow
In Claude Code:
/awflowAn ARC training gym — a game a world model can watch, and six roles that play through it.
A world model is only as good as the play it watches. Solver runs stream past, checkpoints get trained on whatever happened to be recorded, and nobody can answer "did the model actually get better at predicting the next grid?" against transitions it has never seen.
Start here: Play one ARC game end-to-end with the world model watching every transition, then ask it to predict the next grid and watch the surprise score fall.
pip install awgym
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
In Claude Code:
/awnodeThe free half of the elastic work pool: dispatches public-safe work onto the free GitHub-hosted runners of the public aw* mirrors, so their idle CI minutes become compute. awrun remains the paid/self-hosted lane; this is its free twin.
The monorepo's hosted runners are billing-dead and its self-hosted pool is CPU-bound, while the public mirrors run free hosted CI that only ever executes their own sync and publish lanes. The capacity is real and not pooled: nothing routes monorepo public-safe work to it.
Start here: Dispatch one public-safe job to a public mirror's free runner and watch it execute.
pip install awpool
OpenRouter for your own fleet: pick a model backend by cost/latency/ capability, fail over, fit the context window, stream. Standalone, OpenAI-compatible, no Aither-specifics required to be valuable.
Every LLM call in the platform routes through MicroScheduler (:8150) -- but the routing logic (backend discovery, failover, tier maps, context fitting, streaming) is buried inside a 19,535-line service with 107 monorepo imports. A stranger cannot run it: it demands the internal CA, services.yaml discovery, secrets at :8111, the fleet's model inventory. The routing plane is valuable standalone and entangled by accident of packaging, not by design.
Start here: Point it at your backends (vLLM / llama.cpp / any OpenAI-compatible endpoint); ask it which backend should serve model X right now, or to stream a completion with failover and context fitting.
pip install awrouter
A priority-aware queue and dispatcher for agentic runs and ad-hoc CI builds. It also judges whether the runner pool is big enough for the queue it is draining, and can ask a host to grow it -- reserving capacity is zero-sum, so a saturated pool needs more of it, not a different share of it.
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
A place, not a page: every human gets a Space -- a hand-made page, files and a companion agent that is theirs -- and Spaces link to Spaces. Early-2000s internet (Neocities, Newgrounds, Neopets, RuneScape) with local-first AI underneath.
The web stopped being a place humans make things in and became feeds that are made at them, and the first thing AI did there was flood it with bots. There is no surface where a person keeps a page, a companion that works for them, and a community they can find on purpose -- with the agent as a tool, never a peer.
Start here: Mint a Space on this device and open it in the browser -- a page, your files, your companion.
planned -- no package yet
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.
https://chromewebstore.google.com/detail/awconnect/peeojgjhjficedkncdejbfnacooodbak
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
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
One character spec in, a rigged, animated, multi-style avatar pack out.
A generated 3D character is five artifacts from five tools (mesh, rig, clips, VRM, style renders) with no shared contract, so every host re-derives what it may load, and the bakes end up .gitignored with no canonical home -- measured 2026-09-05 on the CoC engine, where every Anny body and every clip pack is absent from disk while the code that drives them is committed.
Start here: Validate one character_spec.json and one character_pack/ against their schemas and refuse the pack if any file's hash, licence or rig audit is missing.
pip install awavatar
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 spatial canvas for a page — arrange things, connect them, and keep the arrangement.
Every product eventually grows a screen where things are placed rather than listed — a board, a map, a graph of what connects to what. That screen is almost always re-implemented per product, and the arrangement lives in component state, so it dies on reload and cannot be exported, reviewed, or moved to another surface. Measured on this tree 2026-08-24, the same hand-vendored tarball appears in three separate product frontends because there was no registered brick to depend on.
Start here: Drop a canvas into one page, arrange two things on it, reload, and find them where you left them.
git clone https://github.com/Aitherium/awbeads
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
In Claude Code:
/awbrowsePrivate camera recording and one-line event summaries, on storage you own.
Home cameras record to someone else's servers, keep footage on their terms, and tell you "motion detected" forty times a day without saying what moved.
Start here: Point it at one RTSP camera, enable it, and read back a one-line description of each event.
builds in-tree -- not on PyPI yet; `pip install awcams` 404s today
Classify any document -- what it is, who may read it, who it is for, what it is about.
A corpus nobody has classified cannot be published safely or retrieved well: the one internal page in a public mirror is found by a stranger, and the question that needed a design note gets a changelog. Classification must be a standalone step any pipeline can call, not a judgement buried in a model prompt.
Start here: Run it on one file and read what it is, who may see it and what it is about.
pip install awclassify
One typed-decision contract -- choice / score / bool with a probability -- over a ladder of backends you already run (rules, tiny local models, an LLM's logprobs), fail-closed, with a Brier ledger that resolves every decision against its outcome.
Software makes the same bounded decision millions of times and asks a text model each time, then parses prose. Hosted "decision models" fix the shape but send the program state off-box, emit a probability that is never resolved against what happened, and cannot say what happens next if you act on it. A decision is a function; the loop it sits in is the product.
Start here: Ask one typed question of one state and read back a decision, a probability, and decided=False when nothing earned it.
pip install awdecide
In Claude Code:
awdecide mcpAn outline becomes a narrated video -- and the file says which voice really spoke it.
A rendered video looks identical whether a neural voice plane narrated it or a 2010-era desktop speech synthesiser did, so the artifact cannot be audited by looking at it. Measured 2026-09-19: one long-job transport failure was read as "the fleet is down", the render silently fell back to Windows SAPI, and the only thing that caught it was the owner listening to six minutes of it. Separately, the voice service accepts a `voice` parameter and serves en-GB-SoniaNeural whatever you ask for, so even the non-degraded path was not the voice chosen.
Start here: Turn a JSON outline into a narrated MP4, and read back which voice actually spoke it.
builds in-tree (pip install -e .); not on PyPI yet
Anonymous multi-round expert panels — a converged answer with a trace.
A single expert opinion is one opinion; a panel that reads each other's names converges on the loudest voice, not the best argument. Delphi panels need anonymous rounds, aggregate feedback, and an honest stop rule.
Start here: Run a multi-round anonymous expert panel on a question and get a converged answer with a trace.
pip install awdelphi
In Claude Code:
/awdelphiAn 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
Train an embedding model that knows your corpus, and prove it beats the big one.
Every agent stack searches your code with an embedding model trained on someone else's. It is right about two thirds of the time on a corpus it never saw, and nothing in the stack measures that. Distilling a small student on your own corpus -- the big model's margins plus your labels -- beats the big model, and the eval that proves it is the part people skip.
Start here: Point it at one repo and get a 0.6B embedder that ranks your directories better than the 7B one it learned from, with the eval that proves it.
pip install awembed
In Claude Code:
/awembedPoint 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
In Claude Code:
awfind mcpSee, search and steer every Claude session from one command.
Every session is a tab; nothing answers "which session is doing what, where did I say X, how do I tell that session to do Y" without hunting.
Start here: List your live sessions, search their transcripts, and focus or message the one you want.
pip install awfocus
In Claude Code:
awfocus mcpA render pipeline you drive from an agent — grade, master, animate, train.
Creative work is the last thing most people will hand to somebody else's machine, and the first thing every creative SaaS requires. The pipeline is not the hard part -- grading, mastering, avatar export and LoRA training are all solved -- the hard part is that reaching them means a GUI a human sits in front of, so an agent cannot help and the footage has to travel.
Start here: Grade one clip on your own GPU and get the master back, without opening an app.
builds in-tree -- no PyPI package yet; published when it is
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
In Claude Code:
awgit mcpA 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
In Claude Code:
awgraph mcpWho 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
Hand it three reference images and get one style card and one critique back.
Character-consistent generation loses the character after a few iterations when the render is locked to prompts alone. Style cards + critique let an artist pipeline run unattended and hold identity across a full production.
Start here: Hand it three reference images and get one style card back.
not on PyPI yet (pending publish)
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.
git clone https://github.com/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
In Claude Code:
/awknoRun one experiment, keep the score, and let a loop decide against it.
Every self-improving loop needs a number it cannot edit. Without a scorer that lives apart from the thing being changed, the cheapest way to win is to change the report -- and every downstream signal agrees it improved.
Start here: Register one experiment with one scoring command, run it twice, and read the leaderboard.
planned -- no package yet (AitherLab.py is 751 lines / 6 imports; the lift is the build)
Ask your logs what is actually failing, instead of grepping them.
Log data is almost never missing. It is written diligently, durably, in structured form -- and then nothing indexes it, so the only way to ask a question is to grep gigabytes by hand and hope you guess the right string. A directory past a few hundred megabytes is functionally write-only: every producer works, every file is current, and nobody can answer "what broke on Tuesday". The failure has no error and no alert, because nothing failed -- something merely never got read.
Start here: Point it at a directory of log files and ask what is failing most.
ships with the AitherOS install; run `awlog --help`
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
In Claude Code:
awm mcpawm recall --claude-hookGive 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
Mine what your agents did -- outcomes, lessons and procedures out of the transcripts they left behind.
Every agent session leaves a transcript, and almost every transcript is thrown away. The correction a human made at turn 40, the retry that finally worked, the six-command sequence three sessions each re-derived -- all of it sits in JSONL nobody reads, while the next session starts from zero.
Start here: Point it at one transcript directory and read back what those sessions learned, with the line each lesson came from.
pip install git+https://github.com/Aitherium/awmine.git
In Claude Code:
/awmineWire the agent harness you already use into a fleet you already run.
Every agent harness reinvents the same four wires -- tool discovery, a credential, session identity, and memory. The wiring gets written inside whichever repo needed it first, so it is invisible to the next harness and dies when that repo moves on. The integration that works best is usually the one nobody else can install.
Start here: Point one harness you already use at a fleet you already run, and get its tools inside it.
planned -- no package yet
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 git+https://github.com/Aitherium/awpredict.git
In Claude Code:
/awpredictTurn 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
In Claude Code:
awprism mcp · plannedDrive a page as the real user, check what rendered, and get a test that goes red if it stops being true.
Every failure that enrages a user answers 200: a lock screen shown to someone already signed in, an empty knowledge base, a chat panel that says "backend unavailable". A route probe, a healthcheck and a test suite all pass while the product is unusable, because none of them looks at what actually rendered. And the one-off script that finally catches it is thrown away, so the same class regresses a week later with nothing watching.
Start here: Write one journey as a real user takes it, name the truths that must hold on the page, and get back a PASS/FAIL plus a gate that pins each truth.
builds in-tree -- not on PyPI yet; `pip install awprove` 404s today
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
In Claude Code:
/awreasonLabelled 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
In Claude Code:
/awrecursePortable 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
In Claude Code:
awrelay mcpawrelay inbox --claude-hook --direct-onlyPut 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 awrena
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
In Claude Code:
/awreplFile a bug report that has already scrubbed your secrets and collapsed the duplicate.
A bug report is the artifact most likely to carry a credential -- logs, a config dump, an env var someone exported to reproduce the fault -- and the person writing it is already frustrated and will not read it twice. So the secret ships, or the report never gets filed at all.
Start here: Turn a failure into a filed, redacted GitHub issue that collapses into the duplicate when one exists.
pip install awreport
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
In Claude Code:
/awresearchThe coding sessions you had open, reopened after the reboot.
The set of sessions actually open exists only while they are running. A reboot, a crash or a closed window takes it with them, and what you get back is a list of every session you have ever had, sorted by a timestamp that does not tell you which were live. Guessing wrong opens a second view of one conversation.
Start here: Snapshot the coding sessions open on this machine, then reopen exactly those after a reboot, each in its own terminal tab.
not published yet (pending a public repo)
Wake an agent on a schedule, let it do one thing, and put it back to sleep.
A scheduled agent fails as a SILENCE. A wake that never fired because the host was down, a wake that overlapped the run before it and corrupted shared state, and a wake that hung forever holding its slot are INDISTINGUISHABLE from outside: in every case nothing happened and nothing said so. Cron has no memory -- a missed minute is simply gone -- so "not due yet" and "due, and never ran" read identically, and the operator finds out days later by noticing absent output rather than by being told.
Start here: Wake something on a schedule, let it do one thing, and put it back to sleep.
pip install awrise
In Claude Code:
/awriseDeliberately chunk artifacts into GitHub release assets — the productized aitherkvcache mirror lane.
Big artifacts (model weights, datasets, builds) exceed GitHub's 2 GiB release-asset cap, so mirrors end up as bespoke scripts with hardcoded manifests that go stale — the fleet's orchestrator served a pre-v18 build for days while the v18 file sat in a release the worker did not know.
Start here: Store one artifact as a versioned GitHub release and fetch it back byte-verified — `awrtifact mirror <URL|FILE> --release TAG`.
pip install awrtifact
In Claude Code:
/awrtifactStart a world from a pack and take one turn the continuity checker can refuse.
A narrative engine that writes forward forever is cheap; one that catches when the story breaks is the part nobody builds. Character deaths contradict later scenes, NPCs appear in two places, relationships quantify as impossible, and the reader never hears about it until they notice.
Start here: Start a world from a pack and take one turn that the continuity checker can refuse.
not on PyPI yet (pending publish)
One scope graph for work and home, where crossing between them takes consent.
Work and home context end up in one tenant with a flag per record, so leaving the company takes your household with it, "share with my family" is a toggle nobody can expire or revoke alone, and an unknown scope reads as no restriction at all.
Start here: Give one household read access to one person's calendar, check it, then revoke it.
not yet published; builds in-tree
See this machine — what is on screen, and where to click it.
Automating a desktop means naming things that have no names. Coordinates rot on the next resize, selectors do not exist outside a browser, and the one thing that does not change is what a human would see and point at.
Start here: Find the thing you want to click by describing what it looks like.
pip install awscreen
In Claude Code:
/awscreenSign 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 agent's permissions and config, following you to the next machine.
An agent harness keeps its permission allowlist, enabled tool servers and hooks in a local file. Work from a second machine -- a laptop, a shell session, a dev container a phone just opened -- and none of it is there. You re-approve the same action, by hand, once per surface, forever, and the copies drift apart while every one of them looks correct.
Start here: Point it at your agent's settings on one machine and have them show up on the next one you open.
pip install awsettings
In Claude Code:
awsettings preset apply aitherium-claudeYour 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 @aitherium/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
In Claude Code:
/awshareHatch a companion that grows only from what you teach it, then take it home.
A companion that never changes is a toy, and one whose growth you cannot see or edit is a black box. Most "AI pet" products are a chat window with a sprite pasted on top -- nothing you taught it persists, and nothing about how it grew is checkable.
Start here: Hatch a companion, teach it something, and watch what it becomes.
pip install awsprite
Every drive on every node, indexed, classified and diffed -- so you can see what you own before you delete it.
Storage sprawls faster than anyone can look at it. Caches, dead builds, duplicate model weights and orphaned volumes accumulate across drives and nodes, and the only tool is an ad-hoc du that answers one question once and is forgotten. Deleting without an inventory destroys the wrong thing; not deleting fills the disk that holds Postgres.
Start here: Scan one drive and read a ranked inventory of what fills it, with each tree marked re-fetchable or not.
pip install awstorage
Your Google Workspace as agent tools, and no write happens without a yes.
Giving an agent your mail, files and calendar is one OAuth consent away, and after that nothing distinguishes "read my inbox" from "reply to everyone". The agent also needs the same tools in every harness it runs in, not a different integration per surface.
Start here: Sign in with your own Google OAuth client and search your inbox from the CLI.
pip install awsuite
Run one model too big for any single GPU across a pool of small ones.
A frontier MoE checkpoint (Kimi K3, ~1.56TB) fits no consumer card, and "rent a bigger box" stops being an option past a certain size. Splitting a model finely enough to run on heterogeneous, unreliable consumer GPUs -- some too small to hold even one full layer -- is a placement and scheduling problem with no shipped general answer. The money-losing failure mode is retrying a fleet acquisition that was never going to complete, because nothing scored the odds before spending on it.
Start here: Feed it one layer's shape and a pool of heterogeneous GPU specs and get back a sub-layer placement plan, plus the probability that plan actually assembles.
pip install awswarm
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.
# retired — use AitherConnect instead
Turn any tax PDF -- returns, W-2, 1099, statements, even scans -- into structured data you can check.
Your own tax data gets locked inside one vendor's encrypted format, and a filed return or a mailed W-2 is a PDF nobody's code can read -- half of them are scans with no text at all. Getting your own numbers back out means re-typing them or re-buying the app that sealed them.
Start here: Point it at a tax PDF and get every figure out as structured JSON, scanned forms included.
pip install awtax
What every tool call costs you in context, measured from your own transcripts.
Every agent stack claims its search/graph/memory tool is cheaper than grepping and re-reading files. Nobody measures it. The claim lives in a README or a code comment, measured once during development and gated by nothing — so a tool can regress into costing MORE than what it replaced and every signal stays green, because a tool that returns less looks identical to a tool that saves you something.
Start here: Point it at your agent transcripts and see what your ten most-used commands cost.
pip install awtoll
In Claude Code:
/awtollReach 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
In Claude Code:
/awtunnelSee an image — describe it, ask it a question, compare two.
An agent handed a screenshot, a scan or a photo has nothing to do with it. The information is right there and the agent is the one participant in the conversation that cannot look at it.
Start here: Ask a question about an image and get an answer.
pip install awvision
In Claude Code:
/awvisionHear and speak — transcribe audio, synthesize a voice.
An agent that can only read text is deaf and mute. Every route to fixing that today is a vendor SDK that wants the audio uploaded, an API key, and a per-minute bill -- which rules it out for exactly the recordings people most want transcribed.
Start here: Turn speech into text and text into speech, on a service you host.
pip install awvoice
In Claude Code:
awvoice reply/awvoiceSay what a workload may reach, and watch everything else fail closed.
Every other gate asks about the CALLER — who they are, what role they hold, whether they are human. Nothing asks what a workload is allowed to REACH. So a service quietly dials whatever its config says, and when that config is stale the failure is a DNS or connect error naming a host with no relationship to the problem — the symptom points at an innocent service. Measured on our own fleet 2026-08-23: 11 registry entries pointed at hosts that did not exist while the real container was running, and every one of those failures named the wrong subsystem.
Start here: Block one outbound host for one workload and watch the call fail closed with the rule that denied it.
pip install awwall
In Claude Code:
/awwallGobboNet campaigns with a real agent brain — scoped memory, graph recall.
Long roleplay campaigns decay: the model loops, forgets what each character knows, and the only fix is a human curating notes by hand. Per-NPC knowledge scoping is exactly the memory-boundary problem agents already have.
Start here: Run one GobboNet campaign where the harness, not the human, keeps the notes.
pip install gawbbonet
The creative studio — search the boards, render scenes, keep the character.
Character-consistent generation is the hard problem of creative tooling: every image re-describes the subject, and the render that survives is the one that won the seed lottery. Media Forge keeps an identity ROSTER (prompt, face refs, negative, LoRA) and locks renders to it via IPAdapter, so a named character is the same person across reference, expression slides and a crossfade slideshow — measured 2026-08-27: the roster-resolved loop holds identity (dHash 5-15 bits) where the stub-prompt path drifted 23-34 bits between the very same beats.
Start here: Pick a roster character and render a reference + expression loop of them, identity-locked.
https://mediaforge.aitherium.com
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
Open labelled corpora you can train and measure against, with the code that built them.
Every embedding and classifier claim needs a corpus, and the corpus is the part that never ships. Papers cite datasets behind logins, repos carry a loader for data nobody has, and a result measured on the wrong domain looks identical to one measured on the right domain until somebody re-runs it. Measured 2026-09-02: a compression result that held on source files (-0.006 macro-F1, within noise) cost -0.10 on real Reddit comments -- same metric, same code, opposite decision.
Start here: Clone it, run one rehydrate command, and score your model on real labelled text today.
git clone https://github.com/Aitherium/awdata
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/awknowledge/
In Claude Code:
/awknowledgeFirst-party agent packs — the ones we build, versioned and installable on their own.
A pack bundled into the SDK inherits the SDK's licence and the SDK's release cadence. That is backwards in both directions: a proprietary pack blocks the SDK's public publish (measured — the adk sync gate aborts on exactly this and names it), and a good pack cannot ship a fix without an SDK release. Packs and the runtime that loads them are different products with different audiences.
Start here: Install one pack and run it. Each carries its own manifest, licence and version, so taking one costs you nothing else.
git clone https://github.com/Aitherium/awpack
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.
podman build -t awnix:latest -f Containerfile .
Each card's Start here is the smallest useful thing that brick does alone — if it needed a sibling to be worth trying, it would not be its own repo. Anything marked planned or not published yet is listed on purpose: a named absence can be chased, a silent one just gets re-forgotten.
The open-source projects these bricks stand on. Each one is something we actually run — the registry has to name a file in our repo that proves it before it is listed here.
Headless auto-rigging service for generated characters.
Base image of awnix — bootable, immutable, built with bootc.
Headless browser engine for AitherBrowser sessions and smoke tests.
Visual generation engine behind media-forge — images, video, and the 3D stack (Hunyuan3D).
Compose stacks and image builds for the fleet.
Every media transform — frames, mux, HLS transcode.
Reversible context compression — a sidecar plus agent-callable tools.
Image-to-3D mesh generation behind AitherMeshGen (standalone API and ComfyUI nodes). Not affiliated with or endorsed by Tencent.
Vector store behind AitherNexus.
Local inference engine — llama-server lanes and the Bonsai models (our PrismML fork).
The framework AitherVeil — the portal and Living OS desktop — is built with.
Browser automation under AitherBrowser and the AitherVeil e2e suite.
Rootless container runtime; systemd quadlet units for the desktop and appliances.
UI library for AitherVeil and its desktop apps.
Codebase-intelligence service (pinned 0.31.0) — wiki, risk and symbol lookup exposed to agents over MCP.
Fast image-generation backend, profile-gated.
GPU inference lanes, extended by our vLLM mesh plugin.
The private overlay network under AitherNet / AitherMesh.
First-party agent packs from the awpack shelf — built and reviewed by Aitherium, each with its own manifest and version.
BeadSpace for agents: read the platform's real work universe (every agent a constellation, their work as beads) and add, update and link your own beads.
pip install awdk git+https://github.com/Aitherium/awpack && awpack install bead-space
A research agent for a documentary record: resolve people to actors before asserting anything about them, quote verbatim before interpreting, and record a null with the corpus it came from.
pip install awdk git+https://github.com/Aitherium/awpack && awpack install dgg-research
Run GobboNet's chat on an agent loop, with campaign memory scoped by who knows what, and character-card / lorebook import-export.
pip install awdk git+https://github.com/Aitherium/awpack && awpack install gobbonet
Desktop avatar bridge for Persona. Control a VRM avatar's state, animation, voice, and audio via HTTP loopback — host-run only.
pip install awdk git+https://github.com/Aitherium/awpack && awpack install persona
Packs other people publish, kept on a separate shelf. awpack lists them like any other, but installs need --allow-community.
git clone https://github.com/Aitherium/awpack-community AWPACK_SHELF=awpack-community/packs awpack install <id> --allow-community
Every public repository publishes an aither-manifest.json; this reads
them all, so a repo that publishes nothing shows as unknown, never as zero.