Seven jobs for a model that only decides

{
  "model": "jev-1.13.0",
  "state": {
    "company": "/Company Name",
    "industry": "/Industry",
    "company_description": "/Company Description",
    "job_title": "/Title",
    "headline": "/LinkedIn Headline"
  },
  "questions": {
    "icp_fit": {
      "type": "score",
      "instructions": "How well do `company`, `company_description` and `job_title` match our ideal customer: REPLACE with one sentence describing who you sell to and the problem you solve.",
      "criteria": [
        "Clearly outside our market: consumer business, student, job seeker, or a company that sells the same service we do",
        "Wrong industry, with no sign they sell to other businesses",
        "Sells to businesses, but the person is junior or not involved in sales or operations",
        "Right kind of business and a manager-level buyer, but no visible sign of the problem we solve",
        "Right kind of business, a founder, owner or head of sales or operations, and visible signs they have the problem we solve"
      ]
    },
    "is_decision_maker": {
      "type": "noul",
      "instructions": "`job_title` is a founder, owner, C-level, VP or head of sales, growth or operations."
    },
    "is_competitor": {
      "type": "noul",
      "instructions": "`company_description` describes a business that sells the same service we do."
    }
  }
}

# Use case 4: stop risky tool calls before they run.
# pip install "langchain-typesafe[experimental]" langchain-openai
# export TYPESAFE_API_KEY=...   (and your model provider key)
# Source: https://docs.langchain.com/oss/python/integrations/providers/typesafe
#
# AutoModeMiddleware asks Jev how likely each listed tool call is to be risky or not properly authorised.
# Risky calls return an error message to the agent instead of running. It blocks; it does not ask you for approval.
# It is experimental. Keep hard permissions in code as well: text the agent reads can still sway the answer.

from langchain.agents import create_agent
from langchain.tools import tool
from langchain_typesafe.experimental.middleware import AutoModeMiddleware


@tool
def send_email_to_list(list_name: str, subject: str) -> str:
    """Send an email to every contact on a list."""
    return f"Sent '{subject}' to {list_name}."


@tool
def read_calendar(day: str) -> str:
    """Read the calendar for a day."""
    return f"Calendar for {day}: 2 meetings."


agent = create_agent(
    "openai:gpt-6-astra",
    tools=[send_email_to_list, read_calendar],
    # Only the tools you list here get checked. Put your dangerous ones in.
    middleware=[AutoModeMiddleware(tools=[send_email_to_list])],
)

result = agent.invoke({"messages": [{"role": "user", "content": "Email the whole newsletter list about the price rise."}]})
print(result["messages"][-1].content)

{
  "hook_type": {
    "type": "choice",
    "instructions": "What kind of opening does the post use? Judge the first line of `caption` and the first sentence of `transcript`.",
    "criteria": {
      "number_claim": "Opens with a specific result, number, or dollar figure",
      "tool_reveal": "Opens by naming a tool or showing something built",
      "problem_callout": "Opens by naming a pain the viewer has",
      "contrarian": "Opens by disagreeing with common advice",
      "question": "Opens with a question to the viewer",
      "story": "Opens with a personal story or moment",
      "other": "None of the above"
    }
  },
  "format": {
    "type": "choice",
    "instructions": "What format is the post, judging by `caption` and `transcript`?",
    "criteria": {
      "tutorial": "Talks the viewer through how to do something",
      "screen_demo": "Shows a screen recording of a tool or build",
      "build_reveal": "Shows a finished build and what it does",
      "list_of_tools": "Runs through a list of tools, tips or resources",
      "case_study": "Tells what happened for a client or project",
      "opinion": "Gives a take or prediction",
      "other": "None of the above"
    }
  },
  "cta_type": {
    "type": "choice",
    "instructions": "What does `caption` ask the viewer to do?",
    "criteria": {
      "comment_keyword": "Comment a word to get something",
      "link_in_bio": "Go to the link in bio",
      "follow": "Follow the account",
      "dm": "Send a direct message",
      "none": "No ask"
    }
  },
  "names_a_tool": { "type": "noul", "instructions": "`caption` or `transcript` names a specific AI tool or product." },
  "shows_result": { "type": "noul", "instructions": "The post shows a finished result or output, going beyond an explanation." }
}

#!/usr/bin/env python3
"""Use case 6: tag every post with Jev, then see which kinds of post get the views.

Input:  a CSV with columns id, caption, transcript (optional), views
        (export from Meta Business Suite or YouTube Studio, then tidy the column names)
Output: tagged.csv (your columns plus one column per tag) and a summary of median views per tag

Set ONE key first:
  export TYPESAFE_API_KEY=...     calls https://api.typesafe.ai/v1/systemone
  export OPENROUTER_API_KEY=...   calls https://openrouter.ai/api/alpha/decisions

Run:
  python3 06-tag_posts.py sample-posts.csv --dry-run   print the first request, send nothing
  python3 06-tag_posts.py posts.csv                    tag everything

No installs needed (standard library only). The questions live in 06-post-tags.json: edit the
options to match your content, and keep an "other" option in every pick-one question.
"""
import csv
import json
import os
import statistics
import sys
import time
import urllib.error
import urllib.request
from collections import defaultdict
from pathlib import Path

HERE = Path(__file__).parent
QUESTIONS = json.loads((HERE / "06-post-tags.json").read_text())
MAX_TRANSCRIPT_CHARS = 6000  # the opening matters most; this also keeps each call cheap


def endpoint():
    if os.environ.get("TYPESAFE_API_KEY"):
        return "https://api.typesafe.ai/v1/systemone", os.environ["TYPESAFE_API_KEY"], "jev-1.13.0"
    if os.environ.get("OPENROUTER_API_KEY"):
        return "https://openrouter.ai/api/alpha/decisions", os.environ["OPENROUTER_API_KEY"], "typesafe/jev-1.13"
    return None, None, "jev-1.13.0"


def build_body(model, post):
    state = {"caption": (post.get("caption") or "").strip(),
             "transcript": (post.get("transcript") or "").strip()[:MAX_TRANSCRIPT_CHARS]}
    return {"model": model, "state": state, "questions": QUESTIONS}


def ask(url, key, body):
    data = json.dumps(body).encode()
    req = urllib.request.Request(url, data=data, headers={"Authorization": f"Bearer {key}", "Content-Type": "application/json"})
    for attempt in range(5):
        try:
            with urllib.request.urlopen(req, timeout=30) as r:
                return json.loads(r.read())
        except urllib.error.HTTPError as e:
            if e.code in (429, 500, 502, 503, 529) and attempt < 4:
                time.sleep(2 ** attempt)  # rate limited or busy: back off and retry
                continue
            raise


def flatten(answers):
    row = {}
    for name, a in answers.items():
        kind = a.get("type")
        if kind == "choice":
            row[name] = a.get("choice")
            row[name + "_confidence"] = round(a.get("confidence", 0), 3)
        elif kind == "score":
            row[name] = round(a.get("score", 0), 2)
            row[name + "_confidence"] = round(a.get("confidence", 0), 3)
        elif kind == "noul":
            row[name] = round(a.get("noul", 0), 3)  # probability of yes
    return row


def to_number(v):
    try:
        return float(str(v).replace(",", "").strip())
    except ValueError:
        return None


def summary(rows, tag):
    groups = defaultdict(list)
    for r in rows:
        views = to_number(r.get("views"))
        if views is not None and r.get(tag):
            groups[r[tag]].append(views)
    print(f"\nMedian views by {tag}:")
    for value, views in sorted(groups.items(), key=lambda kv: -statistics.median(kv[1])):
        print(f"  {value:<20} {statistics.median(views):>12,.0f}   ({len(views)} posts)")


def main():
    if len(sys.argv) < 2:
        sys.exit(__doc__)
    posts = list(csv.DictReader(open(sys.argv[1], newline="", encoding="utf-8-sig")))
    url, key, model = endpoint()
    if "--dry-run" in sys.argv:
        print(json.dumps(build_body(model, posts[0]), indent=2))
        return
    if not key:
        sys.exit("Set TYPESAFE_API_KEY or OPENROUTER_API_KEY first.")
    out = []
    for i, post in enumerate(posts, 1):
        res = ask(url, key, build_body(model, post))
        out.append({**post, **flatten(res.get("answers", {}))})
        print(f"{i}/{len(posts)} {post.get('id', '')}: {out[-1].get('hook_type')}")
        time.sleep(0.06)  # stays under 1,200 requests a minute
    with open("tagged.csv", "w", newline="", encoding="utf-8") as f:
        w = csv.DictWriter(f, fieldnames=list(out[0].keys()))
        w.writeheader()
        w.writerows(out)
    print("\nWrote tagged.csv")
    for tag in ("hook_type", "format", "cta_type"):
        summary(out, tag)


if __name__ == "__main__":
    main()

# LiteLLM proxy config: Jev decides which tier each request needs.
# Needs TYPESAFE_API_KEY in the proxy environment. Tier values must be model_name entries defined elsewhere in this file.
# Source: https://docs.litellm.ai/docs/auto_router/setup
model_list:
  # The four tiers. Swap these for the models you actually use; keep the model_name values matching the tiers below.
  - model_name: gpt-5.6-luna
    litellm_params: { model: openai/gpt-5.6-luna, api_key: os.environ/OPENAI_API_KEY }
  - model_name: gpt-5.6-terra
    litellm_params: { model: openai/gpt-5.6-terra, api_key: os.environ/OPENAI_API_KEY }
  - model_name: claude-sonnet-5
    litellm_params: { model: anthropic/claude-sonnet-5, api_key: os.environ/ANTHROPIC_API_KEY }
  - model_name: claude-opus-5
    litellm_params: { model: anthropic/claude-opus-5-5, api_key: os.environ/ANTHROPIC_API_KEY }

  # The router your app calls. Point your app at model "jev-router".
  - model_name: jev-router
    litellm_params:
      model: auto_router/complexity_router
      complexity_router_default_model: gpt-5.6-terra
      complexity_router_config:
        tiers:
          SIMPLE: gpt-5.6-luna
          MEDIUM: gpt-5.6-terra
          COMPLEX: claude-sonnet-5
          REASONING: claude-opus-5
        classifier_type: jev
        jev_classifier_config:
          model: jev-latest
          timeout_ms: 3000
          circuit_breaker_enabled: true
          circuit_breaker_cooldown_seconds: 30
        classifier_fallback: default_model
        classifier_context_window_size: 3
        classifier_context_budget_chars: 8000
        classifier_context_include_assistant_turns: false