Skip to content
@noizu-labs

noizu-labs

Some of my Interesting Projects/Items

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

Where it lives

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.

Table of Contents


AI Related

Clients / Wrappers / NIFs

GenAI Multi Model/Provider Client

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.

ExLLama: llama.cpp NIF extensions

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.

OpenAI Client

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 protocol

Weaviate VDB Client

noizu-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)

Elixir MCP

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.

GenAI Approval

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.

Prompting

Noizu Prompt Lingo

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⌟

⌜🔏

MASTER PROMPT

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.

PHP

PHP Domain Objects

noizu/domain-objects (archived) @tags PHP

Kick-start domain objects around Doctrine — extra logic (moderated strings, etc.) on top of entities.

PhpConform: Gherkin / Cucumber PHPUnit extension

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());
}

Agent + DevOps toolbox

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.

Tooling / Libs

Elixir GitHub client

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

Assert Match

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)))
end

Streaming JSON Parser

noizu-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;
}

TrieGen

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);

Liquibase extensions

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>

EA Swift extension

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).

Workstation

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

OPC (Other People's Code)

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.

Pinned Loading

  1. RuleEngine RuleEngine Public

    Noizu Scripting and Rule Engine for Business and Interactive Scripting

    Elixir 3 1

  2. fragmented-keys-4java fragmented-keys-4java Public

    Memcache Key Invaldiation and Maintenance Library for Java.

    Java 3

  3. trie_gen trie_gen Public

    Support for compile time defined array of struct or array of int encoded tries.

    C 1

  4. StreamingJsonParser StreamingJsonParser Public

    Support for streaming parsing of JSON code.

    C 1

  5. AwesomeNoizu AwesomeNoizu Public

    Forked from noizu/AwesomeNoizu

    Overview of Interesting Repos and Forks I am involved in.

Repositories

Showing 10 of 37 repositories

Top languages

Loading…

Most used topics

Loading…