schmuhblaster

You might like this: https://github.com/deepclause/deepclause-sdk.

It’s a DSL I’ve been working on to encode mixed deterministic/probabilisitic agent behavior.

Been building various LLM+PDF pipelines at work. As soon as you need to e.g. parse tables etc. it becomes a lot of hard work!

As a European I have long given up on any meaningful change w.r.t AI. Imho the average European is much more risk averse than the average American or Chinese. That and a plethora of other factors that have been discussed over and over again, make it unlikely that we'll see things change within the next ten years or so. Only massive and immediate threats (e.g. he crisis in Ukraine) will make people and governments reconsider their fundamental beliefs (and even then the pace of change will be slow).

Awesome work! If I understand it correctly, it loads relevant subgraphs from the DB and then runs queries in Prolog on it? Or is it more similar to datalog?

It's my own (slightly idiosyncractic ;-) harness: https://github.com/deepclause/deepclause-sdk

I've worked extensively with the slightly less able cousin, the 35B A3B model and tuned my own harness around making it work well with local or non-sota models. The results are quite promising [0], if one sticks to a plan-execute approach. After a bit of fiddling with llama.cpp I was able to get it to work through a small change on a real codebase from work on a 32GB M5 (typical python FastAPI backend, so nothing out of the ordinary). While that's somewhat encouraging, the whole local experience was still far from pleasant with all the noise and heat.

[0] https://deepclause.substack.com/p/how-to-make-small-models-p...

Mathematics has always been an experimental science to some extent. While Newton, Euler and Gauss would spend a lot time calculating numerical approximations by hand, modern mathematicians have been doing the same using computers and software. And once an a clear picture emerge about what’s going, you can start to formalize that and attempt to prove and communicate your results in the standard definition, proposition, lemma, theorem scheme. (Btw there is even a journal called Experimental Mathematics devoted to this approach).

I don’t see that LLMs will fundamentally change this, but rather accelerate the speed of mathematical research.

Some computer generated proofs might of course be hard to understand, but at least their existence gives another data point work with.

Doing Mathematics is more than proving something, that’s just the end of a long road spent pondering at one’s desk about how things could work out.

This trend dates back at least to the machine learning bible, Elements of Statistical Learning (2001).

Could you elaborate on this?

Indeed, and with some tinkering around the harness it can even punch way above its weight.

This somehow resonates with me and I feel this is one of the negative side effects of a CS/Maths dominated culture and mindset that strongly emphasizes intellectual achievement, but hasn’t yet matured enough to appreciate the more messy and irrational parts of our existence.

I’ve been working on my own harness / “orchestration layer”, not with the goal of reaching frontier level performance, but rather boosting performance of smaller (locally hostable) models. Unfortunately, I don’t have VC money to burn on running hundreds of evals, but some preliminary results do indicate that it could work[0].

https://deepclause.substack.com/p/how-to-make-small-models-p...

Hmm, that also happened to me. Scan face, account lost forever?

What worries me personally is the dopamine hit I seem to get from watching my ideas get built in front of me. There is a big temptation to just add feature after feature without really checking what the code actually looks like. So yes, more discipline is needed.

I’ve been playing around with qwen3.6-35b-a3b and managed to boost it significantly by leveraging my own custom harness [0].

It is quite astonishing to see how far local models have progressed, and I think that if you enjoy tinkering a bit, you can save a good bit of money (if you happen to have the hardware lying around anyways). Overall it’s still hard to beat the the cost/convenience combination of a cloud based model provider though.

[0] https://deepclause.substack.com/p/how-to-make-small-models-p...

Thank you very much!

I’ve been building a Prolog and WASM based LLM/Agent framework [0] , where reusable skills and core harness functionality is encoded in a logic programming language. Recently added a small TUI with a Borland Turbo Vision style design. My goal is to build a completely hackable harness that works well with smaller models and to further promote the combination of logic programming and LLMs.

[0] https://github.com/deepclause/deepclause-sdk

Thank you! This looks very interesting!

I've been working on DML, a Prolog-based DSL [0] used to define and orchestrate agents and LLM workflows. It's been quite fun, although - given the amazing capabilities of SOTA models - I am not so sure anymore how meaningful it will be to continue with this work. Anyways, the language and also supports DCGs, so it should allow for plenty of interesting ways to combine grammars, LLMs, agents etc.

[0] https://github.com/deepclause/deepclause-sdk

As someone who has developed a somewhat weird obsession with Prolog, I can highly recommend Markus Triska's other articles on Prolog. His article on meta-interpreters [0] was particularly inspiring for me.

[0] https://www.complang.tuwien.ac.at/ulrich/prolog_misc/acomip....

Shameless self-plug: https://github.com/deepclause/deepclause-sdk/

The idea is to take markdown instructions and "compile" them into a Prolog-based DSL that orchestrates both deterministic and LLM-based components. The (meta-)interpreter of the DSL automatically tracks the entire execution process, so that the final ouput becomes observable and more explainable. Still at an early stage, but I am having lots of fun with it and would love to explore possible use cases.

I am experimenting [0] with compiling markdown to a DSL first. Then running a static analysis on the DSL code. Still at an early stage though.

[0] https://deepclause.substack.com/p/static-taint-analysis-for-...

https://www.github.com/deepclause/deepclause-sdk

"Compile" Markdown specs for SDD or Subagents into executable logic, e.g. CodeAct+DSPy+Prolog. Not sure how and if I will continue, but it's been lots of fun.

I'd be curious if a middle layer like this [0] could be helpful? I've been working on it for some time (several iterations now, going back and forth between different ideas) and am hoping to collect some feedback.

[0] https://github.com/deepclause/deepclause-sdk

Network can be closed down. It also uses a userland network stack, so future iterations might include being able to define rules for ingress and egress.

I've been recently experimenting with using a Prolog-based DSL [0] as the missing layer: Start with a markdown document, "compile" it into the DSL, so that you obtain an "executable spec". Execution still involves LLMs, so it's not entirely deterministic, but it's probably more reliable than hoping your markdown instructions get interpreted in the right way.

[0] https://github.com/deepclause/deepclause-sdk

Or try this: https://github.com/deepclause/agentvm, it's based on container2wasm, so the VM is fully defined by a Dockerfile.

My attempt at a portable solution: Linux VM inside WASM for sandboxed execution: http://agentvm.deepclause.ai

Minimal dependencies, but not as fast as containers or bubblewrap.

Hi all, been building this in public for some time. This is my latest iteration, hoping to get some interesting comments and feedback here, before I go down yet another rabbit hole and unnecessarily burn through even more premium tokens.

Thank you! When I started working on agentvm my original goal was similar to yours, build a kind of Mingw or Cygwin for WASM. However, I quickly learned that this wouldn't really be feasible with reasonable amounts of time/token spend, mostly due to issues like having to find a way to make fork work, etc. I am no expert for WASM or Linux system programming, but it's been a lot of fun working on this stuff. I hope that the WASI standard and runtimes become more mature, as I feel that WASM sandboxes make a lot of sense in environments where containers are not an option.

linux-wasm is an awesome project, but relies on compiling the kernel itself into WASM. This seems to work in principle, but is still a bit unstable. But I do hope that eventually one can get rid of the emulator in the middle as is done in c2w.