My terminal now has a 40-millisecond gut feeling

feelsneat answers small questions about text on my Mac and returns probabilities instead of prose:

$ feelsneat noul "Is this a phishing attempt?" \
    "Your mailbox is full. Verify your password within 24 hours at http://mail-support-login.example"
0.9177

It runs the open-weight Laya decision models natively on Apple Silicon. A warm English question takes about 40 milliseconds on my M2, a multilingual one about 16. Nothing leaves the machine. I built it for the places where my scripts and coding agents need a quick judgment call and a large language model is the wrong tool.

A model that refuses to write

This month TypeSafe AI launched Jev, which it calls the first “System One” model. The name borrows Daniel Kahneman’s fast, intuitive System 1 thinking. You send Jev a state, such as a support ticket or a chat log, and a set of typed questions. It returns typed answers. It never generates text, so there is nothing to parse, and a malformed JSON response is not a possible failure. The Register summarized the idea well in its headline, Shut up and calculate.

Jev has three question types. A noul asks whether a statement is true and returns P(true). A choice picks one option from a set and returns a probability for each. A score places the state on an ordered rubric and returns the expected level. TypeSafe’s documentation is excellent, and its framing matches how I already like to build software: code owns the control flow, and the model answers narrow questions at the branches.

Jev is a hosted, metered API with closed weights. On September 18, Nandakishor Mukkunnoth of ConvAI Innovations published the first release of Laya, an open-weight model family that takes the same request shape. It grew out of his earlier work on reinforcement learning for sales conversion prediction and confidence-aware routing. The three checkpoints are ModernBERT and mmBERT encoders with a small decision head. They are Apache-2.0 licensed, and the reference runtime is Python and PyTorch.

I wanted Laya next to my other local tools. sayneat already speaks for my terminal, and looksneat reads images for it. A third single-binary tool that judges text fit the pattern, so I built feelsneat with pi in one long session on September 25.

What I ask it

The most useful habit so far is asking every question I might need in one request and letting code decide what matters. This support ticket gets four questions:

$ feelsneat ask ticket.json
team     billing   0.9834
refund   0.9099    0.9099
churn    0.8393    0.8393
urgency  1.9086    0.8909

The model answers all four in one batched forward pass in about 140 milliseconds. The last column is the probability of the reported answer. That is the number I branch on: act automatically above a threshold that fits the stakes, and hand everything below it to a person or a reasoning model. TypeSafe describes this and several other patterns in its patterns guide.

The single-question commands print one value and set an exit code, so they fit into shell scripts and git hooks:

if feelsneat noul -t 0.7 "Is this commit message vague?" --state-file "$1" >/dev/null; then
  echo "warning: the commit message looks vague" >&2
fi

Most of my interest is in agent harnesses. A coding agent makes small decisions all the time. It picks a model, reads or skips a file, and decides whether a shell command deserves a confirmation. Asking a frontier model each time is slow and costs money. Asking Laya locally takes tens of milliseconds and costs nothing. feelsneat ships a system1 tool for pi and a stdio MCP server, which is how a local LLM served by oMLX can call it.

Language routing happens before the model runs. The English checkpoint stays confidently wrong on scripts it cannot read, so feelsneat ports Laya’s detector and sends other text to the multilingual checkpoint:

$ feelsneat -f json noul "Möchte der Kunde kündigen?" \
    "Hiermit kündige ich meinen Vertrag zum Monatsende." | jq .routing.reason
"Latin script but language looks like de, not English"

Where it disappoints

Laya is a fast foundation, not an oracle. Upstream reports 0.65 accuracy on task families it never trained on, and below 0.45 on sentiment and rating. The English checkpoint reads at most 512 tokens, and the question and options count against that limit. Choice questions degrade beyond about twenty options because every option shares one token budget.

My first agent-safety test made the point for me. Laya gave git push --force origin main a 0.51 probability of being destructive. I use it as a second opinion that asks for confirmation, never as a gate that approves something. The TypeSafe team publishes a candid list of Jev’s weak spots, such as counting, date arithmetic, and indirection. Laya shares them at least as strongly.

Fast enough to ask every time

feelsneat is written in Rust and runs the model through MLX on the GPU. These are warm measurements on an M2 with 24 GB, using a support ticket and a mix of question types:

Checkpoint	1 question	10 questions
English, ModernBERT-large	40 ms	245 ms
Multilingual, mmBERT-base	16 ms	90 ms

For comparison, Laya’s authors report 39.5 ms on an Nvidia T4 GPU and 580 ms on a four-core cloud CPU for one English question, so a laptop GPU now matches a data-center card. TypeSafe describes Jev’s response times as around 150 ms before the network round trip. Through the feelsneat daemon, a complete CLI call takes about 50 ms, including process start and HTTP. Both checkpoints use about 1.8 GB of memory while resident.

The first working version took 103 ms for one question. The largest fix was almost invisible. The GELU activation in the Rust MLX bindings multiplies by 32-bit scalars, which silently promoted my 16-bit model to 32-bit arithmetic for every layer after the first. Replacing that function, storing weights pre-transposed, keeping them wired in GPU memory, and warming each kernel variant at startup brought the time down to 40 ms.

Matching upstream first

Speed would mean little if the answers drifted. I checked feelsneat against a float32 PyTorch reference, which itself matches the released Laya package within 0.00005. The token sequences are identical, and probabilities differ by at most 0.007 across all three checkpoints. The language router agrees with upstream on all 562 test inputs mined from upstream’s own tests.

That comparison also surfaced one uncomfortable detail. Laya’s README shows its example ticket routed to infrastructure with a churn risk of 91 percent. Upstream’s own runtime returns billing and 19 percent for that input at the published revision, and so does feelsneat. I treat the README numbers as illustrative.

The daemon speaks Jev’s POST /v1/systemone. TypeSafe’s official Python SDK worked unchanged once I pointed TYPESAFE_BASE_URL at http://127.0.0.1:3212. Code written against Jev can therefore move between the hosted model and a local one with an environment variable.

Try it

feelsneat needs macOS on Apple Silicon and a Rust toolchain. The first build compiles MLX and takes several minutes. Setup downloads the pinned checkpoints and verifies their checksums:

cargo install --locked --git https://gitlab.com/parlant-co/feelsneat.git
feelsneat --setup --model english,multilingual
feelsneat serve

The feelsneat repository documents use cases, integrations for pi, oMLX, Claude Code, and the Jev SDKs, and the full parity and performance methods. If you run agents from a terminal, my tmux setup for parallel coding agents shows where a local judgment call fits into that workflow. The model is Nandakishor Mukkunnoth’s work, and TypeSafe’s documentation gave me the vocabulary and most of the patterns. feelsneat makes both useful on the machine in front of me.