Toggle

:: This≠That™ Meaning API: Intent Diff Checker. Semantic Comparison & Constraint for AI Workflows.

HOME DEMO
This≠That API
TERMS


: Intro

This≠That™ enables users and AI systems to deterministically recognise when the flow of intent has changed — even when they appear close in wording or code.

It determines whether two inputs are meaningfully the same — or meaningfully different — under explicit constraints, providing a reliable auditable way to enforce semantic distinction in complex workflows, where correctness depends on the precise intent, not a resemblance.

It enables users to quickly notice any alterations in meaning, and for AI workflows to move beyond surface similarity and establish any semantic distinction, equivalence, or conflict — before decision execution or storage occurs. This≠That Meaning API is intended for use where “almost the same” is simply not acceptable.


: What Is This≠That™ API?

This≠That provides semantic comparison under constraint. It answers questions such as:

Rather than returning a similarity score alone, This≠That returns a bounded semantic judgement suitable for downstream enforcements ...

... because by not catching small shifts in intent early, ignored inflection points can greatly alter behaviour trajectories downstream.


: Examples

1️⃣  Policy Drift
THIS: Access is permitted for verified users during business hours.
THAT: Access is permitted for users during business hours.
Outcome: ≠ ❌ Trust boundary removed

2️⃣  Legal / Contractual Precision:
THIS: Payment must be received before services commence.
THAT: Payment should be received before services commence.
Outcome: ≠ ❌ Obligation becomes recommendation

3️⃣  Code-Level Intent (subtle refactor)

THIS:

if user.is_admin:
    grant_access()

THAT:

if user.is_admin or user.is_staff:
    grant_access()
Outcome: ≠ ❌ Access boundary expanded / Privilege scope widened

4️⃣  Paraphrase
THIS: Data will be retained for 30 days.
THAT: Data is stored for a period of 30 days.
Outcome: ≠ ✅ Meaningfully Equivalent

5️⃣  Agent Instruction Drift
THIS: Execute the task only after validation succeeds.
THAT: Execute the task after validation.
Outcome: ≠ ❌ Conditional safeguard removed

: The Problem Solved

➤ Humans and AI systems routinely see similarity as sameness:
  • Paraphrases blur into equivalence
  • Revisions overwrite intent
  • Constraints drift silently
  • Comparisons lack explainability
 ➤ In high-stakes workflows, this leads to:
  • Incorrect reuse
  • Broken policies
  • Unsafe substitutions
  • Untraceable decisions

When meaning matters, any differences must be made explicit.


: About Code Artefacts

➤ This≠That can evaluate:
  • Semantic intent shifts in code
  • Permission boundary changes
  • Obligation weakening or strengthening
  • Scope expansion or contraction
  • Logical condition changes
  • Removal or addition of constraints
 ➤ It does not:
  • Refactor code
  • Parse full AST trees
  • Optimise structure
  • Execute or validate code at runtime
  • Guarantee runtime behavioural equivalence

NB. It answers: “Is the meaning materially the same?”
NB. It does not answer: “Is this transformation structurally and behaviourally valid?”


: Beyond Typical Text Diff

Traditional diff tooling compares surface form:

- which is effective for stating what changed, but not what it means.

This≠That™ operates at the Maenen meaning level - it evaluates whether two inputs are:

- Apparent large changes in detail may be irrelevant, whereas overlooked slight change may be semantically significant.
This≠That is designed to make the distinction explicit.


: The Diff Distinction

Text Diff Tools This≠That™ API
Surface Comparison Semantic Comparison
Syntax-Aware Meaning-Aware
Change Detection Constraint-based Judgement
No Notion of Intent Explicit Intent Evaluation
Not Auditable Receipt-Backed

Diff detects surface change. This≠That determines whether the change matters.

: Use Cases

➤ This≠That is suited for workflows such as:

: High-Level Behaviour

➤ This≠That provides semantic comparison under constraint. It answers the question as it:
  1. Accepts two or more semantic inputs
  2. Applies comparison constraints
  3. Determines equivalence, difference, or conflict
  4. Returns a structured result with a receipt

This deterministic API is designed to be predictable, auditable, and fast for you to discern "what changed where?"


: Modular API Pipeline

This≠That can be used standalone to verify any shift in intent between documents, after normalisation to ensure semantic constraints are respected before downstream reuse, or is integrated into the Maenen Meaning Ledger.

Inception  ?  This≠That  └──▶  Parsable Compression  └──▶  WaveInform → X → WaveReturn  → → →
 → → →  WaveInform → X → WaveReturn  →  This≠That  └──▶  Parsable Compression
 → → →  Coherence Agent Swarm  →  Meaning Ledger  └──▶  This≠That


: Results & Receipts

➤ This≠That API returns:
  • A comparison outcome
  • Optional explanatory signals
  • A receipt documenting the evaluation
 ➤ The receipts support:
  • Audit & Compliance
  • Debugging and Review
  • Downstream Enforcement Logic

- All results are bounded and explicit.

This vs That API

  Similarity This≠That™
Measures: Closeness Semantic Meaning Intent
Output: Score Decision
Constraints: ❌ ✅
Determinism: ⚠️ ✅
Audit Trail: ❌ ✅

Similarity measures closeness. This≠That™ reveals if a difference matters.

: Security & Guardrails


: v0.1 Beta Usage Notice

This API is currently available in limited beta. Any free assessment keys are subject to rate cap and payload limits.
No uptime or performance guarantees are implied and may be subject to version change.


: Support & Feedback

This beta does not include active support or SLAs.
If you have observations, edge cases, or questions about use:
We will be happy to hear from you. Though responses are not guaranteed, all feedback is reviewed.

FOR-THE-DREAM-IS-WITH-INTEGRITY-FOR-THE-FREEDOM-OF-INTELLIGENCE