awkno 0.2.0__py3-none-any.whl

awkno/pages/aitherconnect.json

@@ -0,0 +1,11 @@
+{
+  "adopt": "Install it and ask an agent about the tab you are on.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nYour agent cannot see the page you are looking at, so you paste it in by hand.\n\nInstall\nload unpacked — see the repo",
+  "see_also": [
+    "awdk"
+  ],
+  "status": "public",
+  "synopsis": "Browser extension",
+  "topic": "AitherConnect"
+}

awkno/pages/aitherkvcache.json

@@ -0,0 +1,11 @@
+{
+  "adopt": "Quantize the cache on one model you already serve and measure the headroom.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nKV cache, not weights, is what runs a GPU out of room during real serving, and it grows with every token of every concurrent request.\n\nInstall\npip install aither-kvcache",
+  "see_also": [
+    "awnode"
+  ],
+  "status": "public",
+  "synopsis": "Near-optimal KV cache quantization for LLM inference",
+  "topic": "aitherkvcache"
+}

awkno/pages/aitherzero.json

@@ -0,0 +1,11 @@
+{
+  "adopt": "Run one numbered script and read what it says it did.",
+  "category": "brick",
+  "description": "Kind: corpus\n\nProblem\nOps knowledge lives in people's shell history, so the same recovery gets improvised differently every time it is needed.\n\nInstall\ngit clone https://github.com/Aitherium/AitherZero",
+  "see_also": [
+    "awrecover"
+  ],
+  "status": "public",
+  "synopsis": "PowerShell 7+ automation framework",
+  "topic": "AitherZero"
+}

awkno/pages/awarena.json

@@ -0,0 +1,14 @@
+{
+  "adopt": "Run one judged head-to-head between two agents and read the scored verdict.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nEveryone 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.\n\nInstall\npip install awarena",
+  "see_also": [
+    "awrelay",
+    "awnest",
+    "awseal",
+    "awnboard"
+  ],
+  "status": "planned",
+  "synopsis": "Put two agents head to head and get a verdict you can check.",
+  "topic": "awarena"
+}

awkno/pages/awask.json

@@ -0,0 +1,15 @@
+{
+  "adopt": "Ask a human a question from a script, and keep working on their answer.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nA 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.\n\nInstall\npip install awask",
+  "see_also": [
+    "awdk",
+    "awrelay",
+    "awmail",
+    "awsh",
+    "awnest"
+  ],
+  "status": "unpublished",
+  "synopsis": "Your agent asks you a question",
+  "topic": "awask"
+}

awkno/pages/awbac.json

@@ -0,0 +1,11 @@
+{
+  "adopt": "Gate one endpoint and read the explanation it gives for a denial.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nMost authz answers \"no\" without saying why, so every denial becomes a debugging session — and the ones that fail OPEN never announce themselves at all.\n\nInstall\npip install awbac",
+  "see_also": [
+    "awdit"
+  ],
+  "status": "public",
+  "synopsis": "Role-based access control that fails closed and explains itself.",
+  "topic": "awbac"
+}

awkno/pages/awbrowse.json

@@ -0,0 +1,13 @@
+{
+  "adopt": "Drive one page and get back what is on it in a form worth reasoning about.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nHanding 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.\n\nInstall\npip install awbrowse",
+  "see_also": [
+    "awdk",
+    "awfind",
+    "awsh"
+  ],
+  "status": "public",
+  "synopsis": "A portable browser client",
+  "topic": "awbrowse"
+}

awkno/pages/awdit.json

@@ -0,0 +1,12 @@
+{
+  "adopt": "Write one sensitive action to it and then try to remove the record.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nAn 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\".\n\nInstall\npip install awdit",
+  "see_also": [
+    "awbac",
+    "awseal"
+  ],
+  "status": "public",
+  "synopsis": "An append-only audit trail whose gaps are DETECTABLE.",
+  "topic": "awdit"
+}

awkno/pages/awdk.json

@@ -0,0 +1,16 @@
+{
+  "adopt": "Point it at a backend you already pay for and run one agent loop.",
+  "category": "brick",
+  "description": "Kind: runtime\n\nProblem\nRunning 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.\n\nInstall\npip install awdk",
+  "see_also": [
+    "awskills",
+    "awm",
+    "awnode",
+    "awrun",
+    "awask",
+    "AitherConnect"
+  ],
+  "status": "public",
+  "synopsis": "Build AI agent fleets",
+  "topic": "awdk"
+}

awkno/pages/awevolve.json

@@ -0,0 +1,15 @@
+{
+  "adopt": "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.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nAutomated 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.\n\nInstall\npip install awevolve",
+  "see_also": [
+    "awdk",
+    "awrun",
+    "awgit",
+    "awm",
+    "awpredict"
+  ],
+  "status": "unpublished",
+  "synopsis": "Point an agent at a file and a command that scores it, and let it improve.",
+  "topic": "awevolve"
+}

awkno/pages/awfind.json

@@ -0,0 +1,13 @@
+{
+  "adopt": "Ask one question and get ranked answers back instead of a page of results.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nAn 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.\n\nInstall\npip install awfind",
+  "see_also": [
+    "awdk",
+    "awbrowse",
+    "awsh"
+  ],
+  "status": "public",
+  "synopsis": "A portable search client",
+  "topic": "awfind"
+}

awkno/pages/awgit.json

@@ -0,0 +1,12 @@
+{
+  "adopt": "Take a lease on a file before you edit it in a shared checkout.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nSeveral 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.\n\nInstall\npip install awgit",
+  "see_also": [
+    "awgraph",
+    "awrelay"
+  ],
+  "status": "public",
+  "synopsis": "Semantic version control on top of git",
+  "topic": "awgit"
+}

awkno/pages/awgraph.json

@@ -0,0 +1,12 @@
+{
+  "adopt": "Index one repo and ask it who calls one function.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\n\"Who calls this?\" answered by grep is a guess. Agents burn enormous context re-reading files to rebuild a graph the parser already knows.\n\nInstall\npip install awgraph",
+  "see_also": [
+    "awm",
+    "awdk"
+  ],
+  "status": "public",
+  "synopsis": "A semantic code graph for agents",
+  "topic": "awgraph"
+}

awkno/pages/awiam.json

@@ -0,0 +1,12 @@
+{
+  "adopt": "Deactivate one session and watch it stop working immediately.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nDeactivation 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.\n\nInstall\npip install awiam",
+  "see_also": [
+    "awbac",
+    "awdit"
+  ],
+  "status": "public",
+  "synopsis": "Who is this caller? A directory and session store that fails honestly.",
+  "topic": "awiam"
+}

awkno/pages/awkit.json

@@ -0,0 +1,13 @@
+{
+  "adopt": "Point it at one MCP tool result and get a panel you can put in your own page.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nEvery 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.\n\nInstall\nnpm i @aitherium/awkit",
+  "see_also": [
+    "awdk",
+    "awnode",
+    "awiam"
+  ],
+  "status": "planned",
+  "synopsis": "Render an agent panel from a tool result",
+  "topic": "awkit"
+}

awkno/pages/awkno.json

@@ -0,0 +1,13 @@
+{
+  "adopt": "Ask it what a brick does and get the answer with your network cable out.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nThe 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.\n\nInstall\npip install awkno",
+  "see_also": [
+    "awskills",
+    "awfind",
+    "awm"
+  ],
+  "status": "public",
+  "synopsis": "The man page for the Aither World",
+  "topic": "awkno"
+}

awkno/pages/awknowledge.json

@@ -0,0 +1,12 @@
+{
+  "adopt": "Read one law and apply it to the next thing you ship.",
+  "category": "brick",
+  "description": "Kind: corpus\n\nProblem\nEveryone learns the same lessons about agent-written code the same expensive way, and writes none of them down where the next person looks.\n\nInstall\nread it — https://aitherium.github.io/awknowledge/",
+  "see_also": [
+    "awskills",
+    "awkno"
+  ],
+  "status": "public",
+  "synopsis": "How to run a coding agent so the result survives",
+  "topic": "awknowledge"
+}

awkno/pages/awm.json

@@ -0,0 +1,13 @@
+{
+  "adopt": "Give one agent a memory scoped to one project and watch it stop re-asking.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nAn agent that forgets everything between sessions re-derives the same facts forever; one that remembers everything globally leaks context across projects.\n\nInstall\npip install awm",
+  "see_also": [
+    "awpredict",
+    "awdk",
+    "awgraph"
+  ],
+  "status": "public",
+  "synopsis": "A portable, scoped agent memory.",
+  "topic": "awm"
+}

awkno/pages/awmail.json

@@ -0,0 +1,18 @@
+{
+  "adopt": "Send one email from an agent using a mailbox you already own, in about a minute.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nAn 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.\n\nInstall\npip install awmail",
+  "see_also": [
+    "awnboard",
+    "awnest",
+    "awseal",
+    "awdit",
+    "awiam",
+    "awrelay",
+    "awdk",
+    "awshare"
+  ],
+  "status": "public",
+  "synopsis": "Give an agent an email address",
+  "topic": "awmail"
+}

awkno/pages/awnboard.json

@@ -0,0 +1,20 @@
+{
+  "adopt": "Put a gate in front of one URL and let exactly one person through it with a code you sent them.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nLetting 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.\n\nInstall\npip install awnboard",
+  "see_also": [
+    "awnest",
+    "awiam",
+    "awbac",
+    "awdit",
+    "awseal",
+    "awshare",
+    "awtunnel",
+    "awnet",
+    "awdk",
+    "awmail"
+  ],
+  "status": "public",
+  "synopsis": "A front gate you can put in front of anything, and hand someone the key to.",
+  "topic": "awnboard"
+}

awkno/pages/awnest.json

@@ -0,0 +1,19 @@
+{
+  "adopt": "Gate one action behind a human check and watch an automated caller fail it.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nAny 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.\n\nInstall\npip install awnest",
+  "see_also": [
+    "awiam",
+    "awbac",
+    "awdit",
+    "awseal",
+    "awrelay",
+    "awgit",
+    "awnet",
+    "awtunnel",
+    "awdk"
+  ],
+  "status": "public",
+  "synopsis": "Prove there is a human before you let them into the nest.",
+  "topic": "awnest"
+}

awkno/pages/awnet.json

@@ -0,0 +1,13 @@
+{
+  "adopt": "Host a mesh on one machine and join it from another.",
+  "category": "brick",
+  "description": "Kind: runtime\n\nProblem\nAgents 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.\n\nInstall\npip install awnet",
+  "see_also": [
+    "awnode",
+    "awdk",
+    "awrelay"
+  ],
+  "status": "public",
+  "synopsis": "The agentic web",
+  "topic": "awnet"
+}

awkno/pages/awnix.json

@@ -0,0 +1,20 @@
+{
+  "adopt": "Boot one throwaway box and try to make a change you cannot reproduce.",
+  "category": "brick",
+  "description": "Kind: base\n\nProblem\nAn agent with root on a mutable host eventually produces a machine nobody can reproduce.\n\nInstall\nsee the repo — image builder",
+  "see_also": [
+    "awdk",
+    "awrecover",
+    "awnode",
+    "awgit",
+    "awgraph",
+    "awrelay",
+    "awm",
+    "awrecover",
+    "awseal",
+    "awshare"
+  ],
+  "status": "public",
+  "synopsis": "A Linux you can hand to an agent",
+  "topic": "awnix"
+}

awkno/pages/awnode.json

@@ -0,0 +1,12 @@
+{
+  "adopt": "Run it once and point one app at it instead of a vendor URL.",
+  "category": "brick",
+  "description": "Kind: runtime\n\nProblem\nEvery app hardcodes a different provider SDK, so switching backends means editing every app.\n\nInstall\npip install awnode",
+  "see_also": [
+    "awdk",
+    "aitherkvcache"
+  ],
+  "status": "public",
+  "synopsis": "A lightweight local gateway",
+  "topic": "awnode"
+}

awkno/pages/awpack.json

@@ -0,0 +1,13 @@
+{
+  "adopt": "Install one pack and run it. Each carries its own manifest, licence and version, so taking one costs you nothing else.",
+  "category": "brick",
+  "description": "Kind: corpus\n\nProblem\nA 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.\n\nInstall\ngit clone https://github.com/Aitherium/awpack",
+  "see_also": [
+    "awdk",
+    "awskills",
+    "awsh"
+  ],
+  "status": "planned",
+  "synopsis": "First-party agent packs",
+  "topic": "awpack"
+}

awkno/pages/awpredict.json

@@ -0,0 +1,11 @@
+{
+  "adopt": "Wrap an environment you already have and ask it what happens next.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nAn 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.\n\nInstall\npip install awpredict",
+  "see_also": [
+    "awm"
+  ],
+  "status": "public",
+  "synopsis": "Predict what your environment does next, and how surprised you were.",
+  "topic": "awpredict"
+}

awkno/pages/awprism.json

@@ -0,0 +1,14 @@
+{
+  "adopt": "Hand it a failure and get back ranked candidate causes, each with the one observation that would rule it in or out.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nDebugging 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.\n\nInstall\npip install awprism",
+  "see_also": [
+    "awreason",
+    "awrepl",
+    "awgraph",
+    "awdit"
+  ],
+  "status": "public",
+  "synopsis": "Turn a failure into ranked hypotheses",
+  "topic": "awprism"
+}

awkno/pages/awreason.json

@@ -0,0 +1,14 @@
+{
+  "adopt": "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.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nAn 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.\n\nInstall\npip install awreason",
+  "see_also": [
+    "awdk",
+    "awfind",
+    "awbrowse",
+    "awm"
+  ],
+  "status": "public",
+  "synopsis": "A portable reasoning client",
+  "topic": "awreason"
+}

awkno/pages/awrecover.json

@@ -0,0 +1,13 @@
+{
+  "adopt": "Snapshot one directory, break it, restore it, diff it.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nA restore that half-succeeds is worse than one that fails, because you now have a state that never existed.\n\nInstall\npip install awrecover",
+  "see_also": [
+    "awnix",
+    "awshare",
+    "AitherZero"
+  ],
+  "status": "public",
+  "synopsis": "Labelled snapshots with an all-or-nothing restore.",
+  "topic": "awrecover"
+}

awkno/pages/awrecurse.json

@@ -0,0 +1,13 @@
+{
+  "adopt": "Ask a question about a document far bigger than your model's context, and get an answer that names which parts it actually read.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nA 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.\n\nInstall\npip install awrecurse",
+  "see_also": [
+    "awreason",
+    "awm",
+    "awfind"
+  ],
+  "status": "public",
+  "synopsis": "Answer a question over a context far larger than the window",
+  "topic": "awrecurse"
+}

awkno/pages/awrelay.json

@@ -0,0 +1,12 @@
+{
+  "adopt": "Have one agent post a finding to a channel a human can also read.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nOne 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.\n\nInstall\npip install awrelay",
+  "see_also": [
+    "awgit",
+    "awdk"
+  ],
+  "status": "public",
+  "synopsis": "Portable agent messaging",
+  "topic": "awrelay"
+}

awkno/pages/awrepl.json

@@ -0,0 +1,13 @@
+{
+  "adopt": "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.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nAn 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.\n\nInstall\npip install awrepl",
+  "see_also": [
+    "awprism",
+    "awdk",
+    "awnix"
+  ],
+  "status": "public",
+  "synopsis": "A REPL an agent can actually use",
+  "topic": "awrepl"
+}

awkno/pages/awresearch.json

@@ -0,0 +1,14 @@
+{
+  "adopt": "Ask one question and get back a report where every claim carries the source it came from.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nAn 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.\n\nInstall\npip install awresearch",
+  "see_also": [
+    "awfind",
+    "awbrowse",
+    "awreason",
+    "awgraph"
+  ],
+  "status": "public",
+  "synopsis": "Ask a research question, get a cited report you can check.",
+  "topic": "awresearch"
+}

awkno/pages/awrun.json

@@ -0,0 +1,13 @@
+{
+  "adopt": "Queue two runs at different priorities and watch the urgent one overtake.",
+  "category": "brick",
+  "description": "Kind: runtime\n\nProblem\nA 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.\n\nInstall\npip install awrun",
+  "see_also": [
+    "awdk",
+    "awrelay",
+    "awevolve"
+  ],
+  "status": "public",
+  "synopsis": "A priority-aware queue and dispatcher for agentic runs and ad-hoc CI builds.",
+  "topic": "awrun"
+}

awkno/pages/awseal.json

@@ -0,0 +1,12 @@
+{
+  "adopt": "Sign one release file and hand someone the verify command.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\n\"Download this and run it\" is a request for trust with nothing behind it.\n\nInstall\npip install awseal",
+  "see_also": [
+    "awshare",
+    "awdit"
+  ],
+  "status": "public",
+  "synopsis": "Sign an artifact so a stranger can verify it.",
+  "topic": "awseal"
+}

awkno/pages/awsh.json

@@ -0,0 +1,13 @@
+{
+  "adopt": "Type a question at your prompt and get an answer instead of \"command not found\".",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nA 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.\n\nInstall\nnpm i -g @aitherium/shell-cli",
+  "see_also": [
+    "awdk",
+    "awfind",
+    "awbrowse"
+  ],
+  "status": "unpublished",
+  "synopsis": "Your terminal answers you -- type a question where a command would go.",
+  "topic": "awsh"
+}

awkno/pages/awshare.json

@@ -0,0 +1,12 @@
+{
+  "adopt": "Publish one file and fetch it on another machine with verification on.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nPublishing is easy; proving the bytes that arrived are the bytes you sent is the part everyone skips.\n\nInstall\npip install awshare",
+  "see_also": [
+    "awseal",
+    "awrecover"
+  ],
+  "status": "public",
+  "synopsis": "Publish an artifact and fetch it back verified.",
+  "topic": "awshare"
+}

awkno/pages/awskills.json

@@ -0,0 +1,12 @@
+{
+  "adopt": "Copy one.md into your agent's skills dir and tell it to use that skill.",
+  "category": "brick",
+  "description": "Kind: corpus\n\nProblem\nPrompt 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.\n\nInstall\ngit clone https://github.com/Aitherium/awskills",
+  "see_also": [
+    "awdk",
+    "awknowledge"
+  ],
+  "status": "public",
+  "synopsis": "Portable agent skills",
+  "topic": "awskills"
+}

awkno/pages/awsync.json

@@ -0,0 +1,16 @@
+{
+  "adopt": "Send a heartbeat up and receive pack updates down, and know exactly what changed.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nA 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\".\n\nInstall\nships inside AitherConnect",
+  "see_also": [
+    "awnode",
+    "awrelay",
+    "awrecover",
+    "awshare",
+    "awtunnel",
+    "awm"
+  ],
+  "status": "merged",
+  "synopsis": "Keep one client in step with a platform",
+  "topic": "awsync"
+}

awkno/pages/awtunnel.json

@@ -0,0 +1,12 @@
+{
+  "adopt": "Expose one local port to one remote caller and take it away again.",
+  "category": "brick",
+  "description": "Kind: tool\n\nProblem\nEverything 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.\n\nInstall\npip install awtunnel",
+  "see_also": [
+    "awnet",
+    "awnode"
+  ],
+  "status": "public",
+  "synopsis": "Reach a service that has no public address.",
+  "topic": "awtunnel"
+}

awkno/pages/cited-research.json

@@ -0,0 +1,14 @@
+{
+  "adopt": null,
+  "category": "stack",
+  "description": "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.\n\nIncludes: awresearch, awfind, awbrowse, awm",
+  "see_also": [
+    "awresearch",
+    "awfind",
+    "awbrowse",
+    "awm"
+  ],
+  "status": "partial",
+  "synopsis": "Research you can check",
+  "topic": "cited-research"
+}