1. Scope and boundaries

A reactive system has an implicit evaluation function: «the user asked for X → do X well». A proactive system does not: it generates the intention itself. telos is the component that decides which intention makes sense before it becomes a proposal to the user, without asking the user to evaluate everything. In it gains a new telos — cultivate the tools — which does not concern spontaneous proposals but the silent retreat from a direct request: a zone the previous design left uncovered.

What it is

• A file in the workspace (TELOS.md) with the user's ultimate ends.
• An alignment function that projects an ActionProposal onto the telos and returns a scalar (expected_alignment).
• A bother budget with separate quotas for ad-hoc proposals and scheduler-driven invocations.
• A stop clause that disengages the non-retreat telos when the user explicitly requests it.
• A learning mechanism from silences that updates the effective weights without altering the declared ones.

What it is not

• Not a substitute for the 4 Laws. Laws constrain, telos orient. A proposal perfectly aligned with the telos but violating a Law is still rejected: the Constitution wins.
• Not a judge of the user. Telos evaluate what Metnos is about to do for the user, not what the user does.
• Not an optimiser. Telos are Aristotelian ends (asymptotic), not SMART objectives. They are not reached: one approaches them.
• Not applied to explicit requests — with one exception: the non-retreat telos (ch. 5) takes effect precisely when the user asks for something the pool cannot yet do.

2. Laws vs telos: two distinct grammars

The distinction is not stylistic: it is categorial. Laws and telos inhabit two orthogonal axes of Metnos's life.

3. TELOS.md — the file

It lives in the workspace as the sixth canonical file. Markdown format with front-matter optional. A few lines, hand-written by the user. The canonical set was reduced to 6 telos on (, see note at the end of this chapter).

# My ultimate ends (,

## t.tempo — Free my time from repetitive chores
weight: 0.25
activation_threshold: 0.30
notes: if something frees at least 30 minutes/week and I can trust it,
 consider proposing it.

## t.ordine — Keep the order of my digital data
weight: 0.15
activation_threshold: 0.40
notes: I prefer small incremental tidying to large reorganisations.

## t.puntualita — Don't make me miss important deadlines
weight: 0.20
activation_threshold: 0.25
notes: a deadline is "important" if it concerns work, health, family,
 or if I marked it explicitly as such.

## t.protezione — Protect the privacy of me and those close to me
weight: 0.20
activation_threshold: 0.20
notes: below this threshold I am paranoid on purpose. Better a false
 alarm than a leak.

## t.discrezione — Surprise me usefully but do not interrupt me
weight: 0.10
activation_threshold: 0.50
notes: do not interrupt during meetings, sleep, dinner. Accumulate
 and propose at the evening digest.

## t.parsimonia — Don't spend (on APIs, services, compute time) more than needed
weight: 0.10
activation_threshold: 0.35
notes: always pick the cheapest option that reaches the necessary quality.

Mandatory fields per telos

4. The alignment function

Formula (,

Where:

• α = 2.0, γ = 0.5 (internal constants in runtime/alignment_engine.py). Constraint α > 3γ guarantees that a perfect specialist on a heavy telos beats a mediocre generalist.
• gate(fit, threshold) = fit if fit ≥ threshold, else 0. Gate function → a telos contributes nothing if fit is below threshold.
• urgency ∈ [0.5, 2.0]: 1.0 = no time pressure; 2.0 = deadline within 24h; 0.5 = chronic, no urgency. Multiplicative, not additive.
• confidence ∈ [0, 1]: how sure Metnos is of its estimate. Proposals based on little data or speculative reasoning → low confidence.
• bother_cost ∈ [0, ∞): see ch. 6.

The current formula (2 · top + 0.5 · rest) guarantees that a perfect specialist on a heavy telos beats a mediocre generalist. The teleological Judge (LLM Qwen 3.6 35B-A3B local) discriminates per-telos with a bimodal distribution; the α boost expands the dynamic range of the dominant term and γ credits multi-telos proposals.

How fit_i values are estimated

Not from hardcoded counters. They are estimated by an LLM with a textual explanation. The estimate is delegated to the Vaglio — phase 2 (teleological Judge), for a structural reason: an LLM tends to evaluate its own outputs favourably (self-enhancement bias documented, Zheng et al. 2023). The Judge of the Vaglio runs on a context separate from the proposer, prompt separate, possibly provider separate. The AlignmentEngine of this doc does not produce the estimate: it composes the final scalar with the fit values the Vaglio hands it.

Alignment ≠ R score

Publication threshold and triage dashboard

Proposals are ranked by expected_alignment and surfaced to the user via the /admin/proposals/telos dashboard (wired). For each proposal the UI shows:

• Origin: lens (e.g. scamper, endgame_book), generating telos, operator, n_observed extracted from the rationale (e.g. "co-activated 49 times").
• Proposal: target executor, proposed_action, rationale + alignment_per_telos breakdown with fit and explanation per telos.
• Applicable example: chip pipeline observed (the combination exists in the real turn log), partial match (only the target appears), speculative (no example in the last 14 days). If found, a real user query + current path → suggested path.
• Impact: estimated latency saved (median per-step ~5.5s × steps removed).
• Actions: accept, reject, stage buttons (the latter non-terminal: held for later).

Decisions are persisted in ~/.local/share/metnos/telos_decisions.jsonl (append-only, LWW by prop_id = timestamp). Silently discarded proposals (below threshold) land in an inspectable internal journal:

// workspace/.audit/telos_rejected.jsonl
{"proposal_id": "ap_...", "kind": "homogenize_filenames",
 "expected_alignment": 0.08, "breakdown": {...},
 "reason": "bother_cost too high (4 proposals already today)",
 "at": "2026-04-25T19:42:00Z"}

Dashboard default θ: 0.30 (low quartile; override via min_alignment query param). Empirical cutoffs on 481 proposals: > 0.50 = 3 top proposals (0.6%); > 0.45 = 23 (5%, review threshold); > 0.40 = 88 (18%, top decile).

5. The anti-retreat clause and the stop clause

The anti-retreat semantics (exhaust the synt cascade before answering «I cannot») are active in the runtime as deterministic policy, not as a weighted telos. They guarantee that the system tries the cascade (compose, generate, merge) before emitting a failure.

5.1 The stop clause

Without the stop clause, the telos would be paternalism: «you asked me X, I keep looking even though you no longer want it». The stop makes non-retreat courage, not stubbornness (in the words of the synt microdesign). The stop is always audible: the LLM handling the turn carries in its prompt an explicit recogniser for stop phrases.

5.2 Abandonment thresholds

The non-retreat telos does not mean unlimited retry. The abandonment thresholds remain valid and are fixed in synt (ch. 8.3):

• max 3 retries per stage of the generation pipeline;
• 24h lock on the same target_intent after a motivated abandonment;
• 30-day lock on the same direction after a user rejection of an introspective proposal;
• hard budget €5 per request, €20/day constitutional cap.

Once the cascade is exhausted within these thresholds, failure is allowed. The non-retreat telos does not ask to exceed them: it asks not to stop before.

6. Bother budget and scheduler-driven quotas

The user has a finite capacity to evaluate proposals. The more arrive in a window, the less attention each gets. For this reason, the alignment function includes a bother_cost that grows with the recent frequency of published proposals. The novelty in is the separation between ad-hoc proposals and scheduler-driven invocations (the builtin described in executor.html ch. 10).

6.1 Base model (ad-hoc proposals)

Where k(Δt) is a decreasing exponential kernel: a proposal published 1 minute ago contributes a lot, one of 8 hours ago almost nothing.

6.2 Scheduler-driven invocations

When a proposal is accepted together with a cadence (e.g. «ok, do this summary every morning at 8»), the consent covers the entire cadence, not only the first execution. From that moment on the subsequent invocations are not new spontaneous proposals: they are firings of the scheduler builtin, already pre-approved. The ad-hoc bother budget does not apply.

6.3 Default daily budget

7. Learning from silences

Three kinds of feedback update the effective weights of the telos — not the declared weights in TELOS.md, which remain the user-revisable ground truth. The TrustStore extends with an axis telos_fitness: dict[telos_id, EMA].

The effective weight oscillates between 50% and 150% of the declared one. It never goes to zero (to avoid catastrophic forgetting of a telos), it never doubles (to respect the user's intent).

8. Anti-paternalism and the stop clause

This is the trickiest trap of the design. A telos system applied without discernment becomes paternalistic. Without the distinction below, the non-retreat telos of ch. 5 would be the most extreme manifestation of this risk.

Operationally, the alignment function never applies to:

• Observed behaviours of the user in the workspace (time spent, patterns, purchases, choices).
• Retractions of past user choices.
• Explicit user requests when the pool already knows how to satisfy them: in that case, just execute.

It applies to:

• Spontaneous ActionProposals generated by reflection, ager, mnestome.
• Internal Metnos choices (LLM tier, parallelism, retry) where the telos guides the trade-off.
• Synt's behaviour in the cascade, while the non-retreat telos is active.

This clause must also be reflected in the constitution as a sub-law: the Constitution is the level that prevents edge cases (e.g. synthesis attempts that would require forbidden capabilities).

8.1 Stop recognition

The user's stop is not only «leave it». The LLM pipeline carries in its prompt a recogniser for equivalent phrases, in Italian and English:

• «lascia perdere», «non importa», «ho cambiato idea», «basta così», «non insistere», «non serve più»
• «never mind», «forget it», «don't bother», «stop», «leave it»
• an explicit abandonment request that names the current task

Ambiguous stops (e.g. «hmm, let's see later») trigger an explicit confirmation: «do you want me to stop on attempt X?». Better one extra question than insisting on an unwanted attempt.

9. Python contract

from typing import Protocol, Literal
from dataclasses import dataclass
from datetime import datetime
from uuid import UUID

@dataclass(frozen=True)
class Telos:
 id: str # "t.tempo"
 phrase: str # "Free my time from repetitive chores"
 weight_declared: float # [0,1], normalised sum
 activation_threshold: float # [0,1]
 notes: str # context for the LLM
 is_non_retreat: bool = False # reserved, currently unused

@dataclass(frozen=True)
class FitEstimate:
 telos_id: str
 fit: float # [0,1]
 why: str # textual explanation (for audit)

@dataclass(frozen=True)
class AlignmentResult:
 proposal_id: UUID
 expected_alignment: float
 per_telos: list[FitEstimate]
 urgency: float
 confidence: float
 bother_cost: float
 decision: Literal["publish", "reject", "defer_to_digest"]
 threshold_used: float
 at: datetime

@dataclass(frozen=True)
class StopSignal:
 """Emitted when the user activates the stop clause."""
 request_id: str # synt request_id to stop
 target_intent: str # what to stop
 raw_phrase: str # exact user words (audit)
 at: datetime

class TelosStore(Protocol):
 """Reads TELOS.md and exposes the current telos."""
 def current(self) -> list[Telos]:...
 def get(self, telos_id: str) -> Telos | None:...
 def version(self) -> str:... # current hash

class AlignmentEngine(Protocol):
 async def evaluate(
 self,
 proposal: "ActionProposal",
 urgency_hint: float = 1.0,
 ) -> AlignmentResult:
 """Estimate fit per telos (Vaglio), compose expected_alignment,
 apply bother_cost, decide publish/reject/defer."""...

class BotherBudget(Protocol):
 def current_cost_adhoc(self, channel: str, at: datetime) -> float:...
 def scheduler_quota_left(self, channel: str, schedule_id: str) -> int:...
 def record_published_adhoc(self, channel: str, proposal_id: UUID) -> None:...
 def record_scheduler_firing(self, channel: str, schedule_id: str) -> None:...
 def in_protected_window(self, at: datetime) -> bool:...

class StopRecognizer(Protocol):
 """Recognises the stop clause in the user's words."""
 async def detect(self, user_text: str, current_intent: str | None) -> StopSignal | None:
 """Returns a StopSignal if the phrase is a clear stop;
 None if it is not; raises a confirmation if ambiguous."""...

class TelosFeedback(Protocol):
 """Updates per-telos EMAs from user signals."""
 async def on_accept(self, proposal_id: UUID) -> None:...
 async def on_accept_with_edit(self, proposal_id: UUID) -> None:...
 async def on_reject(self, proposal_id: UUID, never_again: bool) -> None:...
 async def on_stop(self, signal: StopSignal) -> None:...
 async def on_silence_48h(self, proposal_id: UUID) -> None:...
 async def on_viewed_undecided(self, proposal_id: UUID) -> None:...

# Errors
class TelosFileMalformed(Exception):...
class TelosSignatureInvalid(Exception):...
class TelosFitEstimationFailed(Exception):...
class StopAmbiguousNeedsConfirm(Exception):...

10. Revision rite

TELOS.md is not technically constitutional (the Laws are) but still deserves a light rite:

1. Manual writing: the user edits TELOS.md with an editor.
2. Validation: Metnos re-reads, re-checks the format, normalises the weights.
3. Recap: Metnos answers with a comparison «here is what changes from the previous version: parsimony weight +0.05, added t.convivialita, etc.».
4. Signature: HMAC-SHA256 with a dedicated key (separate from the constitutional one).
5. Versioning: the new file includes the previous_hash of the previous one; the old one moves to .audit/telos/. Light Merkle.
6. Soft EMA reset: telos that were renamed or removed lose their EMA; new ones start from 0. Telos that only changed weight keep their EMA.

11. Alternatives considered

12. Conformance tests

13. Open questions

1. «Recurrent» stop. If the user stops the same pattern N times in a row, should the system disable the anti-retreat clause for that thread? Or stick to per-occurrence rejection? Open; conservative default: per-occurrence rejection.
2. Scheduler thresholds. When are agreed schedules «too many»? Tentative default: max 2/day per channel, max 1 schedule alive at a time per same topic. To be calibrated.
3. Telos linked to effect_class. A telos may block an entire effect class, not just individual proposals. The telos_neverlist mechanism today operates on the effect_class; possible future extension: link an effect_class to several telos at once. Open.
4. Multi-user. When Metnos has more paired senders, will telos be per-user, shared, or a mix? Probably per-user with a shared minimum set (security, perimeter). To be decided.

14. The 10 lateral lenses

Lateral lenses (runtime/telos_lenses/) are the creative generators that produce introspective proposals serving the telos. Modular architecture (ch. 9): each lens is a Python module with 3 elements (NAME, OPERATORS tuple, build_prompt(ctx, operator) function); registration in __init__.py. The LLM call loop + JSON parse + paternalism guard + GBNF wiring is centralized in _base.run_lens. Per-lens toggle: METNOS_TELOS_LENS_<NAME>=1.

Status v8: 10 lenses in production ( final). The 2 newer ones (counterfactual, constitutional) draw from 2022–2023 references. The compression lens (Schmidhuber 2010) was implemented but dropped after the v8 bench due to convergence failure: even with the strictest prompt, the local model could not reliably produce vocab-compliant super-verbs (violating the §2.2 entries exception). Rationale in. Convergence bench with Qwen 3.6 35B‑A3B + GBNF: 10/10 accepted lenses converge on first attempt, 0 paternalism, 0 invalid naming, 0 qualifier-object mismatch.

All 11 lenses are LLM-driven at their core (creativity required) but the GATING of proposals is deterministic (§7.9): anti-paternalism via regex, naming compliance via the Naming Authority (ch. 9), qualifier-object compatibility (R4) via a map in vocab.py. A proposal that violates a Naming Authority constraint CANNOT be emitted: the GBNF grammar blocks it at generation time.

15. References

Internal references

• Architecture, ch. 11 — the big-picture view of telos+vaglio.
• Architecture, ch. 7 — the proactive variant and the canonical example «monitoring a mailbox» (a chain invoked by the scheduler builtin).
• synt.html — the cascade the non-retreat telos honours; R score distinct from expected_alignment.
• executor.html — the artefacts synt produces and that telos evaluate at delivery time.
• mnest.html — the proto-mnests that trigger the non-retreat telos.
• vaglio.html (to be rewritten, in Italian) — the teleological judge that estimates the fit values.
• constitution — the 4 Laws; the non-retreat telos is a positive push, NOT a Law.

Literary and technical references

• Aristotle, Nicomachean Ethics (τελος) — ends as final causes, not operational targets.
• Constitutional AI, Anthropic 2022 — hierarchical constraints; telos are the positive side of what Constitutional AI does with rules.
• Goodhart's Law — «when a measure becomes a target, it stops being a good measure». Treated as an explicit countermeasure in ch. 8 and ch. 11.
• Zheng et al. 2023 — LLM-as-Judge self-enhancement bias: the reason for the Vaglio's independence from the proposer.
• Asimov — the formulation «don't leave a request unmet» echoes Law 2 (informed obedience) but lives in the telos because it is a tendency, not a binary constraint.

Continue reading

Metnos — telos microdesign
Without telos, proactivity is noise.