yes and can do many of those in parallel

unfortunately all hand-written :( my chief-of-staff does unironically handwrite em dashes though

For what it’s worth, I didn’t get that impression, and even noticed a couple typos ;)

I really appreciated the hand-written release. Thank you.

the edit is right - jev would be cheaper, faster, and more self-consistent (in general)

we actually use astra (and fable) in this way for our evals: evals.typesafe.ai

someone on the team cooked hard on that and it shows example traces comparing our model to opus/sol

1. yes a general model 2. no training at all 3. but it is focused on "System 1" tasks (more human judgment, less math reasoning)

strings (and all sequential data structures) are not allowed at all - this is how we make sure all outputs can be computed in parallel (thus no output token cost)

They don't like adding stealth startups :(

inputs are structured program state. there is an example at around second 30 of the doom demo

(though ideally everyone gets off the waitlist and can try it out for themselves )

we hope so! the bigger hope is to not just eat LLM market share, but to allow for people to use AI much more in the inner loop of software

I'm sure you've thought of self-driving. How does the model work in that space?

Great question! Yes, this works much like the doom player. Sensor data (LIDAR, velocity, etc.) becomes the state. You use the score primitive to operate the controls ("What level of braking should be applied" 0: None, 1: just slightly slowing down, 2: there's a suspicious cat on the side of the road you don't trust, ...

Full disclosure, I am not they :=)

This smells like a tool a more broadly capable LLM would take advantage of extremely well.

But the real problem in self driving isn't the decision making but object description. That is, computer vision if with cameras.

Decision making isn't that of a bottleneck I suppose.

99.9% of the time you are right, but in the long tails (construction works, major road damage, temporary road markings that contradict permanent signs) I could see this kind of architecture being useful.

the hard part for coding is actually state engineering (e.g. getting your dependencies in context) - we haven't even tried it yet (because my philosophy is we should automate the easy tasks before the hard and we've been working on getting the model smart on the former)

we do think there's a lot of potential though and do want coding themed releases soon

I could see Jev being great at finding key symbols in codebase before a code generation/code review task. I sent you guys an email (to hello@) about using Jev in Code Review for www.ellipsis.dev.

thanks a ton!

constrained decoding (OpenAI-style structured outputs) make models dumber unfortunately - the short+dense version is that simply masking logits is insufficient because if ever a model was assigning probability to an invalid token, the model is by definition confused. you'd be better off erroring IMO