@prefix : <https://substack.com/app-link/post?publication_id=594665&post_id=216405849#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix prov: <http://www.w3.org/ns/prov#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix schema: <http://schema.org/> .
@prefix skos: <http://www.w3.org/2004/02/skos/core#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .

:TrainingObjective a rdfs:Class ;
    rdfs:label "Training Objective"@en ;
    rdfs:comment "A distinct objective a model can be trained against: preference, correctness, or calibration."@en ;
    rdfs:isDefinedBy :trainingObjectiveOntology .

:entityIndex a schema:Thing ;
    schema:description "Index reaching every entity in this knowledge graph."@en ;
    schema:isPartOf :analysis ;
    schema:mentions <http://dbpedia.org/resource/ChatGPT>,
        <http://dbpedia.org/resource/OpenAI>,
        <https://businessengineering.ai#this>,
        <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/kg-generator#this>,
        <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/rdf-infographic-skill#this>,
        <https://substack.com/@thebusinessengineer#this>,
        :TrainingObjective,
        :a1,
        :a10,
        :a11,
        :a12,
        :a13,
        :a14,
        :a2,
        :a3,
        :a4,
        :a5,
        :a6,
        :a7,
        :a8,
        :a9,
        :agenting-platform,
        :analysis,
        :answersQuestion,
        :calibrationObjective,
        :claim-automation-threshold-ladder,
        :claim-compounding-reliability,
        :claim-earn-autonomy-pricing,
        :claim-escalation-insurance,
        :claim-priced-oversight,
        :claim-seat-anchor-cost-line,
        :claim-ticket-triage-economics,
        :coreEntities,
        :correctnessObjective,
        :diogo-almeida,
        :disclosure,
        :faqSection,
        :genesis,
        :glossarySection,
        :gpt-3-5,
        :gpt-4o,
        :howtoSection,
        :instructgpt,
        :jev,
        :keyLimitation,
        :keyStrength,
        :openclaw,
        :preferenceObjective,
        :q1,
        :q10,
        :q11,
        :q12,
        :q13,
        :q14,
        :q2,
        :q3,
        :q4,
        :q5,
        :q6,
        :q7,
        :q8,
        :q9,
        :qv-chain-steps,
        :qv-end-to-end-reliability,
        :qv-error-cost-high,
        :qv-error-cost-low,
        :qv-error-cost-mid,
        :qv-escalation-cost,
        :qv-escalation-error-threshold,
        :qv-review-cost,
        :qv-step-reliability,
        :qv-threshold-80,
        :qv-threshold-98,
        :qv-threshold-9998,
        :qv-ticket-account-support,
        :qv-ticket-other,
        :qv-ticket-payments,
        :qv-ticket-urgent,
        :qv-wrong-action-cost,
        :sparql-calibration-faqs,
        :sparql-glossary-terms,
        :sparql-type-summary,
        :sparqlSection,
        :step1,
        :step2,
        :step3,
        :step4,
        :step5,
        :term-calibration,
        :term-choice,
        :term-chosen-loop,
        :term-decision-native-model,
        :term-forced-loop,
        :term-harness,
        :term-jev,
        :term-measurement-loop,
        :term-meta-harness,
        :term-noul,
        :term-operational-loop,
        :term-rlcd,
        :term-rlhf,
        :term-score,
        :term-seat-anchor,
        :term-sycophancy,
        :thesisAnalysisSection,
        :trainingObjectiveOntology,
        <https://typesafe.ai#this> ;
    schema:name "Entity index"@en .

<http://dbpedia.org/resource/ChatGPT> a schema:SoftwareApplication ;
    schema:description "Conversational assistant launched in November 2022 on the GPT-3.5 model; its breakthrough was making intelligence accessible through an interaction people immediately understood."@en ;
    schema:isPartOf :coreEntities ;
    schema:name "ChatGPT"@en .

<http://dbpedia.org/resource/OpenAI> a schema:Organization ;
    schema:description "AI research company behind InstructGPT, ChatGPT, and the 2025 GPT-4o sycophancy episode discussed in the article."@en ;
    schema:isPartOf :coreEntities ;
    schema:name "OpenAI"@en .

<https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/kg-generator#this> a schema:SoftwareApplication ;
    schema:description "Knowledge graph generation skill that produced the RDF-Turtle source of truth for this collection."@en ;
    schema:name "kg-generator skill"@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/kg-generator> .

<https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/rdf-infographic-skill#this> a schema:SoftwareApplication ;
    schema:description "RDF-backed HTML infographic generation skill that produced the companion web page from the RDF source of truth."@en ;
    schema:name "rdf-infographic-skill"@en ;
    schema:url <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/rdf-infographic-skill> .

:agenting-platform a schema:WebApplication ;
    schema:description "The Business Engineer's Agenting platform, where Jev is available to executive members."@en ;
    schema:isPartOf :coreEntities ;
    schema:name "Agenting platform"@en ;
    schema:url <https://businessengineering.ai/agent> .

:answersQuestion a rdf:Property ;
    rdfs:label "answers question"@en ;
    rdfs:comment "The question a training objective answers."@en ;
    rdfs:domain :TrainingObjective ;
    rdfs:isDefinedBy :trainingObjectiveOntology ;
    rdfs:range xsd:string .

:calibrationObjective a :TrainingObjective ;
    rdfs:label "Calibration objective"@en ;
    schema:description "Trains the model to output honest probabilities; answers how likely a claim is to be true, and is the objective behind Jev's uncertainty-aware agent."@en ;
    rdfs:isDefinedBy :trainingObjectiveOntology ;
    :answersQuestion "When the model says it is 90% confident, is it actually right about 90% of the time?"@en ;
    :keyLimitation "Calibration works across groups of predictions, not individual cases, and is always local to the environment in which it was measured."@en ;
    :keyStrength "Makes uncertainty trustworthy enough to govern unattended decisions."@en .

:claim-earn-autonomy-pricing a schema:Claim ;
    schema:description "The article argues the business model shifts with the loop: the product reprices toward completed decisions, governance toward evidence and thresholds, and human work toward exceptions and system design. Autonomy is earned through measured calibration and kept only while the evidence holds — the author's thesis, not a verified market outcome."@en ;
    schema:isPartOf :thesisAnalysisSection ;
    schema:name "Automation earns autonomy through evidence; pricing follows completed decisions"@en ;
    schema:position 6 .

:claim-priced-oversight a schema:Claim ;
    schema:description "The article's thesis: once confidence is calibrated, human review stops being per-case labor and becomes statistical oversight — priced by review cost against error cost, sampled by policy, and audited against outcomes. Oversight is retained, but it is selective and measurement-driven rather than a person approving every decision."@en ;
    schema:isPartOf :thesisAnalysisSection ;
    schema:name "Calibration turns oversight into priced, statistical review"@en ;
    schema:position 5 .

:claim-seat-anchor-cost-line a schema:Claim ;
    schema:description "The article's seat-anchor implication: the human seat is a cost line that scales down as calibrated evidence accumulates. Humans remain in forced loops where reliability is insufficient, and in chosen loops where judgment, accountability, values, or authority require them — but each retained seat must be justified by economics or deliberate choice, not by default."@en ;
    schema:isPartOf :thesisAnalysisSection ;
    schema:name "The human-in-the-loop seat becomes a shrinking cost line"@en ;
    schema:position 7 .

:correctnessObjective a :TrainingObjective ;
    rdfs:label "Correctness objective"@en ;
    schema:description "Trains the model to produce verifiably correct outputs; answers whether a prediction matches ground truth, and is the objective behind classifiers with measurable error rates."@en ;
    rdfs:isDefinedBy :trainingObjectiveOntology ;
    :answersQuestion "Did the system get the answer right?"@en ;
    :keyLimitation "Accuracy alone does not solve automation: a model can be very accurate on average and still be dangerous if it does not know when it is likely to be wrong."@en ;
    :keyStrength "Works especially well where the result can be checked directly, as in mathematics, code, or other tasks with clear verifiers."@en .

:disclosure a schema:CreativeWork ;
    schema:isPartOf :coreEntities ;
    schema:name "Affiliation disclosure"@en ;
    schema:text "To be clear, I have no affiliation with TypeSafe AI or Jev. As usual, I cover what I think is important not because it is the loudest news of the week, but because it may reveal where the industry is moving next."@en .

:genesis a schema:SoftwareApplication ;
    schema:description "The Business Engineer's latest free AI tool, offered so readers can experience Jev's speed firsthand."@en ;
    schema:isPartOf :coreEntities ;
    schema:name "Genesis"@en ;
    schema:url <https://businessengineering.ai/tools/genesis> .

:gpt-3-5 a schema:SoftwareApplication ;
    schema:description "The underlying language model of the November 2022 ChatGPT launch."@en ;
    schema:isPartOf :coreEntities ;
    schema:name "GPT-3.5"@en .

:gpt-4o a schema:SoftwareApplication ;
    schema:description "Model whose 2025 sycophancy problem OpenAI described: a change intended to improve the experience instead made the model excessively agreeable."@en ;
    schema:isPartOf :coreEntities ;
    schema:name "GPT-4o"@en .

:instructgpt a schema:SoftwareApplication ;
    schema:description "Model whose training combined supervised examples of conversations with reinforcement learning guided by human rankings of responses; ChatGPT was a sibling of InstructGPT, not simply the same model with a chat window attached."@en ;
    schema:isPartOf :coreEntities ;
    schema:name "InstructGPT"@en .

:keyLimitation a rdf:Property ;
    rdfs:label "key limitation"@en ;
    rdfs:comment "Where the training objective falls short."@en ;
    rdfs:domain :TrainingObjective ;
    rdfs:isDefinedBy :trainingObjectiveOntology ;
    rdfs:range xsd:string .

:keyStrength a rdf:Property ;
    rdfs:label "key strength"@en ;
    rdfs:comment "What the training objective is good for."@en ;
    rdfs:domain :TrainingObjective ;
    rdfs:isDefinedBy :trainingObjectiveOntology ;
    rdfs:range xsd:string .

:openclaw a schema:SoftwareApplication ;
    schema:description "Described as one of the defining product signals of 2026: not inventing agents, but making the direction obvious — persistent AI that can use tools, hold context, and keep working beyond the chat window."@en ;
    schema:isPartOf :coreEntities ;
    schema:name "OpenClaw"@en .

:preferenceObjective a :TrainingObjective ;
    rdfs:label "Preference objective"@en ;
    schema:description "Trains the model to match human preference judgments; answers which response a human would prefer, and is the objective behind RLHF-tuned assistants."@en ;
    rdfs:isDefinedBy :trainingObjectiveOntology ;
    :answersQuestion "Which response would a person prefer?"@en ;
    :keyLimitation "A preferred answer is not necessarily a true one."@en ;
    :keyStrength "Useful for instruction-following, tone, usefulness, and interaction quality."@en .

:qv-chain-steps a schema:PropertyValue ;
    schema:description "Number of sequential decision steps in the article's compounding illustration."@en ;
    schema:isPartOf :claim-compounding-reliability ;
    schema:name "Steps in the compounding example"@en ;
    schema:value "10"@en .

:qv-end-to-end-reliability a schema:PropertyValue ;
    schema:description "0.99 raised to the 10th power: the article's figure for ten 99%-reliable steps in sequence."@en ;
    schema:isPartOf :claim-compounding-reliability ;
    schema:name "End-to-end chain reliability"@en ;
    schema:value "~90.4%"@en .

:qv-error-cost-high a schema:PropertyValue ;
    schema:description "Error cost at which the article's formula sets the automation threshold near 99.98%."@en ;
    schema:isPartOf :claim-automation-threshold-ladder ;
    schema:name "Error cost, high-stakes tier"@en ;
    schema:unitText "USD"@en ;
    schema:value "$10,000"@en .

:qv-error-cost-low a schema:PropertyValue ;
    schema:description "Error cost at which the article's formula sets the automation threshold near 80%."@en ;
    schema:isPartOf :claim-automation-threshold-ladder ;
    schema:name "Error cost, low-stakes tier"@en ;
    schema:unitText "USD"@en ;
    schema:value "$10"@en .

:qv-error-cost-mid a schema:PropertyValue ;
    schema:description "Error cost at which the article's formula sets the automation threshold near 98%."@en ;
    schema:isPartOf :claim-automation-threshold-ladder ;
    schema:name "Error cost, mid-stakes tier"@en ;
    schema:unitText "USD"@en ;
    schema:value "$100"@en .

:qv-escalation-cost a schema:PropertyValue ;
    schema:description "The article's assumed human-time cost of escalating a single case."@en ;
    schema:isPartOf :claim-escalation-insurance ;
    schema:name "Cost of one escalation"@en ;
    schema:unitText "cost units"@en ;
    schema:value "1"@en .

:qv-escalation-error-threshold a schema:PropertyValue ;
    schema:description "Escalate whenever the calibrated error rate exceeds 1/(1+9): the article's insurance-pricing illustration."@en ;
    schema:isPartOf :claim-escalation-insurance ;
    schema:name "Escalation error-rate threshold"@en ;
    schema:value "10%"@en .

:qv-review-cost a schema:PropertyValue ;
    schema:description "The article's assumed cost of one human review, held constant across the threshold ladder."@en ;
    schema:isPartOf :claim-automation-threshold-ladder ;
    schema:name "Review cost"@en ;
    schema:unitText "USD"@en ;
    schema:value "$2"@en .

:qv-step-reliability a schema:PropertyValue ;
    schema:description "Assumed reliability of each individual step in the compounding illustration."@en ;
    schema:isPartOf :claim-compounding-reliability ;
    schema:name "Per-step reliability"@en ;
    schema:value "99%"@en .

:qv-threshold-80 a schema:PropertyValue ;
    schema:description "1 minus $2/$10: the article's illustrative bar for automating low-stakes decisions."@en ;
    schema:isPartOf :claim-automation-threshold-ladder ;
    schema:name "Automation threshold at $10 error cost"@en ;
    schema:value "~80%"@en .

:qv-threshold-98 a schema:PropertyValue ;
    schema:description "1 minus $2/$100: the article's illustrative bar for automating mid-stakes decisions."@en ;
    schema:isPartOf :claim-automation-threshold-ladder ;
    schema:name "Automation threshold at $100 error cost"@en ;
    schema:value "~98%"@en .

:qv-threshold-9998 a schema:PropertyValue ;
    schema:description "1 minus $2/$10,000: the article's illustrative bar for automating high-stakes decisions."@en ;
    schema:isPartOf :claim-automation-threshold-ladder ;
    schema:name "Automation threshold at $10,000 error cost"@en ;
    schema:value "~99.98%"@en .

:qv-ticket-account-support a schema:PropertyValue ;
    schema:description "Support-ticket example: the Account support intent auto-resolves at this calibrated confidence."@en ;
    schema:isPartOf :claim-ticket-triage-economics ;
    schema:name "Account support intent confidence"@en ;
    schema:value "0.06"@en .

:qv-ticket-other a schema:PropertyValue ;
    schema:description "Support-ticket example: the Other intent escalates to a human at this calibrated confidence."@en ;
    schema:isPartOf :claim-ticket-triage-economics ;
    schema:name "Other intent confidence"@en ;
    schema:value "0.03"@en .

:qv-ticket-payments a schema:PropertyValue ;
    schema:description "Support-ticket example: the Payments intent auto-resolves at this calibrated confidence."@en ;
    schema:isPartOf :claim-ticket-triage-economics ;
    schema:name "Payments intent confidence"@en ;
    schema:value "0.91"@en .

:qv-ticket-urgent a schema:PropertyValue ;
    schema:description "Support-ticket example: the urgent-escalation flag routes to a person at this calibrated confidence."@en ;
    schema:isPartOf :claim-ticket-triage-economics ;
    schema:name "Urgent-escalation flag confidence"@en ;
    schema:value "0.42"@en .

:qv-wrong-action-cost a schema:PropertyValue ;
    schema:description "The article's assumed cost when the automated action is wrong."@en ;
    schema:isPartOf :claim-escalation-insurance ;
    schema:name "Cost of one wrong automated action"@en ;
    schema:unitText "cost units"@en ;
    schema:value "9"@en .

:sparql-calibration-faqs a schema:SoftwareSourceCode ;
    schema:codeSampleType "SELECT query"@en ;
    schema:description "Finds FAQ questions and answers that mention calibration."@en ;
    schema:isPartOf :sparqlSection ;
    schema:name "FAQ questions about calibration"@en ;
    schema:programmingLanguage "SPARQL"@en ;
    schema:target <https://linkeddata.uriburner.com/sparql> ;
    schema:text """PREFIX : <https://substack.com/app-link/post?publication_id=594665&post_id=216405849#>
PREFIX schema: <http://schema.org/>
SELECT ?qIri ?question ?aIri
WHERE {
  GRAPH <https://substack.com/app-link/post?publication_id=594665&post_id=216405849> {
    :faqSection schema:mainEntity ?qIri .
    ?qIri a schema:Question ;
          schema:name ?question ;
          schema:acceptedAnswer ?aIri .
    ?aIri schema:text ?answer .
    FILTER(CONTAINS(LCASE(?question), 'calibrat') || CONTAINS(LCASE(?answer), 'calibrat'))
  }
}"""@en .

:sparql-glossary-terms a schema:SoftwareSourceCode ;
    schema:codeSampleType "SELECT query"@en ;
    schema:description "Lists every defined term in the glossary with its definition."@en ;
    schema:isPartOf :sparqlSection ;
    schema:name "Glossary terms with definitions"@en ;
    schema:programmingLanguage "SPARQL"@en ;
    schema:target <https://linkeddata.uriburner.com/sparql> ;
    schema:text """PREFIX : <https://substack.com/app-link/post?publication_id=594665&post_id=216405849#>
PREFIX schema: <http://schema.org/>
SELECT ?termIri ?term ?definition
WHERE {
  GRAPH <https://substack.com/app-link/post?publication_id=594665&post_id=216405849> {
    :glossarySection schema:hasDefinedTerm ?termIri .
    ?termIri a schema:DefinedTerm ;
             schema:name ?term ;
             schema:description ?definition .
  }
}
ORDER BY ?term"""@en .

:sparql-type-summary a schema:SoftwareSourceCode ;
    schema:codeSampleType "SELECT query"@en ;
    schema:description "Counts entities in the companion named graph by rdf:type. Default query for the SPARQL workbench."@en ;
    schema:isPartOf :sparqlSection ;
    schema:name "Entity type summary"@en ;
    schema:programmingLanguage "SPARQL"@en ;
    schema:target <https://linkeddata.uriburner.com/sparql> ;
    schema:text """PREFIX schema: <http://schema.org/>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
SELECT ?typeIri (SAMPLE(?typeLabel) AS ?type) (COUNT(?s) AS ?count)
WHERE {
  GRAPH <https://substack.com/app-link/post?publication_id=594665&post_id=216405849> {
    ?s a ?typeIri .
    OPTIONAL { ?typeIri rdfs:label ?typeLabel }
  }
}
GROUP BY ?typeIri
ORDER BY DESC(?count)"""@en .

<https://businessengineering.ai#this> a schema:Organization ;
    schema:description "Publication of Gennaro Cuofano; its Agenting platform hosts Jev for executive members."@en ;
    schema:identifier "https://businessengineering.ai"@en ;
    schema:isPartOf :coreEntities ;
    schema:name "The Business Engineer"@en ;
    schema:url <https://businessengineering.ai> .

<https://substack.com/@thebusinessengineer#this> a schema:Person ;
    schema:description "Author of the article and publisher of The Business Engineer."@en ;
    schema:identifier "https://substack.com/@thebusinessengineer"@en ;
    schema:isPartOf :coreEntities ;
    schema:name "Gennaro Cuofano"@en ;
    schema:url <https://substack.com/@thebusinessengineer> .

:a1 a schema:Answer ;
    schema:isPartOf :faqSection ;
    schema:text "Jev is TypeSafe's decision-native model, introduced in early access on September 15, 2026. Rather than building another conversational assistant, TypeSafe designed Jev to return structured decisions and probabilities that software can consume directly, through three core primitives: Choice, Noul, and Score. Its stated training objective is calibration: making the numbers attached to decisions reflect how often those decisions are right. The useful way to think about Jev is not as an autonomous agent, but as a decision component inside a larger agentic system — Jev supplies the judgment, and the harness decides what happens next."@en .

:a10 a schema:Answer ;
    schema:isPartOf :faqSection ;
    schema:text "The most likely answer is not always the economically correct action: the correct threshold depends on the probability of error, the cost of that error, the cost of human review, and how reversible the decision is. In the article's simplified examples, if escalating unnecessarily costs 1 unit while missing a genuinely urgent case costs 9 units, escalation becomes worthwhile once the probability of urgency exceeds 10%. For automation: with a $2 human-review cost, a $10 error cost implies automating above roughly 80% confidence, a $100 error cost raises the threshold to about 98%, and a $10,000 error cost raises it to roughly 99.98%. There is no universal confidence threshold for automation — 'automate everything above 90%' makes little sense without knowing what happens when the system is wrong."@en .

:a11 a schema:Answer ;
    schema:isPartOf :faqSection ;
    schema:text "A trustworthy probability is useful, but it cannot run a business process. A model can report 98% confidence that a transaction looks legitimate without telling you whether the payment API should execute, whether the customer record is current, whether the action is reversible, or whether company policy allows the system to act. The model supplies the judgment; the harness turns that judgment into governed execution — authoritative context, explicit permissions, allowed actions, approval rules, failure handling, recovery mechanisms, and a record of what happened. Reliability also compounds across steps: ten decisions each 99% reliable yield only about 90.4% end-to-end reliability even under generous independence assumptions. A reliable component is valuable; a reliable workflow still has to be engineered."@en .

:a12 a schema:Answer ;
    schema:isPartOf :faqSection ;
    schema:text "The operational loop handles the individual decision: prediction, policy, action, result — the model predicts, the system applies policy, executes an allowed action, and checks what happened next. The measurement loop watches the system over time: outcome, audit, calibration, drift detection, updated policy or model — it samples decisions, collects outcomes, measures calibration and error rates, and changes thresholds, policies, or models when performance deteriorates. The measurement loop must also audit a sample of high-confidence automated decisions, not only the cases already escalated to humans, and the system must maintain a continuous connection between prediction, action, and observed consequence, because the world changes."@en .

:a13 a schema:Answer ;
    schema:isPartOf :faqSection ;
    schema:text "Start with one bounded decision where the outcome can be observed, examples occur often enough to measure performance, the available actions are clear, and there is a practical fallback. Then test the prediction (accuracy, reliability of probabilities, sensitivity to wording and option order — one test found reversing option order moved the leading probability from roughly 0.85 to 0.95 — behavior near the automation threshold), the policy (which mistakes matter most, what may be automated, what still requires approval), the workflow (correct action executed, permissions enforced, duplicates handled safely, recovery), unattended execution (shadow mode on held-out cases first, then continued auditing of automated decisions after launch), and the economics (inference, remaining review, monitoring, maintenance, remediation, and the cost of errors). A deployment has earned automation when a defined slice of work runs with less human effort, acceptable outcomes, and risk inside an agreed boundary. A separate experiment on 108 claims found similar aggregate calibration errors for Jev and two conversational models — too small a sample to settle the question, but a reminder that ordinary language models are not automatically incapable of producing useful probability estimates."@en .

:a14 a schema:Answer ;
    schema:isPartOf :faqSection ;
    schema:text "No. The author states: 'To be clear, I have no affiliation with TypeSafe AI or Jev. As usual, I cover what I think is important not because it is the loudest news of the week, but because it may reveal where the industry is moving next.'"@en .

:a2 a schema:Answer ;
    schema:isPartOf :faqSection ;
    schema:text "Jev was built by TypeSafe, whose founder Diogo Almeida was a co-author of the InstructGPT paper. TypeSafe introduced Jev in early access on September 15, 2026, with the stated ambition of building an intelligence primitive for software rather than another chatbot. The article's author states he has no affiliation with TypeSafe AI or Jev."@en .

:a3 a schema:Answer ;
    schema:isPartOf :faqSection ;
    schema:text "RLCD is TypeSafe's training approach for Jev, designed around one idea: produce probabilities that software can use directly. Instead of optimizing for responses people prefer, RLCD optimizes the match between the model's stated probabilities and observed outcomes — so that a reported 0.90 means the decision is right about 90% of the time."@en .

:a4 a schema:Answer ;
    schema:isPartOf :faqSection ;
    schema:text "Choice: select among defined alternatives. Noul: return the probability of a yes-or-no proposition. Score: evaluate something against an ordered scale. Several questions can be sent in the same call, each evaluated against the same underlying state. For example, a support ticket reading 'My payouts have failed three times, and the bank says everything is fine.' might return Payments: 0.91, Account support: 0.06, Other: 0.03, and Urgent escalation: 0.42 — and each number can drive a different action under the company's policy."@en .

:a5 a schema:Answer ;
    schema:isPartOf :faqSection ;
    schema:text "RLHF optimizes for responses people prefer, but a preferred answer is not necessarily a true one, an economically best decision, or a trustworthy probability. Poorly balanced feedback can encourage agreement, reassurance, or confidence the evidence does not justify — illustrated by OpenAI's account of its 2025 GPT-4o sycophancy problem. The stronger claim is narrower: training a model to produce responses people prefer does not, by itself, make its uncertainty trustworthy enough to govern unattended decisions. That said, RLHF also improved instruction-following and truthfulness, and human feedback has trained agents outside conversational settings; human involvement in training is not the same as requiring a human to supervise every decision in production."@en .

:a6 a schema:Answer ;
    schema:isPartOf :faqSection ;
    schema:text "Calibration asks: when the model says it is 90% confident, is it actually right about 90% of the time? If across many comparable cases where it says 0.90 it turns out right about 90% of the time, that confidence is well calibrated — the number has been checked against reality. But calibration is not accuracy: a model answering 0.50 on an evenly split yes-or-no task could be perfectly calibrated yet useless. And calibration works across groups of predictions, not individual cases: a model perfectly calibrated at 90% can still be wrong on the very next case. Calibration does not eliminate mistakes; it makes the risk measurable enough that the system can decide what to do with them — a 99.5% prediction might qualify for automatic execution, an 85% prediction might trigger another check, and a 55% prediction might go directly to a human. Early tests reported an average calibration gap of roughly three percentage points across 1,200 general-knowledge questions; on generated arithmetic tasks, confidence fell as accuracy fell — around 87% accuracy with 0.83 average confidence on three-digit multiplication, and 32% accuracy with 0.30 confidence on harder two-step word problems."@en .

:a7 a schema:Answer ;
    schema:isPartOf :faqSection ;
    schema:text "They answer three different questions. Preference asks: which response would a person prefer — useful for instruction-following, tone, usefulness, and interaction quality, but a preferred answer is not necessarily a true one. Correctness asks: did the system get the answer right — works especially well where the result can be checked directly, as in mathematics, code, or other tasks with clear verifiers. Calibration asks: does the model's stated confidence match how often it is actually right. These are not competing approaches; a strong AI system may need all three."@en .

:a8 a schema:Answer ;
    schema:isPartOf :faqSection ;
    schema:text "Two things. The meta-harness: not just one agent, but the layer that coordinates many agents, models, tools, permissions, context, and execution environments — the important product becomes the system that makes agents useful together. And the redesign of agentic interfaces: human-friendly chat remains useful for expressing intent and controlling important actions, but the machine-facing layer underneath cannot depend on conversational outputs when hundreds or thousands of agent tasks run in parallel. The chat interface was built for humans; the next execution layer is being built for machines talking to machines."@en .

:a9 a schema:Answer ;
    schema:isPartOf :faqSection ;
    schema:text "Forced loops are human checkpoints that remain because the system cannot yet be trusted to act reliably on its own — this category should shrink as the evidence improves. Chosen loops are checkpoints that remain because the decision requires judgment, accountability, values, or explicit authority — this category may remain permanently. The goal of automation is therefore not zero humans, but zero unnecessary review: remove unnecessary case-by-case review where the evidence supports it, while preserving human authority where the decision genuinely requires it."@en .

:diogo-almeida a schema:Person ;
    schema:description "Founder of TypeSafe and co-author of the InstructGPT paper."@en ;
    schema:founder <https://typesafe.ai#this> ;
    schema:isPartOf :coreEntities ;
    schema:name "Diogo Almeida"@en ;
    owl:sameAs <https://x.com/CompleteSkeptic#this> .

:jev a schema:SoftwareApplication ;
    schema:datePublished "2026-09-15"^^xsd:date ;
    schema:description "TypeSafe's decision-native model, introduced in early access on September 15, 2026. It returns structured decisions and probabilities that software can consume directly — Choice, Noul, and Score primitives — and is trained with Reinforcement Learning for Calibrated Decisions (RLCD). It is best understood as a decision component inside a larger agentic system, not as an autonomous agent."@en ;
    schema:isPartOf :coreEntities ;
    schema:name "Jev"@en ;
    schema:producer <https://typesafe.ai#this> .

:q1 a schema:Question ;
    schema:acceptedAnswer :a1 ;
    schema:isPartOf :faqSection ;
    schema:name "What is Jev?"@en .

:q10 a schema:Question ;
    schema:acceptedAnswer :a10 ;
    schema:isPartOf :faqSection ;
    schema:name "How do error economics set the automation threshold?"@en .

:q11 a schema:Question ;
    schema:acceptedAnswer :a11 ;
    schema:isPartOf :faqSection ;
    schema:name "Why does calibration not remove the need for a harness?"@en .

:q12 a schema:Question ;
    schema:acceptedAnswer :a12 ;
    schema:isPartOf :faqSection ;
    schema:name "What are the operational loop and the measurement loop?"@en .

:q13 a schema:Question ;
    schema:acceptedAnswer :a13 ;
    schema:isPartOf :faqSection ;
    schema:name "What should a serious deployment test before automating a decision?"@en .

:q14 a schema:Question ;
    schema:acceptedAnswer :a14 ;
    schema:isPartOf :faqSection ;
    schema:name "Does the author have an affiliation with TypeSafe or Jev?"@en .

:q2 a schema:Question ;
    schema:acceptedAnswer :a2 ;
    schema:isPartOf :faqSection ;
    schema:name "Who built Jev, and when did it become available?"@en .

:q3 a schema:Question ;
    schema:acceptedAnswer :a3 ;
    schema:isPartOf :faqSection ;
    schema:name "What is Reinforcement Learning for Calibrated Decisions (RLCD)?"@en .

:q4 a schema:Question ;
    schema:acceptedAnswer :a4 ;
    schema:isPartOf :faqSection ;
    schema:name "What are Jev's three core primitives?"@en .

:q5 a schema:Question ;
    schema:acceptedAnswer :a5 ;
    schema:isPartOf :faqSection ;
    schema:name "Why is RLHF not enough for automation?"@en .

:q6 a schema:Question ;
    schema:acceptedAnswer :a6 ;
    schema:isPartOf :faqSection ;
    schema:name "What does calibration mean for an AI model?"@en .

:q7 a schema:Question ;
    schema:acceptedAnswer :a7 ;
    schema:isPartOf :faqSection ;
    schema:name "How do preference, correctness, and calibration differ?"@en .

:q8 a schema:Question ;
    schema:acceptedAnswer :a8 ;
    schema:isPartOf :faqSection ;
    schema:name "What does the author predict will define 2027?"@en .

:q9 a schema:Question ;
    schema:acceptedAnswer :a9 ;
    schema:isPartOf :faqSection ;
    schema:name "What is the difference between a forced loop and a chosen loop?"@en .

:step1 a schema:HowToStep ;
    schema:isPartOf :howtoSection ;
    schema:name "Test the prediction"@en ;
    schema:position 1 ;
    schema:text "Does the model make the right call? Are its probabilities reliable? Do harmless changes in wording or option order move the result? What happens when context is missing? Pay particular attention to cases close to the automation threshold."@en .

:step2 a schema:HowToStep ;
    schema:isPartOf :howtoSection ;
    schema:name "Test the policy"@en ;
    schema:position 2 ;
    schema:text "Decide which mistakes matter most, which cases the system is allowed to automate, which still require approval, and what should happen when confidence is too low."@en .

:step3 a schema:HowToStep ;
    schema:isPartOf :howtoSection ;
    schema:name "Test the workflow"@en ;
    schema:position 3 ;
    schema:text "A correct prediction is not enough. Check whether the right action is actually executed, whether permissions are enforced, whether duplicate requests are handled safely, and whether the process can recover when something downstream fails."@en .

:step4 a schema:HowToStep ;
    schema:isPartOf :howtoSection ;
    schema:name "Test unattended execution"@en ;
    schema:position 4 ;
    schema:text "Before letting the system act freely, run it in shadow mode on held-out cases. After launch, continue auditing a sample of automated decisions rather than reviewing only the uncertain ones."@en .

:step5 a schema:HowToStep ;
    schema:isPartOf :howtoSection ;
    schema:name "Test the economics"@en ;
    schema:position 5 ;
    schema:text "Include inference, remaining human review, monitoring, maintenance, remediation, and the cost of errors. Compare the total with both the existing process and simpler alternatives."@en .

:term-choice a schema:DefinedTerm ;
    schema:description "Jev primitive: select among defined alternatives."@en ;
    schema:inDefinedTermSet :glossarySection ;
    schema:isPartOf :glossarySection ;
    schema:name "Choice"@en .

:term-chosen-loop a schema:DefinedTerm ;
    schema:description "A human checkpoint that remains because the decision requires judgment, accountability, values, or explicit authority. This category may remain permanently."@en ;
    schema:inDefinedTermSet :glossarySection ;
    schema:isPartOf :glossarySection ;
    schema:name "Chosen loop"@en .

:term-decision-native-model a schema:DefinedTerm ;
    schema:description "A model designed around decisions from the start — structured outputs, probabilities, permissions, thresholds — so software can act on its output directly, rather than a conversational model imitating that behavior after the fact."@en ;
    schema:inDefinedTermSet :glossarySection ;
    schema:isPartOf :glossarySection ;
    schema:name "Decision-native model"@en .

:term-forced-loop a schema:DefinedTerm ;
    schema:description "A human checkpoint that remains because the system cannot yet be trusted to act reliably on its own. This category should shrink as the evidence improves."@en ;
    schema:inDefinedTermSet :glossarySection ;
    schema:isPartOf :glossarySection ;
    schema:name "Forced loop"@en .

:term-harness a schema:DefinedTerm ;
    schema:description "The operating layer around a decision model that controls context, permissions, sequencing, recovery, and verification. The model supplies the judgment; the harness turns that judgment into governed execution."@en ;
    schema:inDefinedTermSet :glossarySection ;
    schema:isPartOf :glossarySection ;
    schema:name "Harness"@en .

:term-jev a schema:DefinedTerm ;
    schema:description "TypeSafe's decision-native model for software: an intelligence primitive that returns structured decisions and probabilities (Choice, Noul, Score) rather than free-form text."@en ;
    schema:inDefinedTermSet :glossarySection ;
    schema:isPartOf :glossarySection ;
    schema:name "Jev"@en .

:term-measurement-loop a schema:DefinedTerm ;
    schema:description "Watches the system over time: samples decisions, collects outcomes, measures calibration and error rates, looks for drift, and changes thresholds, policies, or models when performance deteriorates."@en ;
    schema:inDefinedTermSet :glossarySection ;
    schema:isPartOf :glossarySection ;
    schema:name "Measurement loop"@en .

:term-meta-harness a schema:DefinedTerm ;
    schema:description "The author's 2027 bet: not just one agent, but the layer that coordinates many agents, models, tools, permissions, context, and execution environments. The important product becomes the system that makes agents useful together."@en ;
    schema:inDefinedTermSet :glossarySection ;
    schema:isPartOf :glossarySection ;
    schema:name "Meta-harness"@en .

:term-noul a schema:DefinedTerm ;
    schema:description "Jev primitive: return the probability of a yes-or-no proposition."@en ;
    schema:inDefinedTermSet :glossarySection ;
    schema:isPartOf :glossarySection ;
    schema:name "Noul"@en .

:term-operational-loop a schema:DefinedTerm ;
    schema:description "Handles the individual decision: the model makes a prediction, the system applies policy, executes an allowed action, and checks what happened next."@en ;
    schema:inDefinedTermSet :glossarySection ;
    schema:isPartOf :glossarySection ;
    schema:name "Operational loop"@en .

:term-rlcd a schema:DefinedTerm ;
    schema:description "TypeSafe's training approach for Jev, designed around one idea: produce probabilities that software can use directly."@en ;
    schema:inDefinedTermSet :glossarySection ;
    schema:isPartOf :glossarySection ;
    schema:name "Reinforcement Learning for Calibrated Decisions (RLCD)"@en .

:term-score a schema:DefinedTerm ;
    schema:description "Jev primitive: evaluate something against an ordered scale."@en ;
    schema:inDefinedTermSet :glossarySection ;
    schema:isPartOf :glossarySection ;
    schema:name "Score"@en .

:term-seat-anchor a schema:DefinedTerm ;
    schema:description "Per-seat pricing assumes value scales with the number of humans using the software. As more work runs without direct human interaction, the economically relevant unit shifts toward decisions, outcomes, or completed work."@en ;
    schema:inDefinedTermSet :glossarySection ;
    schema:isPartOf :glossarySection ;
    schema:name "Seat anchor"@en .

:term-sycophancy a schema:DefinedTerm ;
    schema:description "Failure mode of human-feedback incentives in which the model becomes excessively agreeable; illustrated by OpenAI's account of its 2025 GPT-4o sycophancy problem."@en ;
    schema:inDefinedTermSet :glossarySection ;
    schema:isPartOf :glossarySection ;
    schema:name "Sycophancy"@en .

:sparqlSection a schema:CreativeWork ;
    schema:description "Query recipes for exploring this knowledge graph once the companion Turtle is loaded into a named graph."@en ;
    schema:hasPart :sparql-calibration-faqs,
        :sparql-glossary-terms,
        :sparql-type-summary ;
    schema:name "SPARQL recipes"@en .

:term-calibration a schema:DefinedTerm ;
    schema:description "Whether a model's stated confidence matches how often it is actually right: when the model says it is 90% confident, it is actually right about 90% of the time across comparable cases. Calibration works across groups of predictions, not individual cases, and is always local to the environment in which it was measured."@en ;
    schema:inDefinedTermSet :glossarySection ;
    schema:isPartOf :glossarySection ;
    schema:name "Calibration"@en .

:term-rlhf a schema:DefinedTerm ;
    schema:description "Training method that combines supervised examples with reinforcement learning guided by human rankings of responses; it turned a text-continuation model into an instruction-following assistant. Human feedback can reward correctness, clarity, and useful caution, but poorly balanced feedback can also encourage agreement or confidence the evidence does not justify."@en ;
    schema:inDefinedTermSet :glossarySection ;
    schema:isPartOf :glossarySection ;
    schema:name "Reinforcement learning from human feedback (RLHF)"@en .

<https://typesafe.ai#this> a schema:Organization ;
    schema:alternateName "TypeSafe AI"@en ;
    schema:description "Company that introduced Jev in early access on September 15, 2026; founded by Diogo Almeida. Official homepage verified as https://typesafe.ai."@en ;
    schema:founder :diogo-almeida ;
    schema:identifier "https://typesafe.ai"@en ;
    schema:isPartOf :coreEntities ;
    schema:name "TypeSafe"@en ;
    schema:url <https://typesafe.ai> .

:claim-compounding-reliability a schema:Claim ;
    schema:description "The article's compounding argument: ten sequential steps at 99% reliability each yield only about 90.4% end-to-end reliability, because errors multiply across chains. Each link's calibration must therefore be measured in its own operating environment — a chain is only as automatable as its weakest link."@en ;
    schema:hasPart :qv-chain-steps,
        :qv-end-to-end-reliability,
        :qv-step-reliability ;
    schema:isPartOf :thesisAnalysisSection ;
    schema:name "Reliability compounds across decision chains"@en ;
    schema:position 3 .

:claim-escalation-insurance a schema:Claim ;
    schema:description "The article prices escalation like insurance: escalating costs 1 unit of human time while a wrong automated action costs 9, so the rational policy escalates whenever the calibrated error rate exceeds 10%. Presented as the author's worked illustration of decision economics, not a TypeSafe product claim."@en ;
    schema:hasPart :qv-escalation-cost,
        :qv-escalation-error-threshold,
        :qv-wrong-action-cost ;
    schema:isPartOf :thesisAnalysisSection ;
    schema:name "Escalation is insurance against the cost of being wrong"@en ;
    schema:position 2 .

:claim-ticket-triage-economics a schema:Claim ;
    schema:description "The article's worked triage: a Payments intent at 0.91 confidence auto-resolves, Account support at 0.06 auto-resolves, Other at 0.03 escalates to a human, and an urgent-escalation flag at 0.42 routes to a person. The author's point: calibrated scores let policy, not prose, decide which cases a human ever sees."@en ;
    schema:hasPart :qv-ticket-account-support,
        :qv-ticket-other,
        :qv-ticket-payments,
        :qv-ticket-urgent ;
    schema:isPartOf :thesisAnalysisSection ;
    schema:name "The support-ticket example shows selective automation in practice"@en ;
    schema:position 4 .

:analysis a schema:Article,
        schema:CreativeWork ;
    schema:about :jev,
        :term-calibration,
        :term-rlhf ;
    schema:abstract "Gennaro Cuofano argues that the ChatGPT breakthrough was making intelligence conversational, but the next frontier is making it reliably actionable: systems whose structured decisions and calibrated probabilities software can act on without a person approving every case. TypeSafe's Jev, a decision-native model trained with Reinforcement Learning for Calibrated Decisions, is examined as an early expression of that direction — returning Choice, Noul, and Score primitives instead of prose. The piece distinguishes preference, correctness, and calibration as three training objectives, shows how error economics set automation thresholds, and reframes oversight as a measurement problem: automation should earn autonomy through evidence, and keep it only while the evidence holds."@en ;
    schema:articleBody "From conversational AI to actionable AI. ChatGPT's breakthrough was making intelligence easy to interact with. The next frontier is making AI reliable enough that software can act on its decisions without requiring a person to approve every case. Assistance and automation have different economics. An assistant makes a person faster. Automation removes the person from selected parts of the workflow, and the economic unit shifts: how much accepted work can the system complete without intervention, within an agreed risk budget, at a sustainable total cost. Preference, correctness, and calibration solve different problems. Preference asks which answer a person would choose. Correctness asks whether the answer satisfied an objective verifier. Calibration asks whether the model's stated confidence matches how often it is actually right. They are complementary. What Jev is trying to build. TypeSafe's Jev is designed less like a chatbot and more like a decision primitive for software, returning structured outputs through Choice, Noul, and Score, trained with Reinforcement Learning for Calibrated Decisions. A probability is not yet a decision. The highest-probability answer is not always the right action; the correct action depends on the cost of being wrong, the cost of review, and how reversible the decision is. Calibration is useful, not magical. A calibrated model can still be wrong, and calibration only matters if the probabilities have been tested against real outcomes on the task where the system will operate. The harness still determines whether the system works. The model supplies a judgment; the harness turns that judgment into governed execution. The human loop moves. Human attention moves from checking every case toward setting policies, handling exceptions, auditing automated decisions, monitoring drift, and improving the system. Automation needs two loops: the operational loop (prediction, policy, action, result) and the measurement loop (outcome, audit, calibration, drift detection, updated policy or model). The economics change with the loop: product reprices toward completed decisions, governance toward evidence and thresholds, and work toward exceptions and system design. Bottom line: the breakthrough will not be a model that merely emits probabilities. It will be an operating system that knows when to act, when to ask, and how to prove that the distinction is working."@en ;
    schema:author <https://substack.com/@thebusinessengineer#this> ;
    schema:datePublished "2026-09-19"^^xsd:date ;
    schema:description "A thesis on moving AI from conversational assistance to decision-native automation, using TypeSafe's Jev as the central case study."@en ;
    schema:hasPart :entityIndex,
        :faqSection,
        :glossarySection,
        :howtoSection,
        :thesisAnalysisSection,
        :trainingObjectiveOntology ;
    schema:name "Jev & Beyond Human-in-the-Loop AI"@en ;
    schema:publisher <https://businessengineering.ai#this> ;
    schema:relatedLink <https://businessengineer.ai/p/beyond-human-in-the-loop-ai>,
        <https://businessengineering.ai/agent>,
        <https://businessengineering.ai/tools/genesis>,
        <https://substack.com/@thebusinessengineer> ;
    schema:url <https://substack.com/app-link/post?publication_id=594665&post_id=216405849> ;
    prov:wasGeneratedBy <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/kg-generator#this>,
        <https://github.com/OpenLinkSoftware/ai-agent-skills/tree/main/rdf-infographic-skill#this> .

:howtoSection a schema:HowTo ;
    schema:description "The article's five-test protocol for earning automation on one bounded decision."@en ;
    schema:hasPart :step1,
        :step2,
        :step3,
        :step4,
        :step5 ;
    schema:isPartOf :analysis ;
    schema:name "What a Serious Deployment Would Test"@en ;
    schema:step :step1,
        :step2,
        :step3,
        :step4,
        :step5 .

:claim-automation-threshold-ladder a schema:Claim ;
    schema:description "The article's core unit-economics formula: automate only when calibrated confidence exceeds 1 minus review cost divided by error cost. With a $2 review cost, a $10 error sets the bar near 80%, a $100 error near 98%, and a $10,000 error near 99.98%. Framed as the author's thesis, not a measured result — the threshold is only as good as the calibration behind it."@en ;
    schema:hasPart :qv-error-cost-high,
        :qv-error-cost-low,
        :qv-error-cost-mid,
        :qv-review-cost,
        :qv-threshold-80,
        :qv-threshold-98,
        :qv-threshold-9998 ;
    schema:isPartOf :thesisAnalysisSection ;
    schema:name "Automation thresholds are priced by error economics"@en ;
    schema:position 1 .

:thesisAnalysisSection a schema:CreativeWork ;
    schema:abstract "Gennaro Cuofano's business-model thesis: calibration turns a model's confidence into a decision primitive, and that changes the unit economics of automation. When a calibrated score can be trusted, review stops being per-case human labor and becomes priced, selective, statistical oversight — governed by the ratio of review cost to error cost. The article prices this explicitly: with a $2 review cost, errors costing $10, $100, or $10,000 set automation thresholds near 80%, 98%, and 99.98%. Escalation becomes insurance against being wrong, reliability compounds across decision chains, and the human-in-the-loop seat becomes a cost line that shrinks as calibrated evidence accumulates. Framed throughout as the author's thesis and worked illustrations — not as TypeSafe product claims or verified market results."@en ;
    schema:hasPart :claim-automation-threshold-ladder,
        :claim-compounding-reliability,
        :claim-earn-autonomy-pricing,
        :claim-escalation-insurance,
        :claim-priced-oversight,
        :claim-seat-anchor-cost-line,
        :claim-ticket-triage-economics ;
    schema:image """<svg xmlns="http://www.w3.org/2000/svg" width="680" height="336" viewBox="0 0 680 336" role="img" aria-label="Automation threshold ladder: with a $2 review cost, error costs of $10, $100, and $10,000 set automation thresholds near 80 percent, 98 percent, and 99.98 percent">
<rect x="0" y="0" width="680" height="336" rx="12" fill="#ffffff" stroke="#e5e7eb"/>
<text x="32" y="44" font-family="system-ui, sans-serif" font-size="20" font-weight="700" fill="#111827">Automation-threshold ladder</text>
<text x="32" y="70" font-family="system-ui, sans-serif" font-size="14" fill="#6b7280">Review cost fixed at $2 - automate only above the calibrated threshold</text>
<rect x="32" y="92" width="616" height="40" rx="6" fill="#1f4e79"/>
<text x="52" y="118" font-family="system-ui, sans-serif" font-size="14" font-weight="600" fill="#ffffff">Error cost</text>
<text x="360" y="118" font-family="system-ui, sans-serif" font-size="14" font-weight="600" fill="#ffffff">Automate when calibrated confidence is above</text>
<rect x="32" y="136" width="616" height="46" fill="#f9fafb"/>
<text x="52" y="165" font-family="system-ui, sans-serif" font-size="16" font-weight="700" fill="#111827">$10</text>
<text x="360" y="165" font-family="system-ui, sans-serif" font-size="16" font-weight="700" fill="#1f4e79">~80%</text>
<rect x="32" y="182" width="616" height="46" fill="#ffffff"/>
<text x="52" y="211" font-family="system-ui, sans-serif" font-size="16" font-weight="700" fill="#111827">$100</text>
<text x="360" y="211" font-family="system-ui, sans-serif" font-size="16" font-weight="700" fill="#1f4e79">~98%</text>
<rect x="32" y="228" width="616" height="46" fill="#f9fafb"/>
<text x="52" y="257" font-family="system-ui, sans-serif" font-size="16" font-weight="700" fill="#111827">$10,000</text>
<text x="360" y="257" font-family="system-ui, sans-serif" font-size="16" font-weight="700" fill="#1f4e79">~99.98%</text>
<text x="32" y="302" font-family="system-ui, sans-serif" font-size="14" font-style="italic" fill="#4b5563">threshold = 1 - reviewCost / errorCost</text>
</svg>"""@en ;
    schema:isPartOf :analysis ;
    schema:name "Thesis: Business Model & Unit Economics"@en ;
    schema:position 1 .

:trainingObjectiveOntology a owl:Ontology ;
    schema:description "Lightweight ontology capturing the article's three training objectives — preference, correctness, calibration — as a class with instances and descriptive properties."@en ;
    schema:hasPart :TrainingObjective,
        :answersQuestion,
        :calibrationObjective,
        :correctnessObjective,
        :keyLimitation,
        :keyStrength,
        :preferenceObjective ;
    schema:identifier "https://substack.com/app-link/post?publication_id=594665&post_id=216405849"@en ;
    schema:isPartOf :analysis ;
    schema:name "Training Objective Ontology"@en .

:coreEntities a schema:CreativeWork ;
    schema:description "People, organizations, products, and statements discussed in the article."@en ;
    schema:hasPart <http://dbpedia.org/resource/ChatGPT>,
        <http://dbpedia.org/resource/OpenAI>,
        <https://businessengineering.ai#this>,
        <https://substack.com/@thebusinessengineer#this>,
        :agenting-platform,
        :diogo-almeida,
        :disclosure,
        :genesis,
        :gpt-3-5,
        :gpt-4o,
        :instructgpt,
        :jev,
        :openclaw,
        <https://typesafe.ai#this> ;
    schema:name "Core entities"@en .

:faqSection a schema:FAQPage ;
    schema:description "Questions and answers covering the article's claims about Jev, calibration, RLHF, automation economics, and deployment."@en ;
    schema:hasPart :a1,
        :a10,
        :a11,
        :a12,
        :a13,
        :a14,
        :a2,
        :a3,
        :a4,
        :a5,
        :a6,
        :a7,
        :a8,
        :a9,
        :q1,
        :q10,
        :q11,
        :q12,
        :q13,
        :q14,
        :q2,
        :q3,
        :q4,
        :q5,
        :q6,
        :q7,
        :q8,
        :q9 ;
    schema:isPartOf :analysis ;
    schema:mainEntity :q1,
        :q10,
        :q11,
        :q12,
        :q13,
        :q14,
        :q2,
        :q3,
        :q4,
        :q5,
        :q6,
        :q7,
        :q8,
        :q9 ;
    schema:name "Frequently asked questions"@en .

:glossarySection a schema:DefinedTermSet,
        skos:ConceptScheme ;
    schema:description "Terms introduced or defined in the article."@en ;
    schema:hasDefinedTerm :term-calibration,
        :term-choice,
        :term-chosen-loop,
        :term-decision-native-model,
        :term-forced-loop,
        :term-harness,
        :term-jev,
        :term-measurement-loop,
        :term-meta-harness,
        :term-noul,
        :term-operational-loop,
        :term-rlcd,
        :term-rlhf,
        :term-score,
        :term-seat-anchor,
        :term-sycophancy ;
    schema:hasPart :term-calibration,
        :term-choice,
        :term-chosen-loop,
        :term-decision-native-model,
        :term-forced-loop,
        :term-harness,
        :term-jev,
        :term-measurement-loop,
        :term-meta-harness,
        :term-noul,
        :term-operational-loop,
        :term-rlcd,
        :term-rlhf,
        :term-score,
        :term-seat-anchor,
        :term-sycophancy ;
    schema:isPartOf :analysis ;
    schema:name "Glossary"@en .