Erik MD

Really enjoyable episode of the The Pragmatic Engineer by @GergelyOrosz with Grady Booch on the history of software engineering - great history lesson but my favourite part was the reference to Plato' Sophist! A mind blowing moment for me personally - never thought about that before! Now spent my whole morning just thinking about that and getting back into Plato 😄 The reference is to the part where "The Stranger from Elea", discusses Not Being and Being. The most famous quote from this part goes like this (in Jowett's translation): My notion would be, that anything which possesses any sort of power to affect another, or to be affected by another, if only for a single moment, however trifling the cause and however slight the effect, has real existence; and I hold that the definition of being is simply power. gutenberg.org/files/1735/173… The point The Stranger is making is that a thing exists only if it has the power to act, ie if an object cannot act then it does not exist. Mapping that back to Grady's point: we can't just talk about objects, we have to talk about their actions. Or in my world of computational theory and dynamical systems, we are arguing that we should view data not just as inanimate objects but always through the lens of the computations that generate and act on it. Simply measuring the world without understanding the process that created the measured property is pointless. So the bigger question Plato's is getting at: is the world best viewed as a collection of things with attributes or as a set of processes interacting with each other. Which, I guess, is really one of central question of the theory of computing, dynamical systems and computational theory in general.

Another nice thing I did this weekend was to build an “agent skill” for Hugin, which then allows me to use Claude Code as my main agent for building Hugin agents. github.com/gimlelabs/giml… Still needs a lot more work but so now CC is my agent builder, kicking off sub-agents, building new Hugin agents, publishing them to a Github repo, then using them to do stuff etc. Given how mature/good CC is, this is much more powerful than the BabyHugin app I posted about yesterday. So I think this is my new goto way of working on a lot of things. I am very much considering now moving all of the Gimle stack (pde solvers, simulators, proof solvers and physics models) to Claude Code - basically having that as my interface for all Gimle science, instead of building a new IDE for it. Just clis and good interfaces and then CC on top. I now think that is the future for scientific flows, not Matlab style interfaces with some AI added.

@gustofied Thanks! Finally got time over Xmas to do a new implementation of the old state machine approach 🤗 Lots more todo, but super excited about getting it going again

@arnovicher very cool

First tweet - cool little animation! Playing around with ways to animate state machines and interaction stacks in docs for a repo - so I vibed up a little JS package. Lots to be improved but already pretty cool no? Will tidy up a bit and put on github.com/gimlelabs soon

@gustofied Nice! Super interesting! Just skimmed but will give a good read later - thanks man 🙌 love a good paper 😄

@arnovicher LLM-as-transition oracle..arxiv.org/pdf/2510.23487

To illustrate the pattern I mentioned earlier, of agents building agents, I built a new demo app, BabyHugin(github.com/gimlelabs/giml…) - inspired by @babyAGI_ @yoheinakajima . BabyHugin tries to solve tasks by creating new agents if there isn’t already an agent/capability to solve the task. Here is a quick video of that in action, on the left is the console and on the right is the Hugin monitor, where you can see what is actually happening behind the scene. I asked BabyHugin to create an agent that can retrieve the weather for a given city. Once done I then asked it to run that agent. In the monitor you can see how it kicks off an `agent_builder` using a generic `launch_agent` tool that it has. The `agent_builder` agent then builds a new agent that can solve the given task of ‘given a city find the weather forecast’. It then runs that agent to see if it works, refines it, if needed, and then returns to me to ask what’s next.

One thing I have been playing around with in the last couple of evenings is an agent builder - a Hugin agent specialised in building Hugin agents! Gave me a few of those wow moments, where you see something so cool you just have to get out of your chair and go for a walk 😄 My favourite thing is to ask it to either build agents to analyse different types of financial data, or the weather or to build specialised coding agents and then just watch it in action. I really, really like the idea of having agents build their own sub-agents for new skills, which then leads to tools becoming agents, in a sense. In Hugin you have builtin `launch_agent` and `list_agents` tools, which then become the main interface for an agent - like tool exploration but now it is agent exploration! And if an agent is missing a “tool” it can just create it using the “agent builder” agent! SO now you have agents, searching for other specialised agents to perform certain tasks and then, if they don’t exist, they build new agents for that task - which are then discovered and used by other agents later... and so on... Also, since a Hugin agent is just a folder with a few sub-folders of yaml/python files you can easily share these via Github or similar, by just pointing it to a repo of agent configs. And all of this done by just one simpleton dude with a few evenings to spare - the future is truly here! 😄 (I'll post a video later, when time permits, of this pattern in action)

Hugin v0.1(Hugin..) is now out!! Simple framework for powerful agents! Originally I built it for reasoning about physical systems(coming soon!) but I liked it so much that I reworked it to be a general purpose agent framework - since I think it beats most other frameworks in terms of ease, versatility and multi-agent capabilities(especially!). It is based on some previous stuff I did on state machines models for agents eriksfunhouse.com/writings/state… Hopefully it will be interesting/useful to some! Will post a few cool examples next to show off what it can do! One nice little demo app in the repo is the "The Hugins" - an example of asynchronous exploring, acting and communicating in a isometric 3D world. hugin.gimlelabs.com github.com/gimlelabs/giml…

And a static state machine illustration - which can also be animated to show progression

Here is an example of illustrating possible state transitions