tosh

oh right, good point @ move outside of the loop (or move directly into the Request), ty!

here is a more expanded transliteration:

https://gist.github.com/tosh/61aca9ffa9ea115fa4df332407d7a9a...

Great question!

I had a tool description earlier but 'sh' as tool name seems to be sufficient, the agent behaviour was the same.

There might be performance gains if a description is added though, or worth trying different ways of telling the agent about what is available in the environment.

That said, the newer models are fairly good at driving a harness to explore the environment.

open weights and

similar performance to deepseek v4, inkling at size of nemotron 3 super (!)

performant is more loaded than 'fast'

another reason why it’s great to have open weights: inference providers and your own hardware can ensure that you get the tokens you need even if a lab itself hits roadblocks (and there have been many in quality and availability)

here is a free version of the first 4 chapters

https://training.perforce.com/learn/courses/536/p4-helix-cor...

I know, not the main purpose of it but what's the reduced weight in grams?

Most agent harnesses that have not been designed from scratch for current models are over-engineered.

Chances are whatever was needed to make earlier models perform well now either is no longer helping much or actively hurts performance (worse results, slower, uses more tokens …).

kiwi, an open source implementation of the k programming language

https://kiwilang.com

https://github.com/kiwi-array-lang/kiwi

primitives are accelerated on CPU by SIMD

supports GPUs via Apple MLX

nb:

- stdlib only, 0 external dependencies

- works with openai compatible api (including local models)

- shows context usage in % when turn goes back to user

- cache friendly (keeps stable prefix and provides uuid v4 as session cache key)

- uses 'shell' as open ended tool

'shell' as tool name is sufficient context for gpt 5.6 sol

9 lines of python:

  import json,sys,uuid;from subprocess import getoutput as sh;from urllib.request import Request as R,urlopen
  b={"model":"gpt-5.6","prompt_cache_key":uuid.uuid4().hex,"input":[],"tools":[{"type":"custom","name":"shell"}]}
  while prompt:=input("> "):
      b["input"]+=[{"role":"user","content":prompt}]
      while True:
          o=(r:=json.load(urlopen(R(sys.argv[1],json.dumps(b).encode(),{"Content-Type":"application/json"}))))["output"]
          b["input"]+=o;calls=[i for i in o if i["type"]=="custom_tool_call"];used=r["usage"]["total_tokens"]/10500
          if not calls: print(o[-1]["content"][0]["text"],f'\n[{used:06.3f}%]'); break
          b["input"]+=[{"type":"custom_tool_call_output","call_id":i["call_id"],"output":sh(i["input"])} for i in calls]

yes, ty!

adjacent take: seek out people who don't mind being wrong & who see it as contribution when you can help them understand something better

Is there something like clickbench but specifically for time series dbs/workloads?

rare to see images, let alone with color in a Daring Fireball post

great read, I'm sure I would have bought a suitcase from Om

RIP Om

macbooks (macs in general) are a good package for llms because they come with so much RAM

and for llms more RAM means access to better models

macbooks might not be as fast as a GPU with similar amount of RAM but more affordable and well integrated

last but not least: compared to a PC+GPU the macbook is either silent (air) or at least way less annoying when you care about noise

for ultimate flexibility and low noise: GPU in the cloud for when you need/want it is probably also most cost effective if you don't have workloads that need to run 24/7

discontinuing the cheaper options is a risky move for openai

will trigger re-evaluations of models by other labs + inference providers

fondly remember meeting Om many years ago

I was so anxious I couldn't sleep the night before

then in the morning when I walked up to true ventures I was such a sleep deprived mess I worried I will just waste his time

he was a bit surprised and humored, I think, we grabbed some coffee and had a great conversation

ty for your kindness

RIP Om

ty! very interesting

would love to read also more on what other approaches you considered or played with before settling on the current api/algebra (which is really nice!)

maybe the point, stroke, path tower, enlist and scaling felt kinda self-evident from the beginning?

e.g. postscript has a more imperative (but also very interesting forth-y) approach

ty for the writeup, the wiggly effect is great

apparently it is not what the author meant but:

using projection you can "call a function in two parts"

  add: {x+y}
  add4: add[4] / gives {4+x} by fixing 4 as first argument to {x+y}
  add4[2]      / gives 6

https://en.wikipedia.org/wiki/Partial_application

is learning how to accomplish or understand something boring

just because someone or something else does it better?

I can't recommend highly enough to implement a simple lisp (or a forth).

Illuminating experience and it will also help you see (among many other things) the parentheses in a different light.

it is not easy for a compiler to vectorize

a pragmatic approach: write in a high level interpreted language that rhymes with modern CPUs, vector extensions, memory bandwidth

e.g. apl [0], bqn [1], k [2], kiwi [3]

  - vectors are dense (not boxed)
  - optimized internal representation (e.g. bitpacked bool vectors)
  - primitives act on vectors + use avx, neon if possible

great article by marshall on BQN performance compared to C and how to think about it

https://mlochbaum.github.io/BQN/implementation/versusc.html

related:

  - columnar databases: kdb, duckdb, clickhouse
  - machine learning frameworks: pytorch, keras, jax, mlx

The modern Media Player is said to use around 377MB of RAM when idle, compared to roughly 103MB for the old player—about 3.5x as much memory while doing absolutely nothing.

even 103MB sound like a lot for doing nothing

nb: Robert Recorde also came up with the equals sign as two horizontal parallel lines "=". Yes, that one.

"bicause noe 2, thynges, can be moare equalle"

(and helped make + and - signs more popular)

https://en.wikipedia.org/wiki/Robert_Recorde

see page 5:

https://sigapl.org/Articles/Language%20as%20an%20intellectua...

obligatory mention of Notation as a Tool of Thought

1979 Turing Award lecture by Ken Iverson

https://www.eecg.utoronto.ca/~jzhu/csc326/readings/iverson.p...

Agree, in addition to that DuckDB also works quite well for data that is too big to fit in memory or on the machine DuckDB is on (predicate push down, out of core processing, …).

ty, imho good examples for how you can achieve a distinct look

the problem is not tailwind, the model output just reflects the training material that most likely overindexed on tailwind templates with lots of fonts and text sizes and outlines, I'm sure future training runs will be better

afaiu morsel-driven means the workload gets turned into 'smallish' chunks (morsels)

instead of having to pre-allocate upfront (e.g. 4 nodes get 1/4 each) it is more granular and dynamic

a worker that's "done" can request another morsel

pragmatic approach because nodes might not all be equally fast (cache, cpu frequency, throttling, …) and also some morsel workloads take longer than others depending on the values they contain and what kind of work needs to get done

so this approach tends to balance out nicely

I'm sure someone else can explain it better / correct me (please do!)