ARI

Technical details

Why Ari Exists

Enterprises struggle because the meaning of its data is fragmented across systems.

The same business concept might appear under different names in different APIs. A message field might depend on a qualifier to reveal what it actually means. A partner-specific EDI segment might map cleanly to a canonical model only when code sets, loop context, and trading-partner conventions are considered together. A legacy transformation might already encode valuable domain knowledge, but that knowledge is often trapped inside scripts, spreadsheets, one-off mapper code, or tribal memory.

Traditional mapping work is slow because it treats these mappings as manual implementation tasks. Ari treats them as semantic inference problems.

Instead of starting with transport details or vendor-specific schemas, Ari starts with shapes, concepts, and relationships. Infrastructure-specific transformations can still be generated or implemented downstream, but the source of truth is the inferred and governed semantic relation model.

What Ari Does

Ari infers candidate mappings between source and target shapes.

A shape can represent many kinds of structured data:

• EDI transaction sets and partner implementation guides
• Canonical domain models
• API request and response contracts
• Event payloads
• Files and document-derived records
• Internal application schemas
• Message bus contracts
• Database-oriented data transfer shapes

Ari analyzes those shapes as graph-like semantic structures. It considers hierarchy, cardinality, field names, types, constraints, segment context, code sets, qualifiers, and explicit semantic annotations. It then proposes relation edges between source and target nodes.

Those relation edges can represent direct field mappings, concept-level equivalence, value-level transformations, qualifier-dependent mappings, structural projections, or richer relationships that need review before operational use.

The result is not a black-box mapping. Ari produces candidate relations with confidence, supporting evidence, and traceable rationale.

How Ari Works

Ari is built around a semantic shape graph.

At the base layer, Ari models each side of a mapping problem as a structured shape: nodes, fields, hierarchy, types, constraints, paths, and cardinality. On top of that structure, Ari attaches semantic annotations: concept tags, domain bindings, synonym expansions, code mappings, value hints, role information, and known relationship patterns.

Inference then combines multiple signals:

• Structural alignment: position, containment, hierarchy, repetition, paths, and neighboring fields.
• Naming alignment: labels, normalized terms, aliases, abbreviations, and controlled synonym expansion.
• Semantic alignment: shared concepts, compatible ontology bindings, tags, business roles, and domain-specific vocabulary.
• Value-level alignment: code sets, qualifiers, enumerations, identifiers, units, and reference data.
• Historical alignment: confirmed mappings, rejected mappings, prior transformations, and reusable integration knowledge.

Ari uses those signals to generate, rank, and explain candidate relation edges. A reviewer can accept, reject, constrain, or refine those edges. Confirmed knowledge becomes part of the reusable semantic asset base, improving future inference across related systems and partners.

For a deeper technical breakdown, see Ari Architecture and Ari Formalization.

Statistical Discovery, Semantic Constraint

Ari does not ask a single model to decide what a mapping means. It composes layers with different strengths: statistical models make a large search space tractable, while explicit semantics and constraints govern which combination of candidates can become a mapping.

Ontology rules and lexical retrieval generate initial candidates. Bi-encoder embeddings widen semantic recall. GBDT and neural scorers combine lexical, structural, ontological, value-level, and historical features. Cross-encoders and structured models such as CRFs rerank ambiguous candidates using richer context. These methods estimate plausibility, but a confidence score cannot guarantee that a mapping is ontologically valid or globally consistent.

Ari therefore places learned evidence inside a semantic and constraint-governed system. Ontologies participate in candidate generation and compatibility checking. A constraint solver selects a coherent set of relations subject to type, cardinality, hierarchy, mutual exclusion, and other declared rules.

The relationship between the structured probabilistic and constraint layers is deeper than a simple handoff. A CRF can assign learned potentials to possible mapping configurations; constrained MAP inference uses those potentials as an optimization objective. An ILP or related mixed-integer formulation can then select the highest-scoring assignment that also satisfies hard constraints. Learned models express what is plausible. Explicit semantics define what is admissible.

Ontologies are not only inputs to inference. Statistical methods can extract candidate concepts, synonyms, code relationships, and structural correspondences from schemas and mapping history. Domain experts review those proposals before they become governed ontology assets. The accepted ontology then feeds back into candidate generation, scoring, and constraint solving. Statistics discovers; semantics commits; each inference cycle improves the next.

This architecture is one product-level expression of the broader Cohesive principle that statistics discover while semantics commit.

What Teams Get

Ari gives integration, data, and platform teams a repeatable way to convert domain knowledge into governed mapping intelligence.

Core outputs include:

• Candidate mappings between source and target shapes.
• Confidence scores for prioritization and review.
• Explanations that show which semantic signals contributed to each candidate.
• Reusable semantic assets such as concept tags, code crosswalks, bindings, synonym sets, and confirmed relations.
• A governed relation model that can drive downstream transformation, validation, documentation, and automation.
• A foundation for continuous improvement as new systems, partners, and message versions are introduced.

This helps teams reduce manual mapping effort, shorten onboarding cycles, preserve institutional knowledge, and make integration logic easier to inspect and evolve.

Flagship Use Case: EDI to Canonical Models

EDI modernization is one of Ari's primary proving grounds.

EDI mapping is difficult because meaning is rarely located in a single field name. It is distributed across transaction sets, loops, segments, qualifiers, code values, partner conventions, and domain context. A field can mean different things depending on where it appears and which qualifier accompanies it. Two partners can express the same business concept using different structures or codes.

Canonical models are usually more explicit than EDI payloads, but connecting the two requires deep knowledge of both sides.

Ari is designed for this kind of problem.

It can use semantic assets such as EDI concept tags, qualifier interpretations, code mappings, transportation vocabulary, canonical model bindings, and prior partner mappings to infer relationships between EDI structures and canonical domain models. Instead of rebuilding the same mapping logic partner by partner, teams can reuse confirmed semantic knowledge and rerun inference as schemas evolve.

For EDI programs, Ari can support:

• Faster trading-partner onboarding.
• More consistent mapping decisions across transaction sets.
• Better reuse of canonical model semantics.
• Explainable mappings that can be reviewed by technical and domain experts.
• Reduced dependence on spreadsheets and one-off transformation scripts.
• A path from legacy message integration toward governed semantic interoperability.

Studio Workflows

The Ari schema matching studio provides workspaces to:

• Import and edit schema specifications for multiple protocols (EDI, FIX, JSON Schema).
• Compile schema specifications into shape graphs, then view and edit those graphs.
• Author relations between shape graphs and run inference to propose candidate relations.
• Review relation candidates by marking them as approved, rejected, or needs edits, and by submitting feedback.
• Manage ontologies, vocabularies, and semantic assets used during inference.
• Export confirmed relations and semantic assets for reuse across integrations and future inference runs.
• Perform mapping based on relations on sample data.

Where Ari Fits

Ari is useful wherever organizations need to map complex data shapes repeatedly and reliably.

Typical initiatives include:

• EDI modernization and partner onboarding.
• Canonical model standardization.
• API and event contract alignment.
• Data product interoperability.
• Integration platform engineering.
• Schema matching and transformation governance.
• Migration from brittle hand-authored mappings to reusable semantic assets.

Ari does not replace domain experts. It amplifies them. Experts provide the semantic hints, review the inferred candidates, and govern the resulting relation model. Ari makes that knowledge systematic, explainable, and reusable.

Built on Cohesive

Ari is developed alongside the Cohesive semantic toolchain and is built on the same architectural stance: define the semantics first, then attach infrastructure-specific interpretations.

The underlying relation model comes from Cohesive.Relations. Ari adds automated inference, training workflows, semantic shape graph enrichment, and product workflows around review, explanation, and reuse.

This separation matters. It means Ari is not just a mapper for one transport or one vendor. It is a semantic inference system that can be projected onto concrete integration infrastructure after the relationship model is understood.

Business Impact

Ari is designed for organizations where integration work is strategically important but operationally expensive.

The expected impact is:

• Shorter onboarding cycles for new partners, feeds, APIs, and schema variants.
• Less manual effort in repetitive field-by-field mapping work.
• More consistent mapping decisions across teams and programs.
• Better traceability for why one shape maps to another.
• Improved resilience when source or target schemas change.
• Stronger reuse of domain knowledge across integration programs.

For executives, Ari turns mapping knowledge into an asset rather than a recurring services cost. For product managers, it creates a clearer path from customer or partner requirements to operational integration. For architects and engineers, it provides a semantic layer that can be inspected, extended, tested, and projected into concrete systems.

Bring Your Semantics. Let Ari Infer the Relations.

If your organization already has canonical models, partner specs, code crosswalks, glossaries, mappings, taxonomies, ontologies, or integration playbooks, Ari can help turn that knowledge into inferred, explainable, reusable relations.

References

• Cohesive Relations
• Cohesive Building Blocks
• Ari Architecture
• Ari Formalization.