TL;DR: Jev for accounting researchers is most useful as a fast semantic decision layer between unstructured disclosures and researcher-controlled code. This guide shows how Choice, Noul, and Score can classify disclosures, retain probabilities, route uncertain observations to human reviewers, and support reproducible variable construction—while Python, R, SAS, or Stata still performs the mathematics and econometrics.

Jev for accounting researchers can turn repeated semantic judgments—such as whether a sentence discusses climate risk, contains a forward-looking statement, or provides company-specific detail—into structured outputs. This guide promises a practical research architecture, explains why Jev is different from an LLM, and closes three questions: which decision type fits each construct, how confidence should govern human review, and what researchers must preserve for reproducibility.

What does this guide cover?

1. What is Jev for accounting researchers?
2. Why should accounting researchers care about Jev?
3. How does Jev differ from ChatGPT and other LLMs?
4. Which Jev decision type should a researcher use?
5. How can accounting researchers start with Jev in Python?
6. Where can Jev support accounting research?
7. How should Jev outputs become research variables?
8. How should confidence drive human review?
9. How should researchers validate Jev coding?
10. What must a reproducible Jev study preserve?
11. What should Jev not do?
12. Frequently asked questions
13. What is the practical takeaway?

What is Jev for accounting researchers?

Jev for accounting researchers is a decision-oriented AI workflow for converting unstructured accounting information into bounded classifications, scores, and probabilities. Accounting researchers routinely face a problem that traditional machine learning and large language models do not solve particularly well: millions of small semantic decisions.

Jev is a model for selecting among researcher-defined answers, not for writing research prose.

Examples include: Does this sentence contain forward-looking information? Is this disclosure related to climate risk? Does this paragraph discuss board expertise? Is this ESG statement specific or boilerplate? Does this disclosure describe an actual commitment? Is this sentence related to environmental performance? Does a passage contain a material accounting issue? Should this document be included in a manually reviewed sample?

These tasks do not necessarily require an AI system to write an essay. They require a model to make a bounded decision. Jev, TypeSafe AI’s System One model, uses a different interaction pattern from a conventional large language model:

State + typed questions
        ↓
Structured decisions + probabilities
        ↓
Researcher-controlled code

Instead of asking an LLM to generate an answer and then attempting to parse it, the researcher defines the possible answers in advance. A disclosure can flow through Jev into a climate-related/not-climate-related classification, a probability, Python, and finally a research variable.

The researcher—not the AI model—can control thresholds, aggregation, and statistical analysis. Jev currently centers on three decision primitives: Choice, Noul, and Score. Readers who want the conceptual foundation can start with Jev explained as the AI model that never writes text.

Takeaway: Jev supplies a semantic judgment; the researcher retains methodological control.

If that division of labor fits your dataset, preserve this guide and test it against a human-coded sample. The spreadsheet will not be offended by supervision.

Why should accounting researchers care about Jev?

Jev matters because much of accounting research converts unstructured information into structured variables. A typical pipeline begins with a 10-K, 10-Q, sustainability report, or earnings call; extracts text; codes observations; constructs variables; and then runs statistical tests.

10-K / 10-Q / sustainability report / earnings call
                    ↓
             Text extraction
                    ↓
          Human or model coding
                    ↓
           Variable construction
                    ↓
           Econometric analysis

The difficult part is often the middle. Suppose a study contains 2 million disclosure sentences and asks which ones discuss climate-related risk. Available approaches include manual coding, keyword dictionaries, supervised classifiers, LLM classification, and manual validation. Jev adds bounded semantic classification with native structured output and probabilities.

• Categories are known before coding.
• The distinction is semantic rather than purely lexical.
• The task repeats across a large corpus.
• Machine-readable outputs are required.
• Probabilities are more useful than unexplained generated prose.
• The final coding rule must remain in researcher-controlled code.

A 10-K pipeline can combine extraction, Jev decisions, calibration, and review. The companion guide to fast, calibrated Jev workflows for 10-K data extraction develops that use case further.

Takeaway: Jev is attractive when the construct is bounded, semantic, repeated, and testable against human labels.

How does Jev differ from ChatGPT and other LLMs?

Jev selects structured decisions, while general-purpose LLMs primarily generate language. Large language models such as ChatGPT, Claude, Grok, and Kimi can reason across broad domains, but their primary interface produces tokens. Jev instead expects a question, possible answers, and relevant state; it returns a selected answer and probabilities.

Research task	General-purpose LLM	Jev
Write a literature review	Strong use case	Not designed for this
Explain accounting theory	Strong use case	Not designed for this
Generate Python or SAS code	Strong use case	Not designed for this
Summarize an annual report	Strong use case	Not designed for this
Classify text into predefined categories	Possible	Strong use case
Determine whether a condition is present	Possible	Strong use case
Apply an ordinal rubric	Possible	Strong use case
Return machine-readable decisions	Possible with parsing	Native design
Return decision probabilities	Requires careful interpretation	Native output
Run arithmetic or regressions	Use statistical software	Use statistical software

Jev is not a smaller ChatGPT. A classifier traditionally performs one narrow job and may not generalize beyond its training domain. Jev’s proposed value is broad semantic decision-making without producing a conversational answer token by token. The model is less interested in sounding helpful and more interested in choosing a box—an admirable quality in a coding pipeline.

Takeaway: Use an LLM for generation and broad reasoning; use Jev for bounded semantic decisions.

Which Jev decision type should a researcher use?

Choice fits categories, Noul fits yes/no propositions, and Score fits ordered rubrics. Selecting the primitive before processing data makes the construct easier to document and validate.

Choice classifies an observation into a predefined category

Choice can classify a sentence as environmental, social, governance, general ESG, or not ESG. Other applications include risk categories, accounting policies, governance disclosures, audit topics, director expertise, and earnings-call response types.

What type of ESG disclosure is this?

A. Environmental
B. Social
C. Governance
D. General ESG
E. Not ESG

Noul estimates whether a proposition is true

Noul is appropriate when a construct is present or absent: Does this sentence explicitly discuss climate-related risk? Does a passage contain forward-looking information? Does a management response evade the analyst’s question? The output is a probability rather than a paragraph pretending certainty.

Score applies a researcher-defined ordinal rubric

Score can measure disclosure specificity across ordered levels, such as completely generic, mostly generic, moderately specific, highly specific, and highly specific with quantified information. Score should represent an ordinal judgment, not arithmetic.

Primitive	Best for	Accounting example	Main design risk
Choice	Mutually defined categories	Classify an ESG sentence	Overlapping criteria
Noul	Yes/no propositions	Detect a forward-looking statement	Uncalibrated threshold
Score	Ordered levels	Rate disclosure specificity	Undefined rubric levels

Takeaway: The decision primitive should match the construct’s measurement scale before the first observation is coded.

How can accounting researchers start with Jev in Python?

The official Python package is installed as typesafe-sdk, and the API key is read from the TYPESAFE_API_KEY environment variable.

pip install typesafe-sdk

On Windows PowerShell:

$env:TYPESAFE_API_KEY="YOUR_API_KEY"

# Or persist it:
setx TYPESAFE_API_KEY "YOUR_API_KEY"

A basic Choice test can classify the primary topic of a disclosure:

from typesafe_sdk import Choice, TypeSafeClient

state = {
    "text": """
    The company expects climate-related regulations to increase
    operating costs over the next five years.
    """
}

with TypeSafeClient() as client:
    response = client.system_one(
        state=state,
        questions={
            "topic": Choice(
                instructions="What is the primary topic discussed in this disclosure?",
                criteria={
                    "climate": None,
                    "human_capital": None,
                    "governance": None,
                    "other": None,
                },
            ),
        },
    )

print(response)

The typed response avoids free-form parsing, but structured output does not eliminate measurement error. Researchers still need a codebook, validation sample, model identifier, query date, and saved raw outputs.

Key numbers

• Choice options: up to 255 (Jev interface described in the supplied source post, September 2026)
• Score levels: 2 to 10 (Jev interface described in the supplied source post, September 2026)
• Illustrative forward-looking threshold: 0.80 (researcher-defined example, not a universal recommendation)
• Illustrative auto-accept threshold: 0.90 (researcher-defined example)
• Illustrative human-review band: 0.60 to less than 0.90 (researcher-defined example)
• Suggested pilot: 500–1,000 human-coded observations (practical starting range in this guide)

Takeaway: A working API call is the beginning of the method, not evidence that the measure is valid.

Where can Jev support accounting research?

Jev can support disclosure classification, document screening, ordinal coding, sample routing, and literature organization. The strongest applications ask repeated semantic questions with answers that can be defined before coding.

ESG disclosure classification creates topic variables

A Choice question can classify sustainability-report sentences as environmental, social, governance, general ESG, or unrelated. Pandas should manage identifiers, missing values, outputs, and aggregation.

import pandas as pd
from typesafe_sdk import Choice, TypeSafeClient

INPUT_FILE = "csr_sentences.csv"
OUTPUT_FILE = "csr_sentences_jev.csv"
TEXT_COLUMN = "sentence"
ID_COLUMN = "sentence_id"

df = pd.read_csv(INPUT_FILE)

if TEXT_COLUMN not in df.columns or ID_COLUMN not in df.columns:
    raise ValueError("Required columns are missing")

def classify_esg(text):
    if pd.isna(text) or not str(text).strip():
        return {"category": None, "probabilities": {}}

    with TypeSafeClient() as client:
        response = client.system_one(
            state={"sentence": str(text).strip()},
            questions={
                "esg_category": Choice(
                    instructions=(
                        "Classify the primary ESG topic discussed in the sentence. "
                        "Select the category that best represents the substantive topic."
                    ),
                    criteria={
                        "environmental": None,
                        "social": None,
                        "governance": None,
                        "general_esg": None,
                        "not_esg": None,
                    },
                )
            },
        )

    answer = response.answers["esg_category"]
    return {"category": answer.choice, "probabilities": answer.probabilities}

categories = []
confidence = []

for i, row in df.iterrows():
    result = classify_esg(row[TEXT_COLUMN])
    categories.append(result["category"])
    confidence.append(max(result["probabilities"].values()) if result["probabilities"] else None)
    print(f"{i + 1}/{len(df)} | {result['category']} | {confidence[-1]}")

df["jev_esg_category"] = categories
df["jev_confidence"] = confidence
df.to_csv(OUTPUT_FILE, index=False, encoding="utf-8-sig")

Forward-looking statement detection replaces a purely lexical test

A Noul question can ask whether a sentence contains substantive information about expected future events, conditions, performance, plans, or outcomes. An illustrative threshold of 0.80 is a research-policy choice, not a universal Jev recommendation; calibration against human-coded observations must determine the final threshold.

from typesafe_sdk import Noul, TypeSafeClient

def classify_forward_looking(text):
    if pd.isna(text) or not str(text).strip():
        return None, None

    with TypeSafeClient() as client:
        response = client.system_one(
            state={"sentence": str(text).strip()},
            questions={
                "forward_looking": Noul(
                    instructions=(
                        "Does this sentence contain a substantive forward-looking "
                        "statement about expected future events, conditions, "
                        "performance, plans, or outcomes?"
                    )
                )
            },
        )

    probability = response.answers["forward_looking"].probability
    return probability >= 0.80, probability

Disclosure specificity requires a predefined ordinal rubric

“We are committed to reducing our environmental impact” and “We reduced Scope 1 emissions by 18% in 2025 and plan a further 15% reduction by 2030” address a similar topic but contain different levels of specificity. A five-level Score rubric can distinguish generic language from concrete, quantified information.

1. Completely generic disclosure with no substantive detail.
2. Mostly generic disclosure with limited detail.
3. Moderately specific disclosure containing identifiable information.
4. Highly specific disclosure containing concrete details or actions.
5. Highly specific disclosure containing concrete, detailed, or quantified information.

The rubric should be specified before the model runs. Asking “How specific is this disclosure?” and inventing the scale afterward is not a measurement strategy (it is improvisation wearing a lab coat).

Additional applications cover several accounting domains

Research area	Potential bounded decisions
Financial accounting	Forward-looking statements, policy disclosures, risk, management explanations, revenue recognition, going concern, material weaknesses, internal controls, non-GAAP classification
Auditing	Audit risk, key audit matters, critical audit matter topics, auditor expertise, audit-quality disclosures, going-concern language
ESG and sustainability	Climate risk, human capital, targets, commitments, performance, boilerplate language, specificity, greenwashing-related language
Corporate governance	Director expertise, independence descriptions, diversity disclosure, succession, compensation, governance mechanisms
Capital markets	Earnings-call topics, investor questions, guidance, uncertainty, risk, strategy, non-answers
Management accounting	Performance measurement, cost management, budgeting, controls, operational risk, strategy disclosures

Literature-review workflows can also classify abstracts by financial accounting, management accounting, auditing, taxation, corporate governance, ESG, disclosure, or capital-markets topics. Sample-selection workflows can screen documents for substantive climate-transition-risk discussion before human verification.

Takeaway: Jev fits semantic screening and coding; stronger claims require stronger validation.

How should Jev outputs become research variables?

Jev should classify observations, while Python, R, SAS, Stata, or SQL should calculate research variables. For an ESG disclosure ratio, classify each sentence first and then divide ESG-related sentences by total sentences in deterministic code.

import pandas as pd

df = pd.read_csv("jev_sentence_results.csv")

df["is_esg"] = (
    df["jev_esg_category"]
    .isin(["environmental", "social", "governance", "general_esg"])
    .astype(int)
)

firm_year = (
    df.groupby(["gvkey", "fyear"])
      .agg(
          total_sentences=("is_esg", "size"),
          esg_sentences=("is_esg", "sum")
      )
      .reset_index()
)

firm_year["esg_disclosure_ratio"] = (
    firm_year["esg_sentences"] / firm_year["total_sentences"]
)

firm_year.to_csv("firm_year_esg_variable.csv", index=False)

The architecture is defensible because each component has a narrow job:

• Jev: semantic judgment.
• Python or pandas: data management and variable construction.
• Stata, R, Python, or SAS: econometric analysis.
• Researcher: construct definition, validation, and interpretation.

Takeaway: The AI model should not control the empirical methodology.

How should confidence drive human review?

Confidence can route obvious observations automatically and reserve ambiguous cases for human coders. A probability is useful because uncertainty can remain visible instead of being flattened into “AI says yes” or “AI says no.”

Illustrative probability	Workflow action	Interpretation
p ≥ 0.90	Automatically accept	High-confidence positive observation
0.60 ≤ p < 0.90	Send to human coder	Ambiguous observation
p < 0.60	Automatically reject	Lower-confidence positive observation

The table is an example, not a recommended universal policy. Thresholds should reflect a validation sample and the relative costs of false positives and false negatives.

import pandas as pd

AUTO_ACCEPT = 0.90
AUTO_REVIEW = 0.60

def assign_review_status(probability):
    if pd.isna(probability):
        return "missing"
    if probability >= AUTO_ACCEPT:
        return "auto_accept"
    if probability >= AUTO_REVIEW:
        return "human_review"
    return "auto_reject"

df = pd.read_csv("jev_results.csv")
df["review_status"] = df["jev_probability"].apply(assign_review_status)
df.to_csv("human_review_queue.csv", index=False)

Takeaway: AI handles clear cases; human coders concentrate on observations where mistakes are most plausible or costly.

How should researchers validate Jev coding?

Researchers should compare Jev outputs with independently human-coded observations before scaling to the full population. A practical sequence is:

1. Define the construct and coding rubric.
2. Randomly select a development sample.
3. Code the sample using trained human coders.
4. Run the same observations through Jev.
5. Calculate accuracy, precision, recall, F1, a confusion matrix, and agreement.
6. Inspect false positives and false negatives.
7. Revise the criteria without touching the holdout labels.
8. Evaluate the final specification on a separate holdout sample.
9. Select thresholds using the study’s error costs.
10. Scale only after performance is acceptable for the intended inference.

import pandas as pd
from sklearn.metrics import (
    accuracy_score,
    precision_recall_fscore_support,
    classification_report,
    confusion_matrix,
)

df = pd.read_csv("human_vs_jev.csv")
validation = df[df["human_label"].notna() & df["jev_label"].notna()].copy()

accuracy = accuracy_score(validation["human_label"], validation["jev_label"])
precision, recall, f1, support = precision_recall_fscore_support(
    validation["human_label"],
    validation["jev_label"],
    average="weighted",
    zero_division=0,
)

print(f"Accuracy: {accuracy:.4f}")
print(f"Weighted precision: {precision:.4f}")
print(f"Weighted recall: {recall:.4f}")
print(f"Weighted F1: {f1:.4f}")
print(classification_report(
    validation["human_label"],
    validation["jev_label"],
    zero_division=0,
))

labels = sorted(set(validation["human_label"]) | set(validation["jev_label"]))
matrix = confusion_matrix(
    validation["human_label"], validation["jev_label"], labels=labels
)
print(pd.DataFrame(matrix, index=labels, columns=labels))

“AI coded our variables” is not enough. A methods section should identify the construct, rubric, model, validation design, performance metrics, threshold, and treatment of uncertain observations.

Takeaway: Validation converts an AI-assisted workflow from an assertion into an empirical measurement procedure.

What must a reproducible Jev study preserve?

A reproducible Jev study should preserve the model identifier, exact questions, criteria, raw probabilities, query date, thresholds, human labels, validation results, and final coding code. An alias such as jev-latest can change, so researchers should also save the resolved model version returned during the study.

1. Model: exact version, not only an alias.
2. Question: exact instruction text.
3. Criteria: exact category descriptions or score rubric.
4. State: input text and relevant metadata, subject to data-governance limits.
5. Raw output: selected answer and full probability distribution.
6. Threshold: numerical rule such as p ≥ 0.90.
7. Validation sample: observations, human labels, and sampling procedure.
8. Query date: date and, where material, time of processing.
9. Code: scripts that transform model outputs into final variables.
10. Exceptions: missing inputs, retries, failures, and manual overrides.

Store more than the final binary indicator. A research-ready file can contain sentence_id, gvkey, fyear, jev_model, jev_question, jev_category, jev_probability, threshold, and final_classification.

For U.S. public-company research, obtain filing data through the SEC’s specific EDGAR API documentation and retain accession-level identifiers. Sustainability studies can map constructs to the applicable disclosure framework, including the IFRS Foundation’s specific IFRS S1 General Requirements, rather than citing a regulator’s homepage.

Takeaway: Save enough evidence for another researcher to reconstruct both the model decision and the final variable.

What should Jev not do?

Jev should not replace deterministic computation, statistical software, or methodological judgment. Arithmetic belongs in code.

• Do not use Jev to calculate ROA, Tobin’s Q, abnormal returns, standard deviations, firm age, regression coefficients, or p-values.
• Do not use Jev to merge datasets, sort observations, count rows, or compare dates mathematically.
• Do not interpret a probability as proof that the assigned category is correct.
• Do not choose a threshold after inspecting the desired regression result.
• Do not allow sensitive or licensed data to enter a workflow without checking applicable access and data-governance terms.

# Use Python for mathematics

df["roa"] = df["net_income"] / df["total_assets"]
df["firm_age"] = df["fyear"] - df["incorporation_year"]

Who this does not apply to: Researchers who need open-ended synthesis, causal identification, numerical computation, or authoritative interpretation of accounting standards should not treat Jev as the primary tool for those tasks.

A combined workflow can still be powerful: a general LLM extracts candidate passages, Jev classifies or scores them, Python builds variables, and humans review the evidence. For large filing datasets, the calibrated extraction workflow in Jev for 10-K data extraction provides a natural next step.

Takeaway: Jev’s strength is the semantic judgment that precedes computation, not the computation itself.

Frequently asked questions

What is the practical takeaway?

Jev should be viewed as a semantic decision layer for empirical accounting research, not as another chatbot. Jev makes the semantic judgment; the researcher defines the construct; Python performs the mathematics and variable construction; and human validation establishes whether the measure is fit for purpose.

A sensible starting point is a 500–1,000-observation pilot: define the construct, write the typed question, preserve probabilities, compare results with human coding, inspect errors, revise the rubric, test a holdout sample, and only then scale. For the underlying model concept, read why Jev makes decisions instead of writing text.

Primary action: Build and preregister a small validation study before using Jev-generated labels in a full accounting dataset.

Return hook: Revisit the workflow whenever the resolved Jev model version changes; a new alias target is a dated methodological event, not a silent software update.

The empirical paper—not the AI model—should make the research contribution. Models can choose boxes quickly; researchers still have to explain why the boxes deserve to exist.

Read next

• You can find the code files on GitHub.
• TypeSafe AI System One announcement — primary source for architecture and pricing
• TypeSafe Models documentation — current limits, aliases, and rate information

↑ Back to top