tmzt

Still a work-in-progress[1], but I have a mobile app for herdr also built with a native GPU interface (but not using gpui), optional LLM usage (outside of the agents themselves), designed for a hands off voice-enabled approach to development. The STT/TTS are both on-device. Yes, I used agents to build it, and you can see the development record in tree under docs/design.

[1] https://github.com/flankrapp/flankr

You can. I use it exactly that way with the individual terminal sessions accessible.

I'm mostly using it now because it integrates with ssh while still supporting image paste. I also use it via it's json API for a harness I'm working on which is agent agnostic.

I do expect I'll move off it if it becomes hostile and another tool takes it's place.

I'm doing something similar. Building a text/tactical RPG with typed/structured markdown as the authoring language. So far I've built libraries for character and item rendering, as well as scene graph parsing with procedural generation (also in markdown). Now I'm actually introducing Bevy to enable animation and interactivity. First time using Bevy, and I'm also using teams of agents to do the development, driven by a custom system of plans and review/feedback.

All my graphics are procedural, with no assets apart from open fonts.

The first game is meant to be a sort of Isekei parody, so the animation and character design is anime inspired, with tactical RPG gameplay, and some time-travel/reset mechanics. The story gets into the irony of being a game so magic not being real on Earth, and some historical Earth scientists play a part in the deeper lore modules. The magic construction is an actual MLP puzzle with polar coordinates.

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.