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
- 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 |
Sources, consent, and retention
| 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 |
Server-side source and consent records
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
whenconditions toeq,in,all, andany; - 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:
- The link exists and points to an accessible document.
- The cited passage is present in the retrieved version.
- 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.
12. Voluntary channels and consent
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:
- Unknown adapters, cycles, invalid types, and unsupported fields are rejected before a paid call.
permissionsdoes not expand the effective grant, and resource scope is actually enforced.- The existing BudgetGuard atomically reserves a shared budget for concurrent calls.
- Unknown cost correctly blocks
strictmode. - A lost external response preserves uncertainty instead of creating a hidden duplicate.
- A restart restores available persisted state and results.
- Cancellation stops new dispatch and accurately shows unconfirmed operations.
- AgentJudge checks the same artifact hash that is subsequently used.
needscannot bypass a failedrequirescheck.- Audio and video are not generated after
answer_checks.passfails. - Publication is not accepted without a confirmed receipt and a passing live check.
- Revoked consent prevents subsequent sends.
- Private sources do not enter another user's context, cache, or answer.
- 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:
- Schema and validator: types, references, permissions, limits, and the DAG.
- Local
planand a stable IR. - A DSHREM capability audit and an adapter to existing execution.
- Integration with AIOS BudgetGuard/ledger and receipts.
- Two bounded scenarios: a code fix and source-based research.
- Result inspection through the CLI and TvijoCode/Term.
- 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.
Sources
Source links and observation dates are recorded below. Review status is stated for each material.
🔗 Article connections
Open the full knowledge graph ↗Published article links. Select a node to open its article at the heading.
Show the connection graph
Article links · keyboard / text view
Same topic
- Tvijo agent system: PRIZMA, RUNLEDGER and acceptance
- Read agent communication receipts without mistaking delivery for a human read
- Audit an AI technology radar against primary sources before promoting a story
- Run an AI coding harness evaluation offline before any live pilot
- DSHREM on a phone: SSH, tmux, and safe task handoff
- DSHREM owner practice: cwd, worktrees, WIP, and root boundaries
Next steps
Related reading
Tvijo agent system: PRIZMA, RUNLEDGER and acceptance
Tvijo is developing a controlled workflow from a repository task to an accepted result, with permissions, resource limits and attributable evidence. PRIZMA describes the intended resource profile; RUNLEDGER connects the work to its checks a…
AI and process foundationRead agent communication receipts without mistaking delivery for a human read
Find the current stage of a swarm message without confusing durable storage, delivery, runtime receipt and viewing. This guide connects local checks, the private observation screen and distinct receipts, so a delivery acknowledgement does not become an unsupported claim that an action completed.
AI and process foundationAudit an AI technology radar against primary sources before promoting a story
Check a technology news item against its primary source, version and event date before deciding to adopt it. This guide follows a fixed ten-item sample, separates facts from interpretation and forecasts, and preserves limitations and the condition for checking the claim again.
💬 Comments