magnusi

Hey, have you seen Autolith? https://github.com/lambda-symbolics/autholith

I'm the author and I share the same philosophy, hahaha, my users told me about this post

I'm, the author! And happy to discuss!

hehe

Glad to have you!

(disclaimer: I made Autolith)

Well, having the agent write out tools and call those tools is something I consider to be under self-modification also.

But there are other things, when it's useful:

- You want the agent to update without restarting a session and e.g. killing child LISP REPLs and long-running sub-agents

- There is a bug in the harness that bothers you (Autolith records papercuts and can generally solve them via self-modification)

- You want to temporarily or permanently hook into literally any part of the agent lifecycle

- You are of a ricing persuassion and want to change how the agent looks (very surface level, but I have seen people do it)

- Related to the hooking point, you want to integrate Autolith with something else or make it emit something. We cannot predict all the knobs where you might do this, or how selectively you might do it, but self-modification lets you do it

- You want to add support for yourself for non-standard or proprietary/secret providers

That's off the top of my head. The secondary benefit is that this is great at developing the agent itself as a project. It can try/triage the changes it's working on, try its own tests, probe at things, and so on. This is why by far, the changes submitted to Autolith developed by Autolith are by far the highest quality out of all clanker-submitted changes.

On the other hand, the more mainstream a programming language, the higher proportion of the training data is going to be terrible code.

I think there's an optimal ratio somewhere

It's not just the syntax, but also the tools for debugging, the image paradigm itself, and the iterative approach to development!

Autolith can spawn managed Lisp REPLs either from saved images (so it can do checkpoints) and triage changes before committing them to files, and then run test suites in the same REPL, it's been very useful for this.

Thanks for liking it!

Hi, I'm the author of Autolith!

Never heard about Jolt, and I love Chez Scheme, it was my first Lisp!

Would you like to come to our Zulip at https://zulip.lambda-symbolics.com? We can exchange ideas for our harnesses

Hi, I am the author of Autolith. What do you mean by that? I'd love to give you a good answer, haha

(author of autolith here)

This all correct, I'd also add that in my experience, the GPTs are even better at Lisp, namely in the counting parentheses department.

Which is not an issue that much per-se because in Autolith, the harness detects Lisp file edits (CL, Scheme, Clojure) and gives hints when the edits lead to unbalanced files

(The heuristic is pretty simple, we detect if there's a mismatch, and if yes, it provide hints where the extra/missing might be based on indentation)

It's the most flexible language there is, while also fairly performant and having great features for extensibility and debugging

Thank you!

There is a Common Lisp pro you are not seeing and that is that it has by far the best OOB debuggability/introspectability (especially when using SBCL) out of any practical language, while still having great performance

Well, I made Autolith in Common Lisp because I like Lisp and I think it's by far the best and most practical language for self-modifiable live image agents.

I have been trying Scheme and CL with LLMs for the last three years or so, and in recent months, I have finally decided that they are good enough.

My idea is that well, it's good enough that I can now produce more training data just by using Autolith with the most basic claude/gpt subs, haha

Hi!

I was thinking about Smalltalk as well before I made Autolith. I ended up going with Common Lisp because I know Lisp much better (last time I used smalltalk was like, whew, 2014 or so) and because it has better platform support and ecosystem (at least in my experience).

I think Elixir could be great, I knew a guy who was trying to do an agent in Elixir, but sadly didn't get far.

Keep me posted if you get anywhere! And if you'd like to try Autolith, I am happy to help with issues/questions on our Zulip, haha

We have not done that yet, it's one of the major priorities. Autolith implements RLM a bit differently than Prime Agent (although it both comes from the same paper):

In Autolith, the top level agent is traditional, but has RLM tools which it can use for the things RLM is good at, namely exploratory work, processing a lot of files at once, backward context research and so on.

Hello guys, I am the author of Autolith (github.com/luciusmagn), I am pretty new to Hacker News. I will respond to your posts as soon as I can :)

Yeah, I find that it is one of the best ideas C2 brings to the table

Yes, I really like explicit integer sizes too and yes. C2 is trying to be as close to C as possible, with just improving what is "bad" or cumbersome, so some things like the fall-through are still there. You can certainly mix languages, since C2C (the compiler) allows single-file compilation, although a bit cumbersome, with the -f parameter and currently, it works like this:

1. Find (recursive searching upwards in directory tree) & Read a recipe file (a file for the build system)

2. Either start building all targets or just some, depending on the command-line arguments

3. Build the targets. Output is C (basically complete) or LLVM IR bytecode (like 25% complete).

4. Write a makefile for said C files

5. Compile with default C compiler

so mixing languages works with a little hacking.

I am the author of the Windows/Cygwin support/port, so in case anything doesn't work (especially since the compilation of LLVM is often a horror in Cygwin), let me know and I will see what I can do.

Oh I am sorry, I made a stupid typo.