# Bringing TypeSafe AI Jev Model to Go

> Source: <https://dev.to/truong_an_cornduck/bringing-typesafe-ai-jev-model-to-go-87n>
> Published: 2026-09-25 06:00:53+00:00

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.

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.

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.

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`](https://github.com/KKloudTarus/taurus-jev-sdk-go)** so Gophers can integrate Jev seamlessly.

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 | 

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

**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](https://github.com/KKloudTarus/taurus-jev-sdk-go)** repository. If you find it useful, feel free to give the repository a 🌟 **Star**. Happy coding!