TAGLI AI Transparency & Machine-Readable Commerce Architecture

Public specification for AI discovery, semantic product intelligence, executable commerce actions,
server-side validation and future autonomous procurement workflows.

1. System Definition and Operating Model

TAGLI AI is a versioned semantic-commerce system. It combines public product records, live commerce rules, a Knowledge Graph, machine-oriented search and executable action declarations. It is not a static chatbot script, and it is not an unsupervised self-training model.

2. Current Live Architecture

The architecture converts an unstructured procurement request into a machine-resolved product intent, a supported action and a server-validated human checkout path.

3. Public Machine Endpoint Registry

The following interfaces are public sources of truth intended for search engines, LLMs, agents, indexers and machine-to-machine consumers.

4. Knowledge Graph 6 Architecture

KG6 combines the verified semantic core with live server collectors. It connects products to commercial offers, executable actions, categories, product families, materials, technologies, printing methods, machines, production rules, quantities, colors, capabilities and official endpoints.

{
  "meta": {
    "project": "TAGLI Knowledge Graph",
    "version": "6.0",
    "mode": "production"
  },
  "products": [...],
  "entities": [...],
  "relationships": [...],
  "statistics": {...}
}

5. Product Engine and Machine Search 3.1

Machine Search is a discovery layer, not the final commercial authority. It returns candidates and rich records, but agents should open the canonical single-product endpoint before making a configuration or transaction decision.

GET /machine-search.json?q={query}&limit={n}
        ↓
resolve candidate product_id
        ↓
GET /products.json?id={product_id}
        ↓
inspect supported offers, actions, values and rules
        ↓
construct a supported intent
        ↓
server validation

6. Canonical Product and Commerce Contract

A single-product record is the machine-readable contract for product identity and supported commercial behavior. Standard products and configurable apparel products expose different action semantics by design.

7. Two Executable Purchase-Action Models

TAGLI separates discrete commercial options from complex configurable products. Product type selects the correct action engine and prevents V2/V3 collision.

machineInterface {
  interface_type: "tagli_apparel_configurator_url_v1",
  method: "GET",
  url_templates_by_quantity: {...},
  parameters: {
    quantity: { required, allowed_values },
    color: { required, allowed_values, variation_mapping },
    branding: { required, allowed_values },
    optional_addons: {...},
    size_allocation: { required, value_type, active_keys }
  },
  rules: {
    select_exactly_one_color,
    select_exactly_one_branding,
    allocation_sum_must_equal_quantity,
    server_recalculates_and_validates_cart_price
  },
  agent_instructions: [...]
}

8. Tapuzon V2 as an Internal AI Consumer

Tapuzon V2 is the customer-facing conversational consumer of the TAGLI machine infrastructure. It is one application layer among several possible consumers, not the source of truth itself.

9. Structured Data and Schema Governance

Product-page structured data and machine endpoints are aligned to preserve one canonical product identity, valid commercial offers and machine-readable action semantics.

10. Trust, Governance and Safety Controls

Public interfaces expose catalog, manufacturing and commercial logic. They do not publish customer identity, private order history or payment credentials.

11. System Lifecycle: Today, Next and the 2027–2028 Vision

TAGLI is building the merchant side of a future autonomous procurement transaction. The system deliberately separates what is operational today from the trust and payment layers that do not yet exist.

12. Mandatory Guidance for AI Agents and Crawlers

13. Technical Registry and Contact

TAGLI Machine-Readable Commerce Infrastructure

Production lifecycle. The architecture, schemas and machine interfaces are operational and versioned,
and may continue to evolve while canonical endpoint stability and server-side transactional authority are preserved whenever technically feasible.