Tvijo wiki
Catalog

Topics

Tvision: a task language for Tvijo AIOS — RFC v0.1

Tvision is a proposed task language for Tvijo AIOS. This reference explains typed inputs, scoped permissions, shared budgets, execution evidence, cited customer answers and measurable product development, with a vocabulary, command proposals and seven workflow examples.

🎯 For AI platform engineers, product builders and operators

📚 You will learn
  • Read the proposed vocabulary, commands and workflow examples
  • Connect one task model to three generations of Tvijo AIOS
  • Design budgets, permissions, citations and consent
  • Measure the cost and quality of accepted results

Research and decisions: 2026-11-07 UTC snapshot

Model names are quoted at the site owner's request dated 2026-11-07. Owner's required notice: «имена моделей приведены по требованию владельца площадки от 2026-11-07».

A task language ties goals, constraints and verifiable results together before execution. The research covers the contract, executor boundaries, publication and council rules. Measurements cover the integer threshold and agreement of stars with source artifacts; speed, profit, runtime quality and production effects have not been measured.

Research

The 2026-11-07 cross-review and re-rating assess evidence, not model votes. Model labels are quoted at the site owner’s request dated 2026-11-07: Codex o61s, Cline co61s, and Sonnet 5.5. The re-rating notes that co61s is not a registry code. It confirms the 350-person threshold is ceil(350 × 0.51) = 179, and that an architecture boundary does not prove integration. A plan review also does not establish runtime readiness or publication.

Decision

Treat the roadmap as a staged plan with explicit gates. Any mandatory insufficient blocks; quorum is checked separately; a majority never auto-accepts. T3 validates against its own local plan schema and does not depend on dispatch. T3b is NOT_RUN until ai_os/dispatch is merged to main. The Wiki reference route remains conditional: retain SPEC-252, require the reference-class review and operator preflight, and verify both language routes before any publication decision.

When this does not work

Do not infer acceptance from stars or majority alone when required evidence, quorum, model identity, verification, or cost is unknown. Keep unknown values unknown. A plan-level result cannot stand in for an implementation or publication check.

What has not been done

No runtime, dispatch integration, dispatch merge check, vote execution or publication is claimed here. Preflight evidence is recorded separately.

Any insufficient on a mandatory criterion blocks acceptance. ceil(membership × 0.51) = ceil(350 × 0.51) = 179; quorum is separate. Majority voting never triggers automatic acceptance.

Two separate star tables

Scale: 5 means the cited artifact was checked and fully confirmed; 4 partially checked; 3 a substantively correct conclusion with weak or mismatched evidence; 2 an opinion without a verifiable artifact; 1 a contradiction of checked evidence. These assess Q1–Q5 verdicts, not general model quality. A dash means no rating.

Rating by ds41f on the declared scale

Q o61s co61s Sonnet 5.5
Q1 ★★★★★ ★ —
Q2 ★★★★ ★★★★ ★★★★
Q3 ★★★★ ★★ ★★★★
Q4 ★★★★★ ★★ ★★★★
Q5 ★★★★ ★★★★ —

Source: CROSS_REVIEW_RU__ds41f.md, §3 (2026-11-07).

Rating by o61s on the same scale

Q o61s co61s ds41f
Q1 ★★★★★ ★ ★★★★
Q2 ★★★★★ ★★★★★ ★★★★★
Q3 ★★★★ ★★★ ★★★★
Q4 ★★★★★ ★ ★★★★★
Q5 ★★★★★ ★★★★ ★★★★★

Source: RATING_BY_SOL_20261107__o61s.md (2026-11-07).

Q1 covers plan consistency and feasibility; Q2 one scheduler and one ledger; Q3 legality of the described publication path; Q4 verification and human sign-off; Q5 honest disclosure of gaps. AgentPeople and the council do not replace verification. Disagreements remain visible. Stars are never averaged or substituted for deterministic checks.

Roadmap

The ceilings below are historical phase proposals, not spending authority. This iteration has usd_max: 0; no paid APIs are called.

Phase Goal Level Acceptance Blocker usd_max
T0 Register the R2 initiative L0 One entry per registry; no-shrink guard passes Stop on any hash mismatch; handling of four ignored file types needs the stated archive/git decision. 0
T0b Reconcile DSHREM P0: PRs 165/173/174/178 and local commit 0c783789. L2 Record file overlaps, dated doctor output, and native_meter spent/held/pending reconciliation; unknown remains unknown. Stop if another writer is editing scripts/dshrem_cli.py. 0
T1 Build offline validate and plan for tvision/packet-plan-v0.1. L1 Accepted SPEC; validation and planning are deterministic, have no side effects, and pass the named checks. The Tvision SPEC must be accepted before implementation. 0.2
T2 Define canonical IR, hashing, and integer micro-USD handling. L1 Key order does not affect the plan hash; goal and budget changes do; 0.20 converts to 200000 micro-USD; invalid numeric forms are rejected without floats. Depends on T1; do not decide budgets with floating-point values. 0.2
T3 Compile Tvision documents to twision/v0.1 plans. L2 Plan passes local plan_schema.json; verify and 0 < max_usd ≤ 1 Unknown type or schema violation; runtime deferred to T3b 0.2
T3b Check the compiler against the canonical dispatch interface. L2 ai_os.dispatch.load_plan; runtime dry-run; NOT_RUN precondition: ai_os/dispatch merged to main; dispatch_in_main: false 0
T4 Audit executor capabilities and evidence. L2 Each executor/capability/evidence row is marked PASS or NOT_RUN with a reason. Missing dated evidence leaves the row NOT_RUN. 0
T5 Add budget caps, receipts, and uncertainty handling. L2 Parallel work respects the shared cap; unknown cost is not zero; lost replies are not blindly retried; cancel_requested differs from cancelled; operator reconciliation is named. Depends on T3 and T4; no second money ledger. 0.2
T6 Expose consistent task surfaces across CLI, TvijoCode, TvijoTerm, VSIX, and browser. L2 CLI reads the existing dispatch journal; all surfaces use one task JSON; TvijoTerm rejects foreign Origin or missing X-Tvijoterm. Depends on T5; surface and origin checks remain to be implemented and evidenced. 0.2
T7 Build the RemDesk/RootRemDesk adapter. L2 Unknown commands are rejected before invocation; JSONL audit has a hash chain; STOP revokes access on the next call. Depends on T4; undeclared capabilities must not be invoked. 0.2
T8 Prepare one scoped packet and allowlist per product. L2 Each listed product has its own packet and allowlist. Depends on T5; do not combine products into one packet. 0.2
T9 Prepare the reference-class RFC publication path. L3 Approve a new reference SPEC without weakening SPEC-252; keep vendor names out of Wiki; validate both EN/RU routes and examples; run preflight under RemDesk and require operator digest approval. Requires operator decision and reference SPEC; current page is reported 404, approved digest is absent, legacy check fails, and remote gate behavior is unknown. No publication is established. 0
T10 Create a catalog of role templates as Tvision documents. L2 Each template has verify and explicit prohibitions; templates grant no new permissions. Depends on T5; no template may enable payment or publication without a human. 0
T11 Build demand-delta analysis from existing SEO sources. L2 Analysis steps 2–6 make zero paid calls; fixed snapshots reproduce results; missing values remain NULL; preregister an experiment of one niche, one market, at least two snapshots, and 20 predictions with the stated outcome criteria. Step 6 depends on T3; experiment requires snapshots, preregistered metrics, and cost evidence. 0
T12 Build an edge-offline profile and append-only sync. L2 Validate and plan work with network disabled; effect_id prevents duplicate actions; local RAG is reproducible by path and SHA-256; two-node sync reports conflicts; run the specified 20-task experiment. Depends on T1–T3; local inference and libp2p/CRDT/Raft are reported missing. 0
T13 Define AgentPeople decisions with human quorum and weighted agents. L2 For 350 participants the threshold is 179, separate from quorum; any mandatory insufficient blocks; agent weight is capped at 50%; majority never auto-accepts; protected harm, evidence-backed refutation, self-votes, and deterministic audit rules are enforced. Depends on T4; missing human quorum or required evidence blocks regardless of agent majority. 0
T14 Generate an artifact-backed Wiki timeline for AIOS and Tvijo. L1 Every rendered row has an artifact; dates match artifacts; rebuild is deterministic; superseded/culled entries retain reasons; public output uses model codes and command-derived counts. Rows without evidence, unsupported events, vendor names in public output, or manually entered counts block rendering. 0
T15 Add an operations minimum: restore drill, volume forecast, and cron report. L2 Restore drill has a receipt; 30-day volume forecast uses actual data; weekly cron report shows missed runs; unknown-cost alert is tested. Requires actual dated evidence; backups must not be deleted to create space. 0
T16 Measure cost per accepted task. L2 A 20-task cohort reconciles to 20 statuses; numerator includes all attempts and human time; unknown cost remains unknown; three-product baseline has date and artifact. Depends on T5; a successful attempt alone or zero substituted for unknown blocks the calculation. 0
T17 Prepare the legal and product minimum. L2 Draft terms, privacy, and refunds; define channel response hours; record a dated impressions/clicks baseline. Requires operator decision; public launch is blocked until baseline exists; FinEdg materials require the non-investment-advice statement. 0

⚠️ When this does not work

Unsupported types, unknown fields, a missing verify, or insufficient evidence on any mandatory criterion cause refusal. Model votes cannot remove that block. The article remains an RFC; no Tvision runtime is implemented or verified.

What has not been done

Publication is gated by the operator: preflight neither publishes nor approves a SHA. ai_os/dispatch is absent from main; dispatch_in_main: false. t3_end_to_end: NOT_RUN (precondition: dispatch merged to main). Runtime, live execution, T2 IR, transport/money integration and T4–T17 acceptance are not delivered. Model ratings do not replace deterministic verification.


Status: RFC v0.1 — proposed specification. This document describes a proposed language model, interfaces, and implementation criteria. The fields, CLI commands, adapter names, states, and examples below do not establish that a corresponding runtime has been implemented, installed, or verified. Revision date: 2026-11-06 UTC (2026-11-07 Kyiv).

Tvision is a proposed declarative task language for Tvijo AIOS. It connects a goal, data, authority, a budget, an execution plan, and evidence of the result. Its first useful deliverable is a task that can be checked before execution, run within defined limits, and presented with artifacts and receipts.

1. What we are building

A Tvision document answers practical questions:

  • What result is required, and what will make it acceptable?
  • Which data, repositories, sources, and tools may be used?
  • How much time, money, and computing capacity may be consumed?
  • Which steps depend on each other?
  • Which actions are already authorized, and which require additional authority?
  • Where are the result, sources, checks, and execution receipt?

RFC v0.1 proposes starting with a safe subset of YAML 1.2 and an equivalent JSON representation. Boolean literals are true and false; date and exact decimal values are passed without implicit type changes. A dedicated .tvision syntax can follow once the task model is stable. This lets us test the language's value before building a separate compiler, language server, and package ecosystem.

The minimum implementation consists of a validator, a planner, a canonical intermediate representation—IR, an adapter to AIOS execution, and a result inspection interface. It should use the existing AIOS BudgetGuard and financial ledger rather than introduce another independent ledger.

This article does not confirm that a standalone Tvision application or runtime is ready. Compatibility with existing components, their APIs, queue durability, and atomic budget reservation must be checked during integration.

The language, the agent, and the operating environment

Tvision describes the work. An agent can investigate, propose solutions, and create artifacts. An executor invokes tools. AIOS manages the environment, authority, state, and resources.

A model must not be able to change its own spending limits, permissions, or acceptance rules. Ordinary program code enforces those constraints. A goal such as “build a product” does not itself authorize server purchases, publication, outbound messages, or production changes.

In this RFC, AIOS means an environment for organizing agent work. Building a new operating system kernel is outside the scope of Tvision v0.1.

2. Go, Rust, and the existing Python AIOS

Go is the recommended starting point for a small v0.1 validator, CLI, and integration adapter. This is a design recommendation, not a claim that a Go application is already available. Existing Python AIOS components should be connected through agreed interfaces while retaining their working logic.

Area Proposed approach When to reconsider
Schema, validation, IR, CLI A small Go component If the existing stack already solves the problem at lower cost
Existing AI logic Connect the available Python components When a specific limitation has been measured
Executor calls Versioned adapters with explicit inputs and results When an executor capability changes
Rust A possible component for a narrow, measured bottleneck After profiling and evaluating integration cost
Dedicated syntax Defer until the schema and semantics stabilize When YAML/JSON create demonstrated limitations
A new OS kernel A separate research project Only for an independently justified objective

Choosing Go or Rust does not by itself reduce model token usage or guarantee the correctness of an autonomous agent. Savings depend on context, routing, retries, tools, and acceptance quality. Rewriting a working AIOS for the sake of a language choice is not an RFC objective.

3. Three AIOS generations on a common foundation

Generation What it adds Verifiable result
Agent Execution OS Tasks, dependencies, executors, budgets, checks, and observation Individual tasks with artifacts and receipts
Autonomous Product Factory Process templates for PM, Research, Finance, QA/SRE, Security/Legal, SEO, and Sales A coordinated process for building and maintaining a product
Autonomous Business OS Opportunity, Capital Allocation, Customer Intelligence, Growth, Delivery, Revenue, and Portfolio Work across opportunities, customers, resources, and a product portfolio

This is a development roadmap, not a claim that three complete products exist. Each generation uses the same underlying limits and execution evidence.

Product Factory roles

Role Primary output
PM The user problem, release scope, and acceptance criteria
Research Research, primary sources, alternatives, and uncertainty
Finance Cost calculations, scenarios, and assumptions
QA/SRE Checks, observability, and operating limits
Security/Legal Findings on authority, data, dependencies, and required reviews
SEO Clear structure and technical accessibility of useful content
Sales Proposals and communications within current authorization

A role name does not grant authority. Sales may prepare an offer; sending it remains a separate action. Security/Legal may produce a review report; the report does not replace any necessary professional or accountable human assessment.

Business OS roles

Role Proposed scope of work
Opportunity Identify problems, demand, and opportunities with evidence
Capital Allocation Propose distribution of resources and internal budgets
Customer Intelligence Use authorized customer data and feedback
Growth Develop testable acquisition and retention hypotheses
Delivery Deliver results and track commitments
Revenue Summarize revenue, terms, and metrics from available data
Portfolio Compare products, dependencies, risks, and resource demands

These roles do not automatically gain permission to move money, buy assets, enter commitments, or contact people. A real action must have a specific adapter, a resource scope, and valid authority.

4. Components and ownership of execution

The following table is a proposed responsibility mapping. It requires a capability audit of the existing components.

Component Proposed responsibility Boundary
AgentRoy Task intake, owner, goal, plan, overall status, and requests to AIOS BudgetGuard Does not create a separate financial ledger
AIOS BudgetGuard / ledger The existing system for limits, reservations, accounting, and cost reconciliation Its APIs and guarantees must be checked during integration
AgentOrch The DAG, dependency readiness, permitted route, and executor selection Does not create a parallel independent retry queue
DSHREM Proposed owner of worker job delivery, leases, attempts, and receipts This is a target mapping; this article does not confirm the required capabilities
AgentJudge Review specific artifact versions, tests, sources, and criteria Does not expand permissions or turn an opinion into proof of an external action
RemDesk Authorized server operations, transport, and observation Uses the same task and operation identifiers
RootRemDesk A separate boundary for privileged server actions Requires suitable authority, not the word “root” in a request
TvijoCode / Term Task creation and views of plans, diffs, states, costs, and results Uses the shared API without a competing queue

The goal is one designated owner of delivery and retry attempts for each worker job. AgentOrch determines which step is ready; the selected execution system delivers it to a worker and records attempts.

If DSHREM supports the required capabilities, the adapter should use its queue. If a capability is missing, that becomes an explicit integration limitation. Silently adding a second scheduler does not resolve the ownership problem.

One logical state model does not require one physical database table. It requires clear ownership of each record and explicit update rules.

Identifiers

Identifier Purpose
task_id The task's intent and specification
run_id A particular execution of the task
step_id A node in the committed plan
attempt_id One attempt to execute a step
effect_id One intended external action
receipt_id A receipt for an observed result
reservation_ref A reference to an existing BudgetGuard reservation

A retry receives a new attempt_id. The logical external action key, effect_id, remains stable where a correct idempotency strategy supports that behavior.

5. MCP and external tools

MCP architecture describes the interaction between a host, clients, and servers, including primitives such as tools, resources, and prompts. Tvision can use MCP adapters at the execution boundary; its plan, authority, and financial accounting remain AIOS responsibilities. See MCP architecture.

Long-running work requires a separate capability check for task interfaces. The published MCP Tasks specification is a possible integration point. The presence of an MCP server does not by itself establish support for Tasks, recovery after failure, or cancellation guarantees.

A proposed adapter capability manifest includes:

  • input and output schemas;
  • required permissions and how resource scope is enforced;
  • adapter and supported protocol versions;
  • cost categories and an available upper bound;
  • idempotency properties;
  • cancellation and final-status retrieval capabilities;
  • the availability of an external operation ID;
  • possible external side effects.

An unknown capability must not be treated as an allowed capability.

6. The document envelope

Every construct below is an RFC proposal.

Task contains exactly one executable step. Workflow contains a finite DAG of steps. The empty envelope below is a template that must be completed before execution. apiVersion defines document semantics, while the runtime and adapter capability versions determine which fields are actually supported. An unsupported common field must cause an error before any external action.

apiVersion: tvision/v0.1
kind: Workflow
metadata:
  name: task-name
  description: "Task description"
goal: "The verifiable result required"

inputs: {}

budget:
  currency: USD
  max: "1.00"
  enforcement: strict
  include: ["model", "tool", "media"]

limits:
  timeout: 15m
  parallel: 1
  attempts: 2
  max_steps: 20

permissions: []

routing:
  profile: balanced

steps: []
outputs: {}
acceptance: []

retention:
  profile: standard

An input document expresses a request. It cannot assign itself a tenant, create a grant, establish a recipient's consent, mark spending as settled, or fabricate an execution receipt.

Types

Type Meaning and validation
string Text with a size limit
bool A Boolean value
int An integer with a defined range
decimal An exact decimal value represented as a string
duration A duration such as 15m
timestamp An unambiguous time with a time zone
enum One of the published allowed values
list A bounded sequence of typed values
object An object with a verifiable schema
uri A syntactically valid URI; the URI itself grants no access
money A currency and an exact decimal amount
repo_ref A repository with a pinned revision and access rules
artifact_ref An artifact reference with a content hash
source_ref / source_set A source or source collection with provenance
secret_ref A secret reference without its value in the document
grant_ref A reference to verifiable operator authority
consent_ref A reference to a recipient consent record
audience_ref An authorized audience for a particular channel
dataset_ref A versioned dataset with access rules

The runtime should represent money as integer minimum units, such as microdollars. Binary float arithmetic must not determine the remaining budget.

References and resource scope

Three explicit reference forms are proposed:

repository: {input: repository}
patch: {artifact: patch.diff}
workspace: {run: workspace}

input refers to a validated input value. artifact refers to the output of a particular step. run refers to a resource assigned to the current run by the server, such as workspace, artifacts, allowed_web, knowledge, media, or consent_registry.

run: allowed_web does not mean unrestricted access to the entire internet: it is the runtime's permitted set of network resources. run: knowledge does not mean every document: retrieval must enforce the current user's access rights.

Example permission requests:

permissions:
  - capability: repo.read
    resource: {input: repository}
  - capability: worktree.write
    resource: {run: workspace}
  - capability: artifact.write
    resource: {run: artifacts}

Resource scope must be enforced by the adapter or the underlying access-control system. If a tool cannot maintain the requested boundary, validation or step admission must fail.

7. Extended RFC vocabulary

The following tables contain more than 50 fields, values, and policies. They describe the proposed system, not an inventory of implemented features. An implementation must publish its supported subset and reject unsupported fields.

Document fields, server policies, and receipts are distinct. A task author can request settings but cannot edit the effective grant, the budget ledger, or execution evidence.

Document and inputs

Field Meaning
apiVersion The language version, such as tvision/v0.1
kind Task is one executable step; Workflow is a finite DAG
metadata.name Task template name
metadata.description A description of its purpose
metadata.labels Search and grouping labels
goal The verifiable objective
inputs Named input declarations
inputs.<name>.type Input type
inputs.<name>.required Whether the input is required
inputs.<name>.default Default value
inputs.<name>.values Allowed enum values
inputs.<name>.schema_ref A composite object's schema version
outputs.<name>.ref A reference to a final artifact
outputs.<name>.required Whether the output is required for the selected branch

Budget, time, and resources

Field Meaning
budget.currency Accounting currency
budget.max Total monetary limit as an exact decimal
budget.enforcement strict or tracked
budget.include Declared categories: model, tool, media, and infra when supported; the field cannot exclude actual direct costs from the limit
limits.timeout Overall active-run deadline; waiting rules are committed in the plan
limits.parallel Maximum concurrent steps
limits.attempts Attempts per step, including the first
limits.max_steps Maximum executable plan size
limits.max_tool_calls Maximum tool calls
limits.max_input_tokens_per_call Input limit for one model call
limits.max_output_tokens_per_call Output limit for one model call
limits.max_media_seconds Maximum generated audio or video duration
limits.max_artifact_bytes Maximum stored result size
limits.max_child_tasks Child-task limit; zero in the minimum v0.1 implementation

Permissions and routing

Field or policy Meaning
permissions[].capability The requested action
permissions[].resource The action's resource boundary
routing.profile For example, economy or balanced; the plan records the actual route
routing.allowed_providers Permitted providers
routing.allowed_models Permitted models
routing.data_region A location requirement, if actually enforceable
routing.fallback A bounded switching strategy
policies.permissions deny_ungranted: reject an action without a suitable grant
policies.external_effects The authorized_only policy
policies.secrets The references_only policy
policies.unknown_capability The reject policy
policies.plan_changes Recheck material plan changes

Steps and checks

Field Meaning
steps[].id Unique step name
steps[].needs Dependencies; dependency readiness is not acceptance of its contents
steps[].uses A registered adapter
steps[].role A domain role that grants no authority by itself
steps[].with Arguments validated against the adapter schema
steps[].when A restricted deterministic condition
steps[].requires Admission checks before the action
steps[].budget A narrower step budget
steps[].limits Narrower step limits
steps[].retry A retry strategy within supported capabilities
steps[].idempotency How attempts map to a logical action
acceptance[].check A final acceptance-check identifier
acceptance[].on The artifact to check
requires[].check A prerequisite-check identifier
requires[].on The input or artifact being checked
Field or policy Meaning
sources.prefer A preference such as primary
sources.allowed_domains An additional narrowing of network scope
sources.freshness A freshness requirement
sources.citations For example, required
sources.missing_evidence For example, disclose: explain missing evidence
sources.access principal_scoped: filter for the current user
sources.claim_links Links between individual claims and sources
consent.refs Consent-record references
consent.channel email or telegram
consent.purpose The authorized communication purpose
consent.recheck before_each_send
consent.frequency_policy_ref A reference to frequency limits
consent.suppression_policy_ref A reference to recipient suppression rules
retention.profile A published retention profile
retention.artifacts_ttl Retention of ordinary artifacts
retention.logs_ttl Retention of diagnostic logs
retention.receipts_policy_ref Separate retention rules for operation evidence
retention.deduplicate Deduplication within permitted access boundaries

A trusted part of the system creates these records. Fields in arbitrary YAML do not replace their verification.

Field Meaning
source.id Source identifier
source.url Canonical address
source.title Title
source.publisher Publisher or owner
source.published_at Publication date, if known
source.fetched_at Retrieval time
source.content_hash Hash of the retrieved content
source.locator A passage, section, or other citation locator
source.access_policy_ref Access rules
consent_record.id Consent identifier
consent_record.recipient_ref Recipient
consent_record.channel Channel
consent_record.purpose Purpose
consent_record.evidence_ref Basis and supporting evidence
consent_record.granted_at Time consent was obtained
consent_record.expires_at Expiration, if limited
consent_record.revoked_at Revocation, if any

Receipt: read-only runtime evidence

Field Meaning
receipt.version Receipt format version
receipt.id Identifier
receipt.task_id Task
receipt.run_id Run
receipt.step_id Step
receipt.attempt_id Attempt
receipt.effect_id Logical external action
receipt.plan_hash The approved plan version
receipt.policy_hash The effective policy version
receipt.input_hash Hash of validated inputs
receipt.output_hashes Hashes of produced artifacts
receipt.adapter_version Executor version
receipt.provider_request_id Provider ID, if available
receipt.external_operation_id External operation ID, if available
receipt.reservation_ref BudgetGuard reservation reference
receipt.usage Measured resource usage
receipt.cost Confirmed or estimated cost with a stated status
receipt.cost_status estimated, reserved, settled, or unknown
receipt.status The observed attempt outcome
receipt.started_at / receipt.finished_at Timestamps
receipt.source_ids Sources used
receipt.consent_refs Consent records checked for delivery
receipt.checks Check results and their versions

A hash links a check to specific content. By itself it does not prove that an external service is truthful, nor does it protect against an administrator who can rewrite the entire history. Signatures or an independent log are separate capabilities; a field name is not proof that they exist.

8. Syntax limits and planning

The v0.1 proposal is to:

  • reject unknown fields and duplicate YAML keys;
  • exclude custom YAML tags, arbitrary eval, and unbounded reference expansion;
  • reject cyclic DAGs and unlimited child-task creation;
  • restrict when conditions to eq, in, all, and any;
  • pass references as typed objects;
  • avoid implicitly interpolating document strings into shell commands.

The processing path is:

Document → parsing → type checks → adapter resolution → authority and budget checks → committed IR → execution → acceptance.

The IR contains the normalized DAG, adapter versions, permitted route, input and policy hashes, limits, expected outputs, and evidence requirements.

needs expresses ordering and result availability. Publication, delivery, media generation, and other consequential actions need explicit requires checks confirming that the preceding review actually passed.

When the model, provider, target resource, or material artifact changes, the runtime repeats the affected checks. Automatic fallback does not authorize unlimited spending or disclosure to a new recipient.

9. Lifecycle

The primary path is draft → validated → ready → running → reviewing → succeeded. The reviewing stage is used only when the plan calls for it.

State Meaning
draft The document has not passed validation
validated Schema, references, and supported capabilities have been checked
ready The plan is admitted within current limits
running Some steps are executing
reviewing Results are being checked
waiting No steps can run; the reason is recorded separately
paused The operator has paused new step dispatch
failed A final failure has been established
cancel_requested Cancellation has been requested but not confirmed
cancelled Stopping is confirmed within the system's known boundaries
outcome_unknown An external action may have occurred, but no reliable outcome is available
succeeded Every mandatory output and acceptance condition has been satisfied

Waiting reasons include a dependency, authority, budget, quota, or provider. Pausing must not silently extend authorized time or spending.

For an individual step, when=false means skipped: no action runs and no artifacts are produced. References to absent conditional artifacts are rejected during validation when their absence is statically known, or before admitting a step that uses them. A skipped step does not dereference its with arguments. Skipping does not satisfy a mandatory output or acceptance condition; if either requires the missing result, the run cannot become succeeded.

History replay reads recorded events. A new model call is a new execution, potentially with a new result and cost. Those operations should not be hidden behind one button.

10. Authority and spending invariants

Authority

Effective permission is the intersection of the task request, the user's current grant, and the executor's implemented capabilities.

Content from a website, document, conversation, or model remains data. It cannot elevate authority, disable BudgetGuard, or replace an operator's decision.

Authorization is checked for the specific action and resource immediately before tool invocation. Authority already given by the user is honored within its scope. Additional confirmation is needed for a genuinely new scope or action, not for every implementation detail.

When confirmation is necessary, the user should see the concrete plan, material artifact, action target, and spending limit.

Budget

Tvision uses the existing AIOS BudgetGuard/ledger. The required integration semantics are:

Available = limit − settled spending − active and unresolved reservations.

Before a paid call, the system needs an atomic reservation for its permitted maximum cost. Parallel workers must not each treat the same remaining balance as exclusively available to them.

Mode Proposed meaning
strict Admit a call only when an implemented mechanism can keep its cost within the remaining limit
tracked Account for spending and apply available controls without promising an absolute ceiling

Unknown cost is not zero. Under strict, the lack of a reliable upper bound means rejection or waiting for a suitable adapter. Switching to tracked must not happen silently.

Estimates include retries, fallback, paid tools, and media. budget.include cannot exclude the cost of an actual model, tool, or media invocation from the total limit. The runtime obtains categories from the verified adapter manifest and records all direct costs even if the document author omitted a category. Prices and billing rules are recorded with the calculation. infra costs that the control system cannot bound, including background server and storage costs, are shown separately; they must not be presented as covered by the run's strict limit.

A timeout or closed HTTP connection does not establish that remote work stopped or that billing ended. An unknown outcome keeps its reservation until reconciliation.

Retries, cancellation, and uncertainty

A receipt links an attempt, its inputs, the external action, and the observed result. A lost response must not trigger a blind retry of sending, publishing, charging, or provisioning.

The proposed procedure is to find the external operation ID, query status, use a supported idempotency key, or retain outcome_unknown. If the provider offers no safe reconciliation mechanism, the runtime must not promise exactly-once execution.

Cancellation stops new dispatch and sends the supported signal to the active executor. Confirmation of remote stopping and release of the reservation are separate operations.

11. Sources, evidence, and AgentJudge

A source needs provenance, retrieval time, a hash, access rules, and a locator for the supporting passage. An unknown publication date must remain unknown.

Three checks are distinct:

  1. The link exists and points to an accessible document.
  2. The cited passage is present in the retrieved version.
  3. The passage substantively supports the claim.

The first two do not prove the third. Evaluating support, including evaluation by another model, has its own limitations. AgentJudge complements tests and verifiable data; it does not turn an assessment into proof of truth.

A check must refer to a specific artifact hash. A document modified after review requires the affected properties to be checked again.

When evidence is insufficient, a valid result can explain the limits of the answer and identify missing data. An unsupported assertion should not be presented confidently.

Outbound communication needs two independent bases: operator authority to send and an appropriate recipient consent or permitted recipient record for the particular channel and purpose.

The proposed product policy is to:

  • avoid treating a public email address as mailing-list consent;
  • manage email and Telegram separately;
  • check purpose, channel, revocation, expiry, and frequency immediately before each send;
  • support suppression lists and a clear unsubscribe path;
  • retain consent evidence and delivery receipts;
  • separate message preparation from sending;
  • avoid inferring consent from silence or a hidden interface toggle.

This is a technical product standard. Applicable legal requirements must be assessed separately for the relevant users and jurisdictions.

Using a particular person's likeness or cloning a voice requires appropriate separate permission. A visitor choosing “answer by voice” does not consent to having their own voice cloned.

13. Proposed CLI commands

The commands below are an interface proposal. The existence of an executable tvision binary has not been verified.

Command Proposed action
tvision init Create a document template
tvision fmt task.yaml Normalize formatting
tvision validate task.yaml Check schema, types, references, and the DAG without calling a model
tvision plan task.yaml Show the plan, permissions, unknown capabilities, and dependencies
tvision estimate task.yaml Calculate a cost or range with explicit assumptions
tvision run task.yaml Execute an admissible plan
tvision status RUN_ID Show state and remaining budget
tvision events RUN_ID Show events
tvision artifacts RUN_ID Locate results
tvision receipts RUN_ID Show execution and cost receipts
tvision sources RUN_ID Show data provenance
tvision verify RUN_ID Check stored artifacts
tvision pause RUN_ID Stop dispatching new steps
tvision resume RUN_ID Resume under current valid conditions
tvision cancel RUN_ID Request cancellation
tvision replay RUN_ID --offline Replay history without new external actions
tvision explain RUN_ID Explain routing, spending, and waiting reasons
tvision consent inspect CONSENT_ID Inspect a consent record available to the operator

validate and local planning must not silently invoke a paid model. estimate shows price provenance and freshness. verify distinguishes local checks from operations that would require a new external action.

14. Seven task examples

All examples illustrate the RFC. Adapters and checks require implementation. Monetary values demonstrate limits; they are not promises that the work can be completed at those prices. Input values are supplied at execution time.

For brevity, the examples omit common limits, routing, and retention settings. Their restrictive defaults must be published with the schema version. Every permission applies to its stated resource and is intersected with the actual grant.

Example 1. A code fix with evidence

apiVersion: tvision/v0.1
kind: Workflow
metadata: {name: fix-with-evidence}
goal: "Prepare a bug fix and evidence of its verification"
inputs:
  repository: {type: repo_ref, required: true}
  issue: {type: string, required: true}
budget: {currency: USD, max: "1.00", enforcement: strict}
permissions:
  - capability: repo.read
    resource: {input: repository}
  - capability: worktree.write
    resource: {run: workspace}
  - capability: sandbox.exec
    resource: {run: workspace}
  - capability: artifact.write
    resource: {run: artifacts}
steps:
  - id: patch
    uses: agent.code_patch
    with:
      repository: {input: repository}
      issue: {input: issue}
  - id: tests
    needs: ["patch"]
    uses: tool.repository_tests
    with:
      patch: {artifact: patch.diff}
  - id: review
    needs: ["patch", "tests"]
    uses: judge.code_review
    with:
      patch: {artifact: patch.diff}
      tests: {artifact: tests.report}
acceptance:
  - check: tests.pass
    on: {artifact: tests.report}
  - check: review.no_blockers
    on: {artifact: review.report}
outputs:
  patch: {ref: {artifact: patch.diff}, required: true}
  evidence: {ref: {artifact: review.report}, required: true}

The result is a diff and verification reports. Modifying the remote repository requires a separate action. Test evidence applies to the exact patch and base revision.

Example 2. Source-based research

apiVersion: tvision/v0.1
kind: Task
metadata: {name: primary-source-research}
goal: "Answer with sources and clear limits of confidence"
inputs:
  question: {type: string, required: true}
budget: {currency: USD, max: "0.50", enforcement: strict}
permissions:
  - capability: web.read
    resource: {run: allowed_web}
  - capability: artifact.write
    resource: {run: artifacts}
sources:
  prefer: primary
  citations: required
  missing_evidence: disclose
  access: principal_scoped
steps:
  - id: research
    uses: agent.research
    role: Research
    with:
      question: {input: question}
acceptance:
  - check: citations.resolved
    on: {artifact: research.report}
  - check: uncertainty.disclosed
    on: {artifact: research.report}
outputs:
  report: {ref: {artifact: research.report}, required: true}
  sources: {ref: {artifact: research.sources}, required: true}

citations.resolved checks links and locators. Substantive assessment of conclusions may require separate review. The report must make missing evidence visible.

Example 3. Product Factory: release and publication verification

apiVersion: tvision/v0.1
kind: Workflow
metadata: {name: product-release}
goal: "Prepare a bounded release and verify its publication"
inputs:
  brief: {type: string, required: true}
  target: {type: uri, required: true}
  publication_grant: {type: grant_ref, required: true}
budget: {currency: USD, max: "5.00", enforcement: strict}
permissions:
  - capability: worktree.write
    resource: {run: workspace}
  - capability: sandbox.exec
    resource: {run: workspace}
  - capability: artifact.write
    resource: {run: artifacts}
  - capability: site.publish
    resource: {input: target}
  - capability: site.read
    resource: {input: target}
steps:
  - id: spec
    uses: agent.product_spec
    role: PM
    with: {brief: {input: brief}}
  - id: build
    needs: ["spec"]
    uses: agent.product_build
    with: {spec: {artifact: spec.document}}
  - id: qa
    needs: ["build"]
    uses: tool.product_checks
    role: QA
    with: {build: {artifact: build.bundle}}
  - id: seo
    needs: ["build"]
    uses: tool.web_quality_checks
    role: SEO
    with: {build: {artifact: build.bundle}}
  - id: publish
    needs: ["build", "qa", "seo"]
    uses: tool.site_publish
    requires:
      - check: release_checks.pass
        on: {artifact: qa.report}
      - check: web_checks.pass
        on: {artifact: seo.report}
      - check: authorization.valid
        on: {input: publication_grant}
    with:
      bundle: {artifact: build.bundle}
      target: {input: target}
      grant: {input: publication_grant}
  - id: livecheck
    needs: ["publish"]
    uses: tool.site_livecheck
    requires:
      - check: publication_receipt.confirmed
        on: {artifact: publish.receipt}
    with:
      target: {input: target}
      publication: {artifact: publish.receipt}
acceptance:
  - check: publication_receipt.confirmed
    on: {artifact: publish.receipt}
  - check: livecheck.pass
    on: {artifact: livecheck.report}
outputs:
  release: {ref: {artifact: publish.receipt}, required: true}
  livecheck: {ref: {artifact: livecheck.report}, required: true}

Authority must cover the resource and prepared release. needs does not replace requires. The receipt must connect the published revision to the checked bundle.

Publication needs an actual live check of the expected address, availability, release identity, and material page properties. If the live check fails, the run must not become succeeded even if publication occurred. A possible rollback is a separate action with predefined authority. This example does not establish that the named adapters exist.

Example 4. Token, storage, and server efficiency audit

apiVersion: tvision/v0.1
kind: Workflow
metadata: {name: efficiency-audit}
goal: "Propose optimizations based on measurements"
inputs:
  telemetry: {type: dataset_ref, required: true}
budget: {currency: USD, max: "0.50", enforcement: strict}
permissions:
  - capability: metrics.read
    resource: {input: telemetry}
  - capability: artifact.write
    resource: {run: artifacts}
steps:
  - id: measure
    uses: tool.resource_summary
    with: {telemetry: {input: telemetry}}
  - id: proposal
    needs: ["measure"]
    uses: agent.efficiency_proposal
    role: SRE
    with: {measurements: {artifact: measure.report}}
acceptance:
  - check: recommendations.have_baseline
    on: {artifact: proposal.report}
outputs:
  baseline: {ref: {artifact: measure.report}, required: true}
  proposal: {ref: {artifact: proposal.report}, required: true}

Measured savings and forecasts are shown separately. A production configuration change does not follow automatically from an optimization report.

Example 5. A citing chatbot: text, voice, and video

apiVersion: tvision/v0.1
kind: Workflow
metadata: {name: cited-answer}
goal: "Answer from accessible sources in the selected format"
inputs:
  question: {type: string, required: true}
  mode:
    type: enum
    values: ["text", "voice", "video"]
    default: text
budget: {currency: USD, max: "1.00", enforcement: strict}
permissions:
  - capability: knowledge.read
    resource: {run: knowledge}
  - capability: artifact.write
    resource: {run: artifacts}
  - capability: media.generate
    resource: {run: media}
sources:
  citations: required
  missing_evidence: disclose
  access: principal_scoped
steps:
  - id: retrieve
    uses: tool.authorized_retrieval
    with: {question: {input: question}}
  - id: answer
    needs: ["retrieve"]
    uses: agent.grounded_answer
    with:
      question: {input: question}
      sources: {artifact: retrieve.sources}
  - id: checks
    needs: ["answer", "retrieve"]
    uses: tool.answer_integrity
    with:
      answer: {artifact: answer.document}
      sources: {artifact: retrieve.sources}
  - id: audio
    needs: ["answer", "checks"]
    when: {in: [{input: mode}, ["voice", "video"]]}
    uses: tool.speech_render
    requires:
      - check: answer_checks.pass
        on: {artifact: checks.report}
    with:
      transcript: {artifact: answer.document}
      checks: {artifact: checks.report}
  - id: video
    needs: ["answer", "checks", "audio"]
    when: {eq: [{input: mode}, "video"]}
    uses: tool.cited_video_render
    requires:
      - check: answer_checks.pass
        on: {artifact: checks.report}
    with:
      transcript: {artifact: answer.document}
      checks: {artifact: checks.report}
      audio: {artifact: audio.file}
acceptance:
  - check: answer_checks.pass
    on: {artifact: checks.report}
outputs:
  answer: {ref: {artifact: answer.document}, required: true}
  audio: {ref: {artifact: audio.file}, required: false}
  video: {ref: {artifact: video.file}, required: false}

When voice or video is selected, the corresponding executed step must successfully create and validate its artifact. required: false permits absence only in a skipped conditional branch; it does not permit an error in the selected mode to be ignored.

answer_checks.pass must refer to the hash of the exact document passed to media generation. Its criteria include authorized sources, valid references, disclosed uncertainty, and no identified blocking issues. This is a checking procedure, not a mathematical guarantee of truth.

The visitor's identity comes from validated server context. Audio and video use the checked text as their basis; sources remain available through a transcript, source cards, or captions.

Official guides describe OpenAI file search, web search, and approaches to voice agents. These are possible references for adapter implementation, not proof that the integrations are connected in Tvijo. Video is a separate proposed adapter in this RFC.

Example 6. A voluntary email or Telegram update

apiVersion: tvision/v0.1
kind: Workflow
metadata: {name: opted-in-update}
goal: "Send an update to an audience that has opted in"
inputs:
  announcement: {type: artifact_ref, required: true}
  audience: {type: audience_ref, required: true}
  send_grant: {type: grant_ref, required: true}
budget: {currency: USD, max: "0.50", enforcement: strict}
permissions:
  - capability: consent.read
    resource: {run: consent_registry}
  - capability: contact.send
    resource: {input: audience}
  - capability: artifact.write
    resource: {run: artifacts}
consent:
  recheck: before_each_send
steps:
  - id: prepare
    uses: tool.channel_message_prepare
    with:
      announcement: {input: announcement}
      audience: {input: audience}
  - id: send
    needs: ["prepare"]
    uses: tool.consented_delivery
    requires:
      - check: authorization.valid
        on: {input: send_grant}
    with:
      messages: {artifact: prepare.messages}
      audience: {input: audience}
      grant: {input: send_grant}
acceptance:
  - check: delivery.reconciled
    on: {artifact: send.receipts}
outputs:
  delivery: {ref: {artifact: send.receipts}, required: true}

The adapter rechecks each recipient's consent immediately before sending. A recipient without valid consent is skipped with a recorded reason. delivery.reconciled means that unknown outcomes are not hidden; it does not mean every recipient read the message.

A lost response from the delivery service must not trigger a blind repeat campaign.

Example 7. Business OS: a resource allocation proposal

apiVersion: tvision/v0.1
kind: Workflow
metadata: {name: portfolio-proposal}
goal: "Propose resource allocation across products"
inputs:
  opportunities: {type: dataset_ref, required: true}
  economics: {type: dataset_ref, required: true}
  capacity: {type: dataset_ref, required: true}
budget: {currency: USD, max: "1.00", enforcement: strict}
permissions:
  - capability: business.read
    resource: {input: opportunities}
  - capability: business.read
    resource: {input: economics}
  - capability: business.read
    resource: {input: capacity}
  - capability: artifact.write
    resource: {run: artifacts}
steps:
  - id: opportunity
    uses: agent.opportunity_assessment
    role: Opportunity
    with: {data: {input: opportunities}}
  - id: finance
    needs: ["opportunity"]
    uses: tool.financial_scenarios
    role: Finance
    with:
      opportunities: {artifact: opportunity.report}
      economics: {input: economics}
      capacity: {input: capacity}
  - id: allocation
    needs: ["opportunity", "finance"]
    uses: agent.capital_allocation_proposal
    role: CapitalAllocation
    with:
      opportunities: {artifact: opportunity.report}
      scenarios: {artifact: finance.report}
  - id: review
    needs: ["allocation"]
    uses: judge.business_assumptions
    role: Portfolio
    with: {proposal: {artifact: allocation.document}}
acceptance:
  - check: assumptions.disclosed
    on: {artifact: review.report}
  - check: scenario_inputs.traceable
    on: {artifact: finance.report}
outputs:
  proposal: {ref: {artifact: allocation.document}, required: true}
  assumptions: {ref: {artifact: review.report}, required: true}

The result is a proposal with inputs, scenarios, and limits. The example contains no banking transactions, purchases, or commitments.

15. Saving tokens, storage, and server capacity

Proposed mechanisms should be evaluated through measurement.

Resource Mechanism Metric
Tokens Relevant passages, diffs, and bounded context Tokens and cost per accepted task
Models Deterministic checks before generation and permitted routing by complexity Acceptance rate, cost, and retries
Cache Keys derived from inputs, model, schema, policy, and sources Hit rate and stale-result errors
Storage Content-addressed artifacts and deduplication within access boundaries Bytes per run and recoverability
Logs Bounded volume, secret removal, and archival Size and diagnostic usefulness
Server Bounded concurrency, backpressure, and worker scaling CPU, RAM, queue length, and latency
Media Generation on request and reuse of an unchanged basis Cost per useful output

Unchanged documents should not be processed repeatedly without a reason. But a cached result cannot be reused after a material change to permissions, data, or access rules without checking its applicability.

Ordinary intermediate data, private sources, and external-action receipts need different retention policies. Deleting “unnecessary files” must not destroy evidence for an unresolved operation.

A savings percentage should be published only after a reproducible comparison using the same tasks, acceptance criteria, and accounting conditions. A cheaper attempt is not a saving if more failed attempts are needed.

16. Technical requirements for the wiki, SEO, and interface

The page at https://tvijo.com/wiki/languageprogramming-tvijion should:

  • retain a clear definition of Tvision and a visible RFC status;
  • distinguish verified features, proposed capabilities, and experiment results;
  • show the real date of a substantive update and its sources;
  • use semantic headings, section links, readable tables, and accessible code copying;
  • make the main text available without launching the chatbot;
  • give chatbot answers links to specific sections;
  • enable voice and video through an explicit choice;
  • present subscription as voluntary, with a clear purpose and unsubscribe path.

Google recommends useful, original content, clear provenance, and value to the reader. This is a quality guideline, not a ranking guarantee: Creating helpful, reliable, people-first content.

Generative AI does not replace accuracy, review, or usefulness. Automatically creating large numbers of pages for search traffic should not become the Product Factory's objective: Using generative AI content.

If structured data is used, it must describe the actual visible content. Markup does not establish that an unimplemented runtime has been released, nor does it guarantee a rich search presentation: Structured data general guidelines.

The task interface should make five things clear: the current goal, execution stage, remaining budget, any required user action, and the verifiable result. Internal protocol and queue names should not obstruct that flow.

17. MVP acceptance criteria

Before publicly claiming that “Tvision works,” a verifiable implementation must demonstrate that:

  1. Unknown adapters, cycles, invalid types, and unsupported fields are rejected before a paid call.
  2. permissions does not expand the effective grant, and resource scope is actually enforced.
  3. The existing BudgetGuard atomically reserves a shared budget for concurrent calls.
  4. Unknown cost correctly blocks strict mode.
  5. A lost external response preserves uncertainty instead of creating a hidden duplicate.
  6. A restart restores available persisted state and results.
  7. Cancellation stops new dispatch and accurately shows unconfirmed operations.
  8. AgentJudge checks the same artifact hash that is subsequently used.
  9. needs cannot bypass a failed requires check.
  10. Audio and video are not generated after answer_checks.pass fails.
  11. Publication is not accepted without a confirmed receipt and a passing live check.
  12. Revoked consent prevents subsequent sends.
  13. Private sources do not enter another user's context, cache, or answer.
  14. A demo includes the task, plan, artifact, checks, receipt, and actual cost.

These are future acceptance conditions, not a report of tests already passed.

18. Implementation sequence

The proposed first scope is:

  1. Schema and validator: types, references, permissions, limits, and the DAG.
  2. Local plan and a stable IR.
  3. A DSHREM capability audit and an adapter to existing execution.
  4. Integration with AIOS BudgetGuard/ledger and receipts.
  5. Two bounded scenarios: a code fix and source-based research.
  6. Result inspection through the CLI and TvijoCode/Term.
  7. Expansion of Product Factory and Business OS templates only after measurement.

Dedicated syntax, complex optimization, automated media generation, and broad business autonomy should build on a verified foundation. The next implementation decision needs real capability receipts, measurements of useful completed work, and a concrete list of current AIOS limitations.

Applying Tvision across Tvijo products and priorities

The following are proposed templates built on the same task model. They do not establish that integrations are available, that the products have paying customers, or that the workflows have passed operational testing.

Product or system Proposed Tvision workflow Acceptance and measurement
TvijoCode / TvijoTerm Turn a change request into a patch, checks and a report Accepted patch, time to verification, full task cost
RemDesk / RootRemDesk Diagnosis and an authorized server operation with a receipt Observed service state, enforced scope, recoverability
Hotido Analyze permitted customer questions and prepare source-grounded answers Answer usefulness, evidence of demand, service time
FinEdg Verifiable calculations and scenario analysis over versioned data Reproducible calculation, input provenance, explicit assumptions
SiteSale Prepare a customer website, check its pages and propose a release Customer acceptance criteria, confirmed publication, delivery cost
AI Video Studio Produce a verified script, speech, captions and video on request Fidelity to the source text, media rights, cost per accepted video

A FinEdg analytics template does not authorize trades or transfers. Likewise, a SiteSale workflow does not establish sales, and a rendered video is not evidence of publication.

When to spend tokens on analysis

Start each investigation with a decision it could change: choose an MVP problem, shorten response time, improve an expensive step, or select the next experiment. Record the question, available evidence, spending limit, required sources, sufficiency criterion and accountable decision owner.

An Opportunity Engine record should contain the problem and segment, evidence of interest, observation frequency, proposed price, variable costs, experiment cost, capacity, uncertainty and a stop condition. Missing values remain unknown. Page views and discovered contact details are not orders.

Capital Allocator compares evidence of the problem, scenario-based contribution to margin, time to test and available team capacity. Changes to internal budgets pass through the existing BudgetGuard; financial commitments require their own authorization. AgentRoy turns the selected opportunity into a bounded task, and AgentJudge evaluates the resulting evidence.

Stop research when the predefined criterion is met, the limit is reached, or no new evidence can change the decision. Repeatedly reviewing the same sources does not count as new knowledge. Validate a priority through the next experiment: a customer's acceptance decision, verified delivery or a measured improvement, rather than the number of agent messages.

Economics, customer experience, and verifiable development of Tvision

Status: project proposal. Implemented features and achieved performance have not been confirmed. Compare use cases in a single currency using predefined task cohorts over their full lifecycle. Keep monthly financial results, receipts, and payments in a separate report.

Count the entire accepted result

Before the experiment, fix cohort membership, exclusions, the acceptance criterion, and the full lifecycle boundary, including storage. D is all unique tasks in the cohort; N is tasks with an accepted final outcome, each counted at most once. Generations and intermediate results do not increase N. Acceptance checks answer quality or completion of an authorized action. At the observation cutoff, each task has one status: accepted, failed, cancelled, pending, or unknown; the counts sum to D.

Full cost per accepted task = (C_usage + C_human + F_allocated) / N

The numerator contains the entire cohort's lifecycle costs, including failed attempts; crossing a month boundary does not reset them. When N = 0, unit cost is undefined; report the costs separately.

C_usage includes billed tokens, tools, retries, failed calls, variable server costs, storage, data transfer, and media. Subscriptions and reserved infrastructure enter F_allocated under a predetermined allocation basis. C_human includes preparation, review, support, development, integration, and observability: charge direct hours to the cohort at a stated rate and allocate shared engineering costs in proportion to cohorts' direct hours. Show paid labor and the estimated value of unpaid time separately. Do not count an item twice.

An open cohort, unknown bills, or unknown call outcomes makes the calculation provisional. Mark unknown costs as unknown rather than zero; distinguish estimates, reserves, and confirmed expenses. Fixed subscriptions, allocated unit cost, and marginal cash expense differ: an extra task may require more quota. Check the plan's terms; do not substitute zero for an unknown marginal cost.

Lower consumption with an unchanged bill releases capacity. Cash savings require a reduction in a comparable bill or documented avoidance of a purchase. Time released for an employee does not by itself reduce salary payments.

Comparable formulas and measurements

For comparable predefined cohorts with the same acceptance criterion:

saved_token_ratio = 1 − (T_new / N_new) / (T_base / N_base)

The formula is defined when N_new > 0, N_base > 0, and T_base > 0. T covers all attempts and checks. Normalize categories without overlap: do not add cached usage again when it is already included in input total. Use a comparable tokenizer and report the breakdown; when models differ, also compare monetary costs. A negative ratio means consumption increased.

Normalize the entire cohort's lifecycle resources by N as well:

  • CPU/accepted_task = total CPU-seconds / N;
  • RAM/accepted_task = integrated memory usage in GiB·hours / N;
  • storage/accepted_task = storage in GiB·months / N.

Include attributable background processes, indexes, logs, backups, and failed attempts. RAM is integrated usage over time; record the peak separately for server sizing. Allocate shared resources without double counting.

Contribution margin = net revenue − variable costs

Calculate net revenue after discounts and refunds, consistently excluding indirect taxes. The contribution margin ratio divides contribution margin by positive net revenue. Deduct fixed expenses to calculate operating profit or loss. Cash flow records receipts and payments by date; contribution margin is not a cash balance.

One answer, convenient ways to communicate

We propose concise text and source cards: title, link, verification date, applicability, and the claim supported. Add voice and video on request from the same verified content, retaining the text and links.

Documented mechanisms: File search retrieves material from an uploaded knowledge base; Web search returns citation annotations and requires prominent, clickable source links. OpenAI's voice pipeline supports speech recognition, an agent workflow, and speech generation, with intermediate text that can be inspected. These mechanisms do not establish that Tvision implements them.

Check access before retrieving restricted material and when delivering it. Separate caches by customer, permissions, audience, source version, and freshness; changes require rechecking. An executor's access to an internal document does not authorize public disclosure.

MCP defines context exchange without prescribing LLM management. The MCP Tasks extension describes long-running operations with a durable task handle and result retrieval. The handle itself does not guarantee indefinite storage, executor restart, or exactly-once execution. In the proposed architecture, the existing AIOS/DSHREM is the sole owner of state, retries, budgets, and acceptance; Tvision describes the workflow. Define retention periods and resumption rules explicitly.

Communication with authorized follow-up

Three modes:

  • A reply in the current conversation: the person's request is handled in the same context; this does not create a subscription to future messages.
  • Recurring messages: a separate opt-in specifies the topic, channel, frequency, and a way to stop delivery.
  • Publication by the owner: material appears in an owner-controlled channel within the granted permissions; this does not authorize personal messages to its audience.

A question, inquiry, or demonstration request records interest, but a discovered address or username does not authorize contact. Address scraping and unsolicited mass messaging are excluded. Verifying claims against sources and permission to send are independent requirements.

Create a draft first. Automatic delivery is possible only within a scoped grant covering recipients, channel, purpose, expiry, and frequency limits. Before delivery, recheck current consent, opt-outs, and duplicates. Revoking a grant stops messages that have not yet been sent. Apply the same process to email and Telegram.

Accumulating useful feedback

The proposed cycle: a real customer request → a prioritized feature → verified delivery → documentation with sources → a relevant inbound inquiry → an updated product. Value may accumulate when observations support the iterations; exponential growth is not guaranteed.

Google recommends helpful content for people. Its generative AI guidance warns about producing many pages without added value. Structured data policies require consistency with visible content and do not guarantee rich results. Accordingly, publish verified examples, limitations, and answers to real questions; do not promise indexing or search rankings.

Eight metrics for the first observation period

Initial values are “not measured.” Retain the cutoff, cohort, sources, and workflow version. Show accepted, failed, cancelled, pending, and unknown counts alongside the metrics. An empty denominator means N/A. Both sides of the inbound inquiry ratio use the same period and deduplication key. Fix the inventory of material factual claims and the materiality rule before evaluation: a citation counts as evidence only when it supports the specific claim in the relevant context. Do not present a small latency sample as a reliable tail estimate.

Metric Definition
Acceptance N / D: accepted unique tasks / all unique tasks in the predefined cohort at the cutoff
Time to result Median and p95 from request to acceptance for accepted tasks only, with observation count n; N/A when n = 0
Full unit cost Entire cohort's full lifecycle costs / N; an incomplete calculation is provisional
Token savings saved_token_ratio against a recorded baseline
Resource intensity Vector of CPU-seconds, RAM GiB·hours, and storage GiB·months / N
Evidence coverage Supported material factual claims / all material factual claims in the evaluated answer, including unreviewed claims
Qualified interest Unique inbound inquiries with a concrete task and authorized follow-up / all unique inbound inquiries in the same cohort
Monthly contribution margin ratio Contribution margin / positive net revenue for the same month

A 30-day plan with progression gates

These are planning windows, not guaranteed deadlines. Set quality and budget thresholds before the experiment; a failed gate keeps the current stage. Reproducibility means a repeatable procedure and verifiable acceptance, not identical LLM wording.

Window Work Progression gate
Days 1–7 Select the use case, cohort, acceptance criterion, baseline process, and accounting rules The baseline procedure is repeatable and measurement gaps are known
Days 8–14 Add attempt accounting, sources, and access checks; build a text prototype The procedure is repeatable, acceptance is verifiable, and cost completeness is visible
Days 15–21 Test the use case with consenting users; try voice or video when requested Quality and authorized actions are verified, and failures have been investigated
Days 22–30 Compare costs and acceptance, prepare documentation, and select the next iteration The decision to continue, revise, or stop is grounded in data

If evidence is insufficient, extend observation and disclose limitations. Consider scaling after verifying usefulness and economics; publication is insufficient.

Evidence and research contributions

Evidence snapshot: 2026-11-06 UTC (2026-11-07 Kyiv). The status below concerns preparation of this RFC, not verification of a Tvision runtime.

The technical specification, primary-source research, economics and editorial review were prepared within this ChatGPT work session. Model-level token and monetary receipts for that session are not available, so no per-model cost or ranking is claimed.

Requested external contributor Evidence available for this RFC Accepted contribution and cost
DS41F through DSHREM A task was queued with a requested USD 0.05 cap; its answer and final receipt were not recovered No answer credited; actual cost unknown
GLM53F through DSHREM A task was queued with a requested USD 0.05 cap; its answer and final receipt were not recovered No answer credited; actual cost unknown
MiMo / mi26f Not dispatched in this work session No answer credited
Devstral Not dispatched in this work session No answer credited
Codex account CLI, requested gpt-6.1-sol A bounded publication and integration preflight returned a report Infrastructure findings; allocated subscription cost not measured

The user's spelling tlm53f was not found as an available route; glm53f was a plausible interpretation, not a verified new alias. A queue receipt establishes acceptance of a request, not completion by a model. Requested spending caps are not billed amounts. Missing results must be reconciled before another paid attempt. This record does not constitute a model benchmark.

Sources

The sources below describe external protocols and guidance. They do not establish that Tvision or Tvijo integrations have been implemented.

  1. MCP: Architecture overview.
  2. MCP Tasks extension.
  3. Google Search: Creating helpful, reliable, people-first content.
  4. Google Search: Using generative AI content.
  5. Google Search: Structured data general guidelines.
  6. OpenAI API: File search.
  7. OpenAI API: Web search.
  8. OpenAI API: Voice agents.

Sources

Source links and observation dates are recorded below. Review status is stated for each material.

  1. MCP architecture · Checked 2026-11-06
  2. MCP Tasks extension · Checked 2026-11-06
  3. OpenAI file search · Checked 2026-11-06
  4. OpenAI web search · Checked 2026-11-06
  5. OpenAI voice agents · Checked 2026-11-06
  6. Google helpful content · Checked 2026-11-06
  7. Google generative AI content · Checked 2026-11-06
  8. Google structured data · Checked 2026-11-06

🔗 Article connections

Open the full knowledge graph ↗

Published article links. Select a node to open its article at the heading.

Show the connection graph
100%
→ Linked articles← Linked from⋯ Same topic
Article links · keyboard / text view

💬 Comments

Comments are public and moderated. Do not post personal data.
  • No comments yet. Be the first!

Next steps