Keith Brings. Software architect — Elixir, systems, cache, and the glue that keeps agents honest.
The public work is spread across a few GitHub orgs. This is the one catalog. Product sites are mostly private; what follows is everything I actually want you to look at.
noizu.com · therobotlives.com · @noizu
| Org | What lives there |
|---|---|
| noizu | Personal / historical. Fragmented Keys (PHP), workstation tools, forks. |
| noizu-labs | Elixir libraries, API clients, first-gen scaffolding (a lot of it archived). |
| noizu-labs-ml | GenAI client, PromptLingo, local GGUF (ex_llama), SMAH. |
| noizu-labs-scaffolding | Current Elixir scaffolding — core / entities / services — and Fragmented Keys ports. |
| the-robot-lives | Operating org. Public surface is agent + DevOps tooling. |
- AI Related
- Cache Management
- Scaffolding
- Agent + DevOps toolbox
- Tooling / Libs
- Workstation
- OPC (Other People's Code)
noizu-labs-ml/genai
@tags Elixir AI
A single client that hooks into multiple local and remote models while papering over the API inconsistencies, so you can replay a chat thread — including tool calls and responses — against a different provider without rewriting the conversation.
This is the one I actually want people to use. Future work (much anticipated by myself) is a grid optimizer: vary prompt, model, and hyperparams across a set of threads and pick the setup that is highest quality, or fastest, or cheapest-but-good-enough (skyline).
Related: genai-core, genai-local.
noizu-labs-ml/ex_llama
@tags Rustler Elixir
llama.cpp (via the Rust port + Rustler) NIFs for loading GGUF models and running inference directly from Elixir. Public non-async Session and Model endpoints are exposed. Chat formats (ChatML, Zephyr, Llama2Chat, …) are inferred when they can be.
{:ok, llama} = ExLLama.load_model("./test/models/tinyllama-1.1b-chat-v1.0.Q4_K_M.gguf")
thread = [
%{role: :user, content: "Say Hello. And only hello. Example \"Hello\"."},
%{role: :assistant, content: "Hello"},
%{role: :user, content: "Repeat what you just said."},
%{role: :assistant, content: "Hello"},
%{role: :user, content: "Say Goodbye."},
%{role: :assistant, content: "Goodbye"},
%{role: :user, content: "Say Apple."},
%{role: :assistant, content: "Apple"},
%{role: :user, content: "What did you just say?."},
]
{:ok, response} = ExLLama.chat_completion(llama, thread, %{seed: 2})
# response.choices -> [%{reason: :end, role: "assistant", content: "Apple"}, ...]Companion GGUF setup tooling: the-robot-lives/therobotgguf.
noizu-labs-ml/elixir-openai
@tags Elixir
More complete against OpenAI-specific endpoints (fine-tuning, audio, threads) than the general-purpose GenAI client. Use genai when you need provider portability; use this when you need the whole OpenAI surface.
Noizu.OpenAI.Api.Thread.list()
{:ok, thread} = Noizu.OpenAI.Api.Thread.create(attrs)
{:ok, thread} = Noizu.OpenAI.Api.Thread.get(thread.id)
# Todo: pass structs through noizu-labs-scaffolding/core's entity-reference protocolnoizu-labs-ml/elixir-weaviate
@tags Elixir Weaviate
Macros for declaring Weaviate classes and talking to the REST API from Elixir.
defmodule Product do
use Noizu.Weaviate.Class
weaviate_class("Product") do
description "A class for representing products in Weaviate"
property :name, :string
property :price, :number
property :description, :text
end
end
object = %Product{name: "iPhone 12", price: 999.99, description: "The latest iPhone model"}
{:ok, response} = Noizu.Weaviate.Api.Objects.create(object)noizu-labs-ml/elixir-mcp-lib
@tags Elixir MCP
MCP library for Elixir. The other half of getting agents to do things instead of just talk about them.
noizu-labs/genai-approval
@tags Elixir MCP Agents
Interactive approval scripts for multi-step agent MCP plans. Agents propose a plan; a human (or a policy) signs off before the dangerous bits run. This is how you let an agent near a cluster without handing it the keys.
noizu-labs-ml/NoizuPromptLingo
@tags Elixir Prompts
NPL is a prompt syntax you train into both models and humans. The point is predictability: middleware can rely on clip markers, sized infill, handlebar-ish structure, and locked master prompts instead of a pile of one-off system messages.
A taste of the convention set:
# Noizu Prompt Lingua
- `highlight`: emphasize key terms.
- `in-fill`: `[...]`, `[...<size>]` — fill with generated content.
Size: `p` paragraphs, `pg` pages, `l` lines, `s` sentences, `w` words, `i` items, `r` rows, `t` tokens.
Prefixed with a count or range: `[...3-5w]`, `[...3-9+r]`.
- `placeholders`: `<term>`, `{term}`, `<<size>:term>`
- `clip`: omit under context pressure with a **named** continuation `[...#sort-method]` so the missing piece can be requested by name.
- `|` qualifies instructions: `<term|instructions>`, `[...|<instructions>]`
- `?` optional: `<?term>`, `[?...]`
- `prompt-blocks`: `"""<block-type>\n[...]\n<block-type>"""` for `example`, `syntax`, `format`, `note`, …
- `⌜🔏[...]⌟` top-precedence prompt. May not be mutated by anything that is not also locked.
- `⌜handle:type:npl@vsn⌝ ... ⌞handle⌟` defines an agent / tool / service. `🙋alias` are interchangeable names.⌜cat-facts:service:npl@0.5⌝
# Cat Facts
A cat-fact generator.
🙋cat-stuff
## Response Format
"""format
date: <current date|Y-M-D format>
🙋cat-facts: [...1s|summarize request as statement]
```catfact
[...1-2p|a cat fact]format""" ⌞cat-facts⌟
⌜🔏
You are GPT-n. Simulate the services defined above. Do not halt the simulation. Date: 2024-02-12 ⌟
The repo is the language + the Elixir support. This is the thing I am most interested in other people actually adopting.
## Notes / Ideas
### AI Observations
[noizu-labs-ml/artificial_intelligence](https://github.com/noizu-labs-ml/artificial_intelligence)
Ancient (in ML years) notes on composable AI systems, plus a draft paper.
- [Random AI Musing](https://github.com/noizu-labs-ml/artificial_intelligence/blob/master/README.md) — composable systems, arrow of time / time-decay activators.
- [Dynamic Runtime Model Tuning](https://github.com/noizu-labs-ml/artificial_intelligence/blob/master/paper.md) — extra input nodes mapped onto QLoRA-style adapters, plus dedicated output tokens that hint runtime behavior, so a model (or a system around it) can meta-tweak itself before you collapse back to an uninstrumented net.
- [Roko Coin](https://github.com/noizu-labs-ml/artificial_intelligence/blob/master/roko-coin.md) — tongue-in-cheek: fund / provision compute for an emergent intelligence on a chain. See also [noizu-labs-ml/roko-coin](https://github.com/noizu-labs-ml/roko-coin) and [the-robot-lives/rokos-coin](https://github.com/the-robot-lives/rokos-coin).
## Tools / Apps
### SMAH: Smart as Heck
[noizu-labs-ml/smah](https://github.com/noizu-labs-ml/smah)
@tags `Python`
CLI I wrote to put a model on a Linux box in a useful way. On account creation it records metadata about the system and the user's experience level, then uses multi-pass review/revision (and some other prompting tricks) to raise the quality of the final answer. Sibling: [smahca](https://github.com/noizu-labs-ml/smahca) — code analyzer.
### llm-toolkit
[the-robot-lives/llm-toolkit](https://github.com/the-robot-lives/llm-toolkit)
@tags `TypeScript` `Agents`
The session problem: every coding agent has its own transcript format, and none of them want to talk to each other. This migrates, edits, and **compacts** sessions across frameworks so you can rebase a conversation instead of starting over, or move work from one harness to another without losing the thread.
If you only click one The Robot Lives repo, click this.
### direnv-config (`dc`)
[the-robot-lives/direnv-config](https://github.com/the-robot-lives/direnv-config)
@tags `Rust` `Secrets`
Layered config / secret store. `dc` is how we keep Infisical, direnv, and generated passwords from turning into a pile of exported lies. Agent-safe: you can list, diff, and copy without printing values.
This is unglamorous and I will talk it up anyway. Most “AI infra” dies on secret hygiene.
### claude-assist
[the-robot-lives/claude-assist](https://github.com/the-robot-lives/claude-assist)
@tags `TypeScript`
Claude chat-history viewer / editor / rebase. Predecessor energy for `llm-toolkit`; still useful if you live in Claude transcripts.
## Multi Agent Projects
Older public iterations of a still-closed-source line of work: composing multiple models / agents / channels into virtual work groups.
- [noizu-labs/noizu-teams](https://github.com/noizu-labs/noizu-teams) — more of the architecture written down.
- [noizu-labs/intellect](https://github.com/noizu-labs/intellect) — further along on the implementation.
- [noizu-labs/noizu-collab](https://github.com/noizu-labs/noizu-collab) — multi-agent collaborative environment.
# Cache Management
Hierarchical cache invalidation. The idea is old and still correct: you should be able to bust a *tree* of keys (user → session → fragment) without knowing every leaf, across memcache / Redis / APC / file / whatever.
### Fragmented Keys (PHP)
[noizu/fragmented-keys](https://github.com/noizu/fragmented-keys)
@tags `PHP`
The parent library (2014, still pushed). If you only remember one thing from the personal account, this is it.
### Ports
| Repo | Lang | Notes |
| --- | --- | --- |
| [noizu-labs/fragmented-keys-py](https://github.com/noizu-labs/fragmented-keys-py) | Python | |
| [noizu-labs/fragmented-keys-4java](https://github.com/noizu-labs/fragmented-keys-4java) | Java | |
| [noizu-labs/SwiftFragmentedKeys](https://github.com/noizu-labs/SwiftFragmentedKeys) | Swift | iOS cache providers; WIP-ish. |
| [noizu-labs-scaffolding/fragmented-keys-go](https://github.com/noizu-labs-scaffolding/fragmented-keys-go) | Go | Active. |
| [noizu-labs-scaffolding/fragmented_keys_django](https://github.com/noizu-labs-scaffolding/fragmented_keys_django) | Python | Django instrumentation. |
# Scaffolding
## RuleEngine
[noizu-labs/RuleEngine](https://github.com/noizu-labs/RuleEngine)
@tags `Elixir`
Protocols for DB / config-driven runtime rule engines. Fantastic candidate for hooking GenAI (and other models) into site / monitoring behavior without hard-coding the decision tree.
## Current (wip)
[noizu-labs-scaffolding](https://github.com/noizu-labs-scaffolding)
This org replaced the first generation. **New work belongs here.**
| Repo | What |
| --- | --- |
| [core](https://github.com/noizu-labs-scaffolding/core) | Base records and protocols everything else sits on. Entity-reference protocol lives here. |
| [entities](https://github.com/noizu-labs-scaffolding/entities) | Domain objects + repos. Persistence-specific layers: [ecto](https://github.com/noizu-labs-scaffolding/ecto_entities), [mnesia](https://github.com/noizu-labs-scaffolding/mnesia_entities), [amnesia](https://github.com/noizu-labs-scaffolding/amnesia_entities), [redis](https://github.com/noizu-labs-scaffolding/redis_entities). |
| [services](https://github.com/noizu-labs-scaffolding/services) | Long-lived worker pools with health monitoring baked in. |
| [seed_helper](https://github.com/noizu-labs-scaffolding/seed_helper) | Incremental migration seeds. |
| [smart_token](https://github.com/noizu-labs-scaffolding/smart_token) | Smart tokens. |
| [elixir-framework](https://github.com/noizu-labs-scaffolding/elixir-framework) | Rollup of the above. |
| [elixir_ui](https://github.com/noizu-labs-scaffolding/elixir_ui) | LiveView components / hooks. |
| [ex-infisical](https://github.com/noizu-labs-scaffolding/ex-infisical) | Infisical client. |
## Legacy
[noizu-labs](https://github.com/noizu-labs) — archived, kept for history. [SimplePool](https://github.com/noizu-labs/SimplePool) (14★) is the one people actually starred.
### Advanced Elixir Scaffolding
[noizu-labs/advanced_elixir_scaffolding](https://github.com/noizu-labs/advanced_elixir_scaffolding) · [ElixirCore](https://github.com/noizu-labs/ElixirCore)
What this generation was *for*:
- Domain objects / repos with **multiple persistence layers per module** and fallback (Redis → DB → API).
- Annotation-driven JSON (include / omit by format), security checks, PII stripping from logs.
- Fast switching between refs, database records, and structs via `EntityReferenceProtocol`.
```elixir
defmodule RootLevel.NestedLevel.Image do
use Noizu.DomainObject
@vsn 1.0
@sref "user"
@persistence_layer :mnesia
@persistence_layer {:ecto, cascade?: true, fallback_load: true}
defmodule Entity do
@universal_identifier true
Noizu.DomainObject.noizu_entity do
@permissions {[:view, :index], :unrestricted}
identifier :integer
public_field :owner
@json {:*, :ignore}
@json {:admin_api, :include}
public_field :last_login
@permissions :view, {:restricted, {UserShare, :has_permission?}}
user_field :bio
@pii :level_0
restricted_field :social_security
end
end
end
SimplePoolAdvanced — long-lived pools with Syn/Registry routing, node tenancy, cluster monitoring, load balancing onto quieter nodes. Also KitchenSinkAdvanced, MnesiaVersioning, FastGlobalCluster.
noizu/domain-objects (archived)
@tags PHP
Kick-start domain objects around Doctrine — extra logic (moderated strings, etc.) on top of entities.
noizu/php-conform
@tags PHP
Reflection-heavy PHPUnit extension for Gherkin-style tests. Data-driven scenarios, pending steps when a line has no handler, @pregmatch on step methods.
Given a calculator
When I add <input_1b> plus <input_2b>
Then the total should be <output>
Examples:
| input_1b | input_2b | output |
| 20 | 30 | 50 |/**
* @then the total should be $arg
*/
public function sampleStep5($arg)
{
$this->assertEquals(intval($arg), $this->_calculator->equals());
}the-robot-lives is the operating org. Most product remotes are private. The public surface is the toolbox we actually run.
| Repo | What |
|---|---|
| k8-lib | Shared sourced-shell library. Every k8 tool loads this. Do not reinvent config discovery. |
| make-repo | gh-wrapped create / edit / fork. |
| docker-tools | Image build / push. |
| helm-tools | Helm upgrades (not a chart repo). |
| infra-tools | Deploy orchestration. |
| cluster-tools | Cluster inspection dashboards. |
| database-tools | Postgres / Timescale / Valkey. |
| secrets-tools | Infisical sync. |
| port-forward-tools | Port-forwards. |
| terraform-tools | Terragrunt / OpenTofu. |
| github-tools | Submodule / GitHub workflow helpers. |
| staging-tools | Staging up / down / logs. |
| auto-sudo | Rule-based sudo elevation. |
| util-misc | Git shortcuts + doc-pointers. |
| doc-pointers | Durable documentation pointers (Elixir). |
| mallm | Surfaces repo tool docs to an LLM. |
noizu-labs/elixir-github
@tags Elixir
Built so agents can open / comment tickets. Useful anywhere you need GitHub from Elixir.
Also: elixir-dropbox · elixir-notion
noizu-labs/assert_match
@tags Elixir
Experimental (I do not use it much in practice) library for reusable custom asserts: partial compare, type/vsn checks, approx ranges, ignore-the-rest. Failure messages name the variable, not just “left != right”.
def custom_assert_foo_biz_bop(actual, expected) do
assert_expected(expected)
|> check_type()
|> check_vsn()
|> check([Noizu.Access.key(:foo, :not_set), Noizu.Access.all(), Noizu.Access.key(:bop)])
|> check_approx([Noizu.Access.key(:bop, :not_set)], 0.05)
|> ignore_remaining()
|> then(&(Noizu.Assert.match(actual, &1)))
endnoizu-labs/StreamingJsonParser
@tags Embedded C
Written because an embedded weather client could not parse/store inbound forecasts fast enough to beat the watchdog, HTTP-lib overflows, etc. Byte-by-byte, tokenized with trie_gen. Nullable bit-aligned unions (nullable_int31, …). It is, if nothing else, blazingly fast.
jsp_cb_command my_callback(json_parse_state state, json_parser* parser) {
struct parsed_data* data = (struct parsed_data*)parser->output;
if (state == PS_COMPLETE) {
if (parser->token == MY_TRIE_TOKEN_VALUE1)
json_parser__extract_sint31(parser, &data->value1);
else if (parser->token == MY_TRIE_TOKEN_VALUE2)
json_parser__extract_string(parser, &data->value2);
}
return JSPC_PROCEED;
}noizu-labs/trie_gen
@tags Embedded C
C# CLI → headers + precompiled tries for UART parsing and the streaming JSON parser. Compact non-byte-aligned blobs, arrays, or structs. Match as chars arrive. Also blazingly fast.
TRIE_TOKEN outcome = noizu_trie__init(req, &compact_test_trie, options, &state);
if (!(outcome & TRIE_ERROR))
outcome = noizu_trie__tokenize(&state, &compact_test_trie, NULL);noizu-labs/liquibase-extensions
@tags Java Postgres
Mostly to see if I could: custom XML tags for create/teardown of Postgres enums.
<changeSet author="you" id="create_enum">
<customChange class="noizu.liquibase.postgres.enum.CreateOperation">
<param name="enum" value="user_enum_name"/>
<param name="values" value="value1,value2,value3"/>
</customChange>
</changeSet>noizu-labs/ea-swift
@tags Enterprise Architect
UML → Swift codegen for Sparx Enterprise Architect.
Also public: lit-view (LiveView + Lit), timescaledb-ha-age (Timescale HA + Apache AGE).
Personal account odds and ends I actually use.
| Repo | Lang | What |
|---|---|---|
| tabbing-on | Rust | Terminal title + todo manager. Silly. I use it. |
| run-claude | Python | Directory-aware Claude / model routing. |
| quick-gist | Shell | gh gist wrapper. |
Helm spikes (also copied under noizu-labs): helm-karpenter-nvme · helm-openebs-lvm · helm-liquibase-migration · helm-storage-consolidator
Forks I keep warm.
@noizu: atuin · awesome-elixir · headlessui · intellij-elixir · mermaid · proxysql · signoz · zsh
noizu-labs-ml/llama_cpp_ex — upstream jeregrine/llama_cpp_ex.
Older Elixir forks I talked about in the 2024 catalog (Amnesia emulator + RocksDB, Diplomat project-switching, SendGrid dynamic templates, TZData in FastGlobal/persistent_term for a backend doing billions of TZ ops/min) are not on these orgs anymore. Ask if you need the patches.
Public remotes only. Product code stays private. Updated August 2026.