Skip to content
@the-robot-lives

the-robot-lives

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.

Popular repositories Loading

  1. live_view_event_passing_demo live_view_event_passing_demo Public

    Elixir

  2. live_view_grid_demo live_view_grid_demo Public

    Elixir

  3. AwesomeNoizu AwesomeNoizu Public

    Forked from noizu/AwesomeNoizu

    Overview of Interesting Repos and Forks I am involved in.

  4. .github .github Public

  5. claude-assist claude-assist Public

    A claude chat history viewer, editor, rebase, and more tool.

    TypeScript

  6. make-repo make-repo Public

    No additional details.

    Shell

Repositories

Showing 10 of 31 repositories

Top languages

Loading…

Most used topics

Loading…