tmzt

I've been experimenting with using J-Space (and final hidden layers) to extract the semantic meaning of words to improve TTS output accuracy using Qwen and Gemma models. My goal is to either map to an alternative token set where heteronyms are preserved or to output parenthesized IPA annotations for ambiguous words (with standard tokens). It's interesting to me that LLMs preserve this data throughout their processing but discard it in the final output.

I've also looked into extracting actions from J-Space to short-circuit a local assistant on low-end hardware. Are there any resources on how to do this training with inexpensive H100 instances (~$8/hr)? I would be opening up the final weights for Qwen/Gemma layers.

Does it work with Codex subscriptions like OMP? I realize others (such as Anthropic) restrict theirs and am not asking about per-call usage.

Payments should be the obvious feature. The commercials for various smart watches show the same thing: somebody buying a coffee with just their watch.

But the reality is different. On my smartwatch (an older Samsung, but same Google OS merged with Tizen) there's a PIN required if you enable payments on the watch. I understand why, the secure element requires it. But it makes every other feature of the watch useless to me. I don't have any secrets I want a watch to protect. I want to be able to time workouts while standing on a treadmill.

They could solve this, only have large amounts require the code while letting me buy a coffee without it, but I'm sure there's some line in an agreement between Google and the banks prohibiting this. The risk has to be transferred to the customer, even if the likelyhood of somebody buying a coffee with my watch is low.

Product design should consider all of these things, but getting out the next smartwatch without thinking it through is more inline with quarterly objectives. There isn't even a Steve around to piss off enough to do something about it.

Using it now. It seems like I finally found something that works. Having the same agents accessible on the laptop in a large TUI and quickly viewable from my phone has been useful.

Tailscale integration works well too. The mobile notification setup was a little clunky and the instructions were confusing, until I found the directory with the shell scripts. It should probably expose a herdr action to generate the keys and include that in the documentation.

One thing though: the subagent lines should be clickable like they are in Termux but your actions box absorbs the click and focuses the GUI input line.

If you're looking for way to get userdebug functionality without building a huge source tree, I created regraph[0]. It's similar to other solutions but does not inject sudo or root, other than the supported adb root path.

It starts with an upstream GrapheneOS build and modify the system image (super) in place, signed with the published userdebug keys.

[0]https://github.com/tmzt/regraph

A nice little asciinema demo would be helpful on the TUI page. I should be able to see what it is, how it presents the contained agents, etc.

I've been evaluating a few of these (and built one into another project I was working on, almost by accident), and am mostly looking for a frontend agnostic, terminal only (not harness) which can submit instructions to agents one line at at time with rate-limiting.

I was also surprised by tmux being built on shared memory when I tried to route it over a vsock to a VM. One of the annoyances with tmux is it's failure to forward environment changes to the individual tabs (such as an option when attaching), or allow for something like a ssh-agent forwarder (shouldn't be built in though).

Are there any with small system prompts that are still useful, especially with local models and subagents?

Of course, both of those examples started out as proprietary software.

[1] https://www.blender.org/about/history/

[2] https://www.libreoffice.org/libreoffice-timeline/

This should be a Show HN but looks incredibly interesting and definitely on-topic for the HN crowd.

The historical project it references isn't widely known either.

To the author: you might consider resubmitting as a Show HN with a human authored write-up.

Anybody know what happened to the Pattern Language Wiki?

I haven't been able to find it on archive.org or anywhere else. It might have been twiki or similar if not mediawiki software.

A prehensile-tailed monkey? Watch them perform simple tasks with three useful appendages. (Really five)

The 40-bit hashed address seemed familiar, then I realized that I (and Claude) had used a similar concept in a VM we built for the OS I've been building. It's a capability and typing system that enables import boundaries to be enforced and third-party packages are unable to perform security sensative operations without being specially signed. It's also a "distribution of one" concept as the user builds their own UI to their specification personalising the OS.

I went ahead and forked this and added a new remote INFER protocol. You can see it at https://github.com/tmzt/ds4 if interested.

This looks useful for somebody with a 16-32GB Mac Mini interested in running larger MoE models.

I've been working on a mesh environment that relies on an explicit prefix hash in the request and enables constructing a new session with a cached pre-filled system prompt specific KV-cache beyond what OpenAI-compatible APIs offer. Can you see a feature like that being supported?

Awesome. I'd love to see this evolve into something, maybe a Matrix server of our own.

For now, I've been hanging out here as tmztmobile: https://matrix.to/#/#pocket-bootloaders:samcday.com

Updated and added links to gsmarena, thanks for that.

Thanks. I will.

I pushed all the intermediate branches as well.

So you've heard of USB?

You can with the newer instances that suport nested VM. There was a recent story about this here https://news.ycombinator.com/item?id=48556561.

Personally, I'm repurposing an older HTC phone with slide-out keyboard (the Speedy) with a new Linux port.

Do you see much of a difference between started Chromium instances with the same configuration in terms of the contents of allocated memory? Are they deterministic?

If not, could you template the memory and apply runtime patches (like timers or other initialized values) before releasing the process to run?

Would forcing the isolates to allocate memory better help at all, such as reducing fragmentation making your 2MB page sizes more effective?

I've been working on a mesh network for private AI models running remotely, controlled by mobile devices (smartphones, tablets, etc.). The mesh is constructed like a piconet, a few devices controlled by a single individual, layered on top of the internet.

How does it support semi-connected devices, intermittent connection failures, etc?

I thought they were itenerant troubadours.

Sounds a bit like Transmeta Crusoe.

Same. I switched my efforts to a larger Gemma 4 MoE model (26B-A4B) and llama.cpp and started getting meaningful results. I also implemented subagents for querying, determining which object/action to execute, and composing a short title. This is all running on an M4 in approximately 16 gb of ram. Also using Google's native tool calling channels.

It's basically restricting what logits are allowed when sampling the model to conform with the JSON (or whatever) shape. It can also cause the model to get "confused" though and doesn't always result in the output you want.

Doing the same for Apple M-series with fused wgsl shaders specifically targeting Qwen3/3.5.

My effort is called shady-thinker and is on github at github.com/tmzt/shady-thinker.

This was inspired in part by Antirez's earlier work with C kernels as well as other efforts to support in-browser LLMs. I've adapted them to Rust and the wgpu library.

Gemma 4 is also the next likely target (with the MTP work) as I'm experimenting with local AI agents.

I'd love to see what you've done to improve prefill and decode even if its not directly applicable.

One difference, I'm using MLX and GPTQ 4bit quants including AutoRound with safetensors as my shader pipeline is pretty much fixed for each model, ggml just adds unnecessary complexity.

I'm working on this too. I'm building a distributed environment where compute and GPU resources can be on one system, display on another, organized into a type of piconet. So far, I'm working with offline/local AI though running into limitations with it. The goal is to allow for a user to customize the environment with personalized cards powered by open schema databases. The same UI works on mobile devices, tablets, desktops, even TVs and IoT devices (ESP).

While it's true that early Linux ARM devices where embedded and generally only supported a single configuration, they didn't actually use devicetree.

Originally, embedded Linux ARM devices used a board file with a platform bus and hard-coded device metadata. The bootloader had to pass a machine id which told the kernel which hardware you were running on and which board file to use.

You can see remenants of this in the kernel still, though it's quickly being removed. I'm actually working on a hybrid kernel with the goal of bringing modern Linux support (on an lts branch) to old MSM7x300 devices, like the Evo 4G Shift I intent to use a tmux console/cyberdeck.

On another note, ACPI/UEFI doesn't always give you a clean abstract surface to work with either. ACPI is notorious for building in OS checks into it's compiled bytecode to the point that Linux often lies to it about what OS is running.