jiffy Start exploring

IN DEVELOPMENT AN EDUCATIONAL AI PROJECT

Small model.
Clear decisions.

Turn text and questions into answers your code can use. Jiffy is an educational alternative inspired by Jev, built to make generalized classification understandable.

Explore the primitives See how it works

Preparing an open-source release. Built for learning.

a decision, in a jiffyEXAMPLE

01 / YOUR INPUT

“I was charged twice for the same order. Can you help?”

02 / YOUR QUESTION

Which team should handle this?

billingshippingreturns

03 / A TYPED ANSWER

Choice
choice"billing"
billing
0.92
shipping
0.05
returns
0.03

Illustrative probabilities. No model is running on this page.

~150Mparameters in the default model
8,192document tokens
3 primitivesone shared architecture
Your questionsdefined at inference time

01 / THE BUILDING BLOCKS

Three ways to
make a decision.

Describe the question and the allowed answers. The model scores them; Jiffy constructs a response with a defined shape.

SUPPORT ROUTINGILLUSTRATIVE EXAMPLE

Which team should handle this?

“I was charged twice for the same order.”

{
  "type": "choice",
  "choice": "billing",
  "probabilities": {
    "billing": 0.92,
    "shipping": 0.05,
    "returns": 0.03
  },
  "confidence": 0.70
}

The selected key always comes from your options. A valid key can still be the wrong answer.

These are example outputs, not measured predictions. Confidence describes the distribution; it is not a guarantee of correctness.

02 / UNDER THE HOOD

Follow the whole
path to an answer.

A pretrained text encoder, a trainable interaction head, and a small set of output rules. Each piece is there to inspect and understand.

REUSE ACROSS INPUTSQuestion + allowed answersEncode and cache the task
ONCE PER DOCUMENTYour input textEncode the document
LEARNED INTERACTIONScore the candidatesQuestions attend to document tokens
DEFINED OUTPUTSChoice · Score · NoulConstructed directly from scores
A

Ask new questions.

Supply instructions and answer descriptions at inference time. All tasks use the same scoring head.

B

Reuse the work.

Cache fixed questions across documents, and share one document encoding across several questions.

C

Learn by distilling.

Use an open model as a teacher, train the student on its probability targets, then evaluate on held-out data.

03 / BUILT TO BE UNDERSTOOD

The interesting part
is how it works.

Jiffy takes inspiration from Jev’s typed-decision interface and explores it with a small, inspectable classifier. The goal is an open-source educational alternative you can study, modify, and train yourself.

It is an independent implementation. Jiffy does not reproduce Jev’s undisclosed internals, and comparable accuracy or speed has not been demonstrated.

Read about the original inspiration
PROJECT STATUSEARLY DEVELOPMENT

Training & inference pipeline

Data generation, distillation, checkpoints, resume, evaluation, and local serving.

Typed outputs & reusable encodings

Choice, Score, and Noul with task and document caches.

Useful trained weights & GPU evidence

Toy CPU checks are complete. Broad training, calibration, and GPU benchmarks are still ahead.

Public source release

The repository is currently private. An open-source license and public release are being prepared.

04 / A SMALL PLACE TO START

One question.
Your own experiment.

After training a checkpoint, compile a task, encode an input, and score it. Keep the task around for the next document.

example.py
from jiffy import Question, configure_runtime, load_model

# Load a checkpoint you have trained.
model = configure_runtime(load_model("runs/student"), "cpu", "float32")
task = model.compile_task(Question.choice(
    "Which team should handle this?",
    {
        "billing": "Charges, invoices, or payment errors",
        "shipping": "Delivery updates or missing packages",
    },
))

state = model.encode_state("I was charged twice.")
result = model.score(state, {"route": task})

Source access is currently limited to repository collaborators.

Repository (private) Training guide (private)

A FEW USEFUL DETAILS

Good questions.

Is this a smaller chat model?

Jiffy is a classifier built around a text encoder and an interaction head. At inference time, it scores the answers you provide and constructs typed results. It does not generate answer text token by token.

Does type safety mean it is always correct?

No. Type safety constrains the shape and allowed values of a successful response. The model can still choose the wrong option, and useful confidence requires calibration and evaluation on representative data.

Can I use it out of the box?

The pretrained encoder provides a starting point, but Jiffy’s interaction head needs training. This project currently provides the software and an educational workflow, not a broadly trained classifier or hosted inference API.

What inputs and hardware does it support?

The current model accepts text, with up to 8,192 document tokens and a default limit of 1,024 tokens per question/candidate pair. CPU execution has been tested. NVIDIA GPU training profiles are prepared, with hardware checks at startup. Images and native 32K context are future work.