Seems like the core idea is the same, but I took it farther down the Unix philosophy line of thinking and tried to make the individual components small and composable.

Feel free to check it out and compare!

I tried to abide by the Unix philosophy, breaking the REPL into the composition of a few small, single-purpose program. Because the data flow is just text streams fed through pipes, at any step you can inject tools to inspect or modify the data—like using `grep` to filter out strings before they hit the model, or `pv` to benchmark model throughput. Everything is ultimately tied together into an `agent` Bash script that codifies the interaction into a REPL. To my surprise, this setup seemed to be sufficient to get a working “agent” that largely resembles ones built by more complex frameworks.

One motivation I have for sharing this here is to embed some semi-rhetorical questions: is that really all there is to a “modern agent”? Are the frameworks and libraries being tossed around overly complex and we really just need to keep it simpler?

A few more details of potential interest:

- Zero heavy dependencies: No `pip`, `npm`, package managers, virtual environments, etc. It just requires `bash`, `jq`, and `curl` to talk to the local model server. These should be available in most modern CLI environments.

- Transparent, file-based state: The agent's memory is just an append-only `.jsonl` file (like `.bash_history`). If you want to rewind the agent's memory, you just run head on the log to drop the last few lines.

- Standard exit codes for control flow: Tool execution is handled by checking standard Unix exit codes within a basic bash while loop.

I suspect there are scaling limits to doing this all in shell, and I'm still figuring out the most elegant way to handle some of the edge cases, particularly around tool calling - but those appear to mostly be limitations of the underlying models. Nevertheless it's been a really fun experiment in stripping out bloat, and as I mentioned above, somewhat surprising at least from a neophyte perspective.

Would love to hear thoughts and comments, particularly around the limitations to this orchestration and what features are otherwise missing due to bypassing the popular frameworks and libraries.

Comments URL: https://news.ycombinator.com/item?id=48733677

Points: 1

# Comments: 0

It turns out you can get pretty far with pipes, text streams, append only logs, and standard command-line components - concepts pretty well aligned with classic Unix philosophy. The agent is a wrapper composed of a handful of smaller programs, which should allow for flexibly injecting various tool to inspect, filter, redirect, and audit different stages of the agent loop.

This project as it stands is a proof-of-concept, but packs enough punch with tool calling support - which in theory should make it indefinitely extensible. With that said, it does appear that the sophistication of tool calling is largely limited by the underlying model, and so far I’ve only experimented with lightweight local models (e.g. llama3.2:1b) that have modest success for tools.

Nevertheless, I wanted to share this here and am curious to see if others find it interesting enough to build upon or extend!

Comments URL: https://news.ycombinator.com/item?id=48645683

Points: 2

# Comments: 0

Automatic differentiation library in Clojure (https://github.com/cloudkj/lambda-autodiff) - inspired by Karpathy's `micrograd` from a few years ago; dusted it off recently, fixed a few issues, and was able to use it to implement a version of `microgpt` - https://cloudkj.github.io/lambda-autodiff/doc/examples/gpt/

PG&E "Share My Data" self-access library (https://github.com/cloudkj/pgesmd_self_access) - been tinkering with various home automation and monitoring ideas, and was able to get an end-to-end prototype for ingesting and visualizing PG&E meter data using a combination of the (forked) aforementioned library, an old circa 2015 Raspberry Pi, and a handful of dollars spent on AWS services (certificate manager, load balancer) to get the full mTLS PG&E integration working. Probably deserves a blog post to document all the gory details.

Geo data mashups (https://github.com/cloudkj/snowpack) - small frontend utilities to overlay custom data on top of each other; was able to satisfy two recent personal use cases: (1) visualize snow depth across California ski destinations and (2) heat map of national park traffic by entrance. Previously posted at https://news.ycombinator.com/item?id=46649103

REST interface for Gymnasium reinforcement learning (fka OpenAI Gym) (https://github.com/cloudkj/gymnasium-http-api) - simple wrapper around the forked version of OpenAI Gym to allow for language-agnostic development of RL algorithms.

gymnasium-http-api is an attempt at bringing back the same type of language-agnostic support. It mostly wraps the forked and supported Gymnasium library, with some endpoints specifically for making it easier to render and visualize the training and learning process.

Check out the README for some examples. Hope others find it useful!

Comments URL: https://news.ycombinator.com/item?id=47657165

Points: 1

# Comments: 1

In the motivating example, the main challenge was in converting the raw snow depth data into the proper format, for which I've included some sample adapter code. Sharing this here in case anyone finds it useful for upcoming weekend trips, has recommendations for different tools to solve the same problem, or suggestions for improvement!

Comments URL: https://news.ycombinator.com/item?id=46649103

Points: 1

# Comments: 0

I'm also interested in starting up something similar for a particular niche, and would like to hear first hand accounts of the return on investment for aggregators such as these.

https://github.com/cloudkj/ngram-syllables

Can you provide some links to temperature sensors you've tried that work well with an RTL-SDR receiver? I'm also interested in setting something up with a Raspberry Pi.

Mostly a small collection of posts about programming and personal finance. Also been running for around fifteen years.

Most popular post is about currency arbitrage, which seems to have had a small resurgence in interest as of late from various crypto folks: https://www.kelvinjiang.com/2010/10/currency-arbitrage-in-99...

Side note: not sure if it's just a funny coincidence, but it seems like a good number of folks here have been running their sites for around fifteen years. Perhaps the timing just happens to match the typical career arc of software professionals, or maybe it was due to the popularity of blogging fifteen years ago.

Comments URL: https://news.ycombinator.com/item?id=22760782

Points: 3

# Comments: 0

I personally prefer the Palomar Knot as it is probably the strongest knot that is also easy to tie. The Improved Clinch Knot and its brethren are also handy to know since there are so many variants that have high breaking strength; I typically teach the Improved Clinch Knot to folks new to fishing.

Comments URL: https://news.ycombinator.com/item?id=21931400

Points: 3

# Comments: 0

  def parse(text):
      stack = []
      index = 0
      result = None
      while index < len(text):
          char = text[index]
          val = None
          if char == '[':
              stack.append([])
          elif char == ']':
              val = stack.pop()
          index += 1
          if val is not None:
              if stack:
                  stack[-1].append(val)
              else:
                  result = val
      return result

It seems like the main criticism here is against recursive implementations. Or am I missing something?

Comments URL: https://news.ycombinator.com/item?id=20344991

Points: 2

# Comments: 0

I also started off in the same manner of implementation - bash scripts wrapping AWS CLI calls - then stumbled upon the more straightforward, template based approach.

I was mostly going for a DIY solution since I wanted to "own" the bits being deployed while remaining as close to the infrastructure as possible. Providing a hosted service somewhat moves away from the DIY spirit; I suppose additional tools/UIs could be offered to simplify setup and deployment and still run everything directly on AWS, but at that point one might be inclined to just move to one of the other hosted solutions for the simplicity.