Bringing TypeSafe AI Jev Model to Go

#go #ai #typesafeai #jevmodel

The Jev model from TypeSafe AI introduces a System One approach, delivering structured data rapidly instead of slow text generation. Since official SDKs are only available for Python and JS, our team built taurus-jev-sdk-go. Here is how to use it in Go.

Traditional LLMs Are Not Always the Right Choice

AI engineers often face an inherent drawback: using traditional Large Language Models (such as GPT or Claude) for automation tasks like classification, risk scoring, or data routing is often slow and resource-intensive. These LLMs generate text token-by-token (autoregressively), resembling the "System 2" thinking pattern (deliberate, slow reasoning) in psychology. However, most backend systems require "System 1" decisions: fast reactions, intuitive judgment, and strongly typed return values.

TypeSafe AI Releases Jev: The First "System One" Model

That is why TypeSafe AI (founded by former OpenAI engineers) introduced a novel class of models: System One Models. Their first model is named Jev.

Jev operates as an intelligence function call. It does NOT generate text or chat. Instead, it takes raw data alongside a set of questions, then processes them in parallel to return structured outputs (Yes/No, scores, labels) paired with calibrated probabilities. By eliminating token generation, Jev achieves ultra-low latency, ranging from 70ms to 500ms.

With Jev, every response is a standard value (float, string, int) ready for direct evaluation in if/else logic branches.

The Problem: TypeSafe Lacks an Official Go SDK

TypeSafe AI currently provides official SDKs only for Python and JavaScript/TypeScript. If you work with a Golang backend, you would have to write raw HTTP requests, construct payloads, and handle errors manually.

To solve this, our team developed taurus-jev-sdk-go so Gophers can integrate Jev seamlessly.

What Can You Ask the Jev Model?

TypeSafe AI supports three question types. The SDK covers all three:

Type	Intended Use	Return Value
`jev.Noul`	Is this statement true?	Probability `float` between 0 and 1
`jev.Choice`	Which label fits best?	Selected label + Confidence
`jev.Score`	Rated scale evaluation	Numeric score + Legend + Confidence

How to Use the SDK

Consider a real-world scenario: an automated Support Ticket processing pipeline. You need AI to inspect the ticket content and categorize it immediately:

Does this ticket relate to a billing issue?
What is the user's emotional tone?
What is the urgency level?

Step 1 - Set the API Key from TypeSafe:

export TYPESAFE_API_KEY="sk-typesafe-..."

Step 2 - Install the SDK:

go get github.com/KKloudTarus/taurus-jev-sdk-go

Step 3 - Call the API:

package main

import (
    "context"
    "errors"
    "fmt"
    "log"

    jev "github.com/KKloudTarus/taurus-jev-sdk-go"
)

func main() {
    // Initialize Client (automatically reads TYPESAFE_API_KEY from environment)
    client, err := jev.New()
    if err != nil {
        log.Fatalf("Failed to initialize client: %v", err)
    }

    // State: Support ticket payload to analyze
    state := map[string]any{
        "subject": "Duplicate charge",
        "body":    "I was charged twice on my credit card. Please refund immediately!",
    }

    // Send 3 questions simultaneously in a single request
    response, err := client.SystemOne(context.Background(), state, jev.Questions{
        "is_billing": jev.Noul{
            Instructions: "Does this ticket relate to a billing or refund issue?",
        },
        "tone": jev.Choice{
            Instructions: "What is the primary tone of the user?",
            Criteria: map[string]any{
                "angry": "upset, hostile, or demanding",
                "calm":  "neutral or polite",
            },
        },
        "urgency": jev.Score{
            Instructions: "How urgent is this ticket?",
            Criteria: []any{
                "Can wait for regular business hours",
                "Needs attention this week",
                "Needs immediate attention today",
            },
        },
    })
    if err != nil {
        switch {
        case errors.Is(err, jev.ErrRateLimit), errors.Is(err, jev.ErrOverloaded):
            log.Fatal("AI service overloaded, queuing ticket for retry...")
        case errors.Is(err, jev.ErrAuthentication):
            log.Fatal("Invalid API Key!")
        default:
            log.Fatalf("Error: %v", err)
        }
    }

    // Process results and execute business logic
    if p, ok := response.NoulOf("is_billing"); ok && p > 0.85 {
        fmt.Printf("[Billing] Probability %.0f%%: routing to Accounting\n", p*100)
    }

    if tone, ok := response.ChoiceOf("tone"); ok && tone.Label == "angry" {
        fmt.Printf("[Tone] User is upset (confidence %.2f): escalating ticket\n", tone.Confidence)
    }

    if u, ok := response.ScoreOf("urgency"); ok {
        fmt.Printf("[Urgency] Level %d: %q\n", u.Score, u.Legend)
    }
}

Every response from the model is pre-parsed into standard Go types without regex matching or manual string parsing.

You can check out the source code and try it yourself in the taurus-jev-sdk-go repository. If you find it useful, feel free to give the repository a 🌟 Star. Happy coding!

DEV Community