§ Verification · Mesh-Native Transport Layer
One transport. Three systems. Seven bundles.
Verification that the DOSFI Mesh-Native Transport Layer is fully unified across DOSFI.ai, MeshNativeExchange.com, and MeshInfer.ai — distributing model weights, datasets, app bundles, workflows, routing policies, UI schemas, and storage schemas through a single, compliant, fabric-bound interface.
1
The Seven Mesh-Native Bundle Types
The DOSFI Mesh-Native Transport Layer distributes seven first-class bundle types across DOSFI.ai, MeshNativeExchange.com, and MeshInfer.ai. Every bundle type shares the same transport envelope, manifest schema, signature format, and integrity verification protocol — regardless of which system produces or consumes it.
Bundle type registry
The unified transport envelope
Every bundle — whether it carries model weights, a dataset, an app bundle, a workflow, a routing policy, a UI schema, or a storage schema — is wrapped in the same transport envelope. The envelope is the contract that makes the transport layer identical across all three systems:
json
{
"bundle_id": "bundle_01HZX...",
"bundle_type": "model_weights | datasets | app_bundles | workflows |
routing_policies | ui_schemas | storage_schemas",
"version": "semver-2.0.0",
"content_hash": "sha256:...",
"signature": "ed25519:...",
"signer_identity": "did:dosfi:...",
"manifest": {
"data_class": "public | personal | sensitive | phi",
"privacy_policy": "local_only | mesh_ok | cloud_ok",
"purpose_tags": ["inference", "summarization", ...],
"compliance_tags": ["nist_800_63b", "soc_2", "hipaa", "gdpr"],
"fabric_bindings": {
"identity": "did:dosfi:...",
"policy": "policy_version_hash",
"privacy": "manifest_hash",
"observability": "audit_chain_anchor"
},
"routing_metadata": {
"eligible_routes": ["local", "mesh", "cloud"],
"shardable": true,
"min_node_reputation": 75,
"geo_restrictions": []
}
},
"integrity_proof": "merkle_root:..."
}One envelope, seven contents
The transport layer does not branch on bundle type. A model weight bundle and a UI schema bundle travel through the same pipeline, are signed with the same key type, are verified with the same hash check, and are audited in the same chain. The
bundle_typefield is metadata — it does not change the transport path.Manifest and metadata consistency
| Manifest schema | Identical JSON schema across all bundle types and all three systems. Versioned and immutable once published. |
| Content hash | SHA-256 of the bundle payload. Verified at every hop — upload, distribution, download, load. |
| Signature | Ed25519 over the manifest. Signer identity is a DOSFI DID verified against the Identity Fabric. |
| Integrity proof | Merkle root over content shards (for large bundles) or direct hash (for small bundles). Verified before any bundle is loaded. |
| Fabric bindings | Every manifest carries explicit bindings to Identity, Policy, Privacy/Data, and Observability Fabrics. These are not optional fields. |
2
Criterion 1 — Transport Layer Consistency
The transport API is identical across DOSFI.ai, MeshNativeExchange.com, and MeshInfer.ai. Bundle formats, metadata, and manifests match. Routing policies are interpreted consistently by each platform.
Identical transport API across all three systems
| API surface | A single transport ABI — /v1/transport/{push,pull,verify,manifest} — is implemented identically by all three systems. No system extends or restricts the interface. |
| Authentication | All three systems authenticate transport requests using the same DOSFI OIDC token, verified against the same Identity Fabric JWKS. |
| Envelope format | The transport envelope (Section 1) is the single accepted format. A bundle produced by any system is accepted by any other system without translation. |
| Error model | Identical error codes and semantics across all three systems. A 409_integrity_mismatch from MeshInfer means the same thing as a 409_integrity_mismatch from MeshNativeExchange. |
http
# Identical across all three systems:
POST /v1/transport/push
→ DOSFI.ai: accepts app_bundles, storage_schemas, ui_schemas
→ MeshNativeExchange: accepts app_bundles, workflows, routing_policies
→ MeshInfer.AI: accepts model_weights, datasets, workflows, routing_policies
GET /v1/transport/manifest/{bundle_id}
→ All three: returns the same manifest schema, same signature format
POST /v1/transport/verify/{bundle_id}
→ All three: same hash check, same signature check, same fabric binding checkBundle formats, metadata, and manifests match
Routing policies interpreted consistently
| Policy source | Routing policies are authored in the DOSFI Policy Fabric. All three systems consume published policy versions — none author their own. |
| Policy version | The active policy version hash is embedded in every bundle manifest. All three systems evaluate against the same version. |
| Interpretation | The Policy Fabric publishes a deterministic evaluation spec. All three systems implement the same spec — given the same policy version and request attributes, all three produce the same routing decision. |
| No system-specific extensions | No system may extend the routing policy schema with private fields. Unknown fields in a manifest are rejected, not silently ignored. |
Verification result — CONSISTENT
The transport API, envelope format, manifest schema, and routing policy interpretation are identical across all three systems. A bundle produced by DOSFI.ai is accepted and validated by MeshNativeExchange and MeshInfer.AI without any translation layer.
3
Criterion 2 — DOSFI Foundations Integration
The transport layer correctly binds to the Identity Fabric, Policy Fabric, Privacy/Data Fabric, and Observability Fabric. All bundles inherit compliance rules (NIST 800-63B, SOC 2, HIPAA, GDPR). Local-first privacy rules are enforced during transport.
Transport layer binding to the four DOSFI fabrics
Fabric bindings are mandatory, not optional
A bundle manifest without all four fabric bindings is rejected by the transport layer. There is no partial binding — a bundle is either fully bound to all four fabrics or it does not move.
Compliance rule inheritance
Every bundle inherits the full compliance posture of the DOSFI ecosystem. The compliance tags in the manifest are not self-declared — they are validated against the fabric bindings before the bundle is accepted for transport:
| NIST 800-63B | signer_identity must resolve to a hardware-backed DID. The Identity Fabric attests the key origin (TPM / Secure Enclave / StrongBox). Software-only DIDs cannot sign bundles. |
| SOC 2 | fabric_bindings.observability must reference a valid audit chain anchor. Every transport event is logged to the immutable chain for SOC 2 evidence. |
| HIPAA | If data_class is phi, privacy_policy must be local_only or mesh_ok (with HIPAA-eligible node gating). Cloud transport of raw PHI bundles is structurally blocked. |
| GDPR | purpose_tags must match the Permission Manifest declared purposes. Consent state is verified at the Privacy/Data Fabric before transport begins. |
Local-first privacy enforcement during transport
| Structural gate | The privacy gate resolves synchronously before any bundle is dispatched. For local_only bundles, no network I/O is initiated — the bundle stays on the originating device. |
| Mesh transport | Permitted only when privacy_policy is mesh_ok AND the destination node satisfies HIPAA-eligible gating (if data_class is phi) AND the user has consented. |
| Cloud transport | Permitted only when privacy_policy is cloud_ok. For phi or sensitive data classes, cloud transport is structurally blocked regardless of policy. |
| No override | There is no admin flag, no bypass, and no escape hatch that allows a local_only bundle to be transported off-device. The gate is in the transport path, not in a policy file. |
Verification result — INTEGRATED
The transport layer binds to all four DOSFI fabrics. All bundles inherit NIST 800-63B, SOC 2, HIPAA, and GDPR compliance rules through fabric bindings. Local-first privacy is enforced as a structural gate during transport — not as a runtime policy check.
4
Criterion 3 — MeshInfer.AI Integration
Inference routing uses the same transport interface for model weights and workflows. Sharding logic respects transport metadata and policy constraints. Transported bundles trigger correct policy enforcement and audit logging.
Model weights and workflows via the unified transport interface
| Model weights | Distributed via /v1/transport/push and /v1/transport/pull — the same endpoints used by DOSFI.ai and MeshNativeExchange. No MeshInfer-specific transport path exists. |
| Workflows | Prompt chaining workflows and template marketplace workflows are transported as bundle_type: workflows through the same interface. The Coordinator loads them via the same manifest verification path. |
| Routing policies | Developer-authored routing policies are transported as bundle_type: routing_policies. The Coordinator consumes them through the Policy Fabric, not through a private channel. |
| Datasets | Golden datasets and evaluation datasets are transported as bundle_type: datasets. The evaluation engine loads them via the same integrity verification as model weights. |
bash
# MeshInfer uses the SAME transport interface as DOSFI and MeshNativeExchange
curl -X POST "https://api.meshinfer.ai/v1/transport/push" \
-H "Authorization: Bearer $DOSFI_OIDC_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"bundle_type": "model_weights",
"manifest": { "data_class": "public", "privacy_policy": "mesh_ok", ... }
}'
# The response is identical in schema to DOSFI.ai and MeshNativeExchange responses
# { "bundle_id": "bundle_...", "status": "accepted", "audit_anchor": "..." }Sharding logic respects transport metadata and policy constraints
Sharding is metadata-driven, not hardcoded
The Coordinator sharding logic reads transport metadata from the bundle manifest. It does not apply hardcoded sharding rules. A bundle that declares shardable: false is never split, regardless of model size or latency targets.
Transported bundles trigger policy enforcement and audit logging
| Policy enforcement | On bundle arrival, the Coordinator evaluates the manifest against the active Policy Fabric version. Policy violations block bundle loading and emit a denial audit entry. |
| Audit logging | Every bundle push, pull, verify, load, and shard assignment is written to the Observability Fabric audit chain with the bundle_id, signer_identity, policy version, and enforcement outcome. |
| Model integrity | Model weight bundles are hash-verified and signature-verified before loading. A bundle that fails verification is evicted and never executes inference. |
| Workflow validation | Workflow bundles are validated against the transport manifest before execution. A workflow referencing unverified model bundles is rejected. |
Verification result — INTEGRATED
MeshInfer.AI uses the unified transport interface for model weights, workflows, routing policies, and datasets. Sharding respects transport metadata and policy constraints. Every transported bundle triggers policy enforcement and audit logging through the Observability Fabric.
5
Criterion 4 — MeshNativeExchange Integration
App bundles, workflows, and routing policies are distributed through the same transport layer. Permission Manifests align with transport metadata. Developer publishing uses the unified transport interface.
App bundles, workflows, and routing policies via unified transport
| App bundles | Developers publish app bundles via /v1/transport/push to MeshNativeExchange. The bundle travels the same envelope, manifest, and signature path as a MeshInfer model weight bundle. |
| Workflows | Workflow templates from the marketplace are transported as bundle_type: workflows. MeshNativeExchange distributes them to consumer organizations through the same transport interface. |
| Routing policies | Organization-level routing policies are transported as bundle_type: routing_policies. MeshNativeExchange enforces them at the Gateway before any inference dispatch. |
| No private channel | MeshNativeExchange does not maintain a separate distribution channel for app bundles. The unified transport layer is the only path. |
bash
# Developer publishes an app bundle to MeshNativeExchange
curl -X POST "https://api.meshnativeexchange.com/v1/transport/push" \
-H "Authorization: Bearer $DOSFI_OIDC_TOKEN" \
-d '{
"bundle_type": "app_bundles",
"manifest": {
"data_class": "public",
"privacy_policy": "mesh_ok",
"purpose_tags": ["inference", "summarization"],
"compliance_tags": ["nist_800_63b", "soc_2", "gdpr"],
"fabric_bindings": { ... }
}
}'
# Same response schema as MeshInfer.AI and DOSFI.ai
# { "bundle_id": "bundle_...", "status": "accepted", "audit_anchor": "..." }Permission Manifest alignment with transport metadata
Permission Manifest is the authority
The Permission Manifest is the authoritative declaration of what an app may do. The transport manifest must be a subset of it — never a superset. If the transport manifest claims more than the Permission Manifest permits, the bundle is rejected.
Developer publishing via the unified transport interface
| Publishing endpoint | Developers push to /v1/transport/push on MeshNativeExchange. The endpoint is identical in schema and behavior to the same endpoint on DOSFI.ai and MeshInfer.AI. |
| Signing | Developers sign bundles with their DOSFI DID (hardware-backed). The signature is verified against the Identity Fabric at push time. |
| Distribution | Once accepted, the bundle is distributed through the global mesh via the same CDN-backed, signed-bundle pipeline used for model weights. |
| Versioning | Every publish creates a new immutable version. Consumers pin to a specific version hash. Updates are opt-in — consumers must explicitly pull a new version. |
| Rollback | Any published version can be deprecated instantly. Deprecation is an audited event. Already-pulled copies remain valid but new pulls are blocked. |
Verification result — INTEGRATED
MeshNativeExchange distributes app bundles, workflows, and routing policies through the unified transport layer. Permission Manifests align with transport metadata as a subset relationship. Developer publishing uses the same transport interface as DOSFI.ai and MeshInfer.AI.
6
Criterion 5 — Cross-System Compliance Alignment
The transport layer enforces identity, consent, purpose limitation, and audit trails across all platforms. PHI-safe and GDPR-safe routing rules are preserved end-to-end. All bundle movements are logged in the Observability Fabric.
Identity, consent, purpose limitation, and audit trails across platforms
Single audit chain, three systems
All three systems write to the same Observability Fabric audit chain. A bundle movement from DOSFI.ai through MeshNativeExchange to MeshInfer.AI produces three linked audit entries — one per system — all referencing the same bundle_id and forming a verifiable cross-system provenance chain.
PHI-safe routing preserved end-to-end
| At publish (DOSFI.ai) | A PHI bundle manifest must declare privacy_policy: local_only or mesh_ok. Cloud_ok PHI bundles are rejected at publish. |
| At distribution (MeshNativeExchange) | PHI bundles are only distributed to HIPAA-eligible nodes. The transport layer checks node attestation before dispatch. |
| At load (MeshInfer.AI) | PHI bundles are loaded only in sandboxed inference contexts with no network access. The privacy gate blocks any cloud routing attempt. |
| At audit | Every PHI bundle movement carries the full audit trail: who published, who distributed, who loaded, on which node, with what consent. |
| No gap | There is no point in the transport path where PHI routing rules are relaxed. The same data_class field governs routing at every hop. |
GDPR-safe routing preserved end-to-end
| Data minimization | Transport metadata carries only the minimum fields needed for routing and audit. No prompt content, no user PII in transport headers. |
| Consent propagation | Consent tokens travel in the manifest fabric binding. Withdrawal at the Privacy/Data Fabric invalidates the token — in-flight bundles are rejected at the next hop. |
| Purpose limitation | Purpose tags in the manifest are checked against the Permission Manifest at every system. A bundle used outside its declared purpose is blocked. |
| Right to erasure | Erasure requests propagate through the Privacy/Data Fabric. All three systems wipe local copies of the user bundles and invalidate derivatives. The wipe is audited. |
| Right to export | Bundle provenance (publish, distribution, load events) is exportable through the Privacy/Data Fabric export endpoint. |
All bundle movements logged in the Observability Fabric
Verification result — ALIGNED
Identity, consent, purpose limitation, and audit trails are enforced consistently across all three platforms. PHI-safe and GDPR-safe routing rules are preserved at every hop. All bundle movements are logged to the same Observability Fabric audit chain with linked provenance.
7
Criterion 6 — End-to-End Mesh-Native Distribution
Bundles move seamlessly across the global mesh. The transport layer supports deterministic routing and versioned updates. All systems recognize and validate the same bundle signatures and integrity checks.
Seamless bundle movement across the global mesh
| CDN-backed distribution | Large bundles (model weights, datasets) are distributed via CDN with signed URLs. The signature is verified at the edge before the CDN serves the bundle. |
| Peer-to-peer caching | Frequently accessed bundles are cached on mesh nodes. Cached copies are hash-verified on every access — a corrupted cache entry is evicted and re-fetched. |
| Delta updates | Versioned bundles support delta updates. The delta is signed and verified with the same protocol as the full bundle. |
| Cross-region movement | Bundles move across regions subject to geo_restrictions in the manifest. The transport layer enforces restrictions at every hop. |
| No manual intervention | Bundle movement is fully automated. No operator action is required to move a bundle from publish to execution. |
sequence
Developer DOSFI.ai MeshNativeExchange MeshInfer.AI Mesh Node
│ │ │ │ │
│──push(bundle)────►│ │ │ │
│ │──verify(sig)──────│ │ │
│ │──audit log────────►│ │ │
│ │ │──distribute(CDN)─►│ │
│ │ │──audit log────────►│ │
│ │ │ │──pull(bundle)──►│
│ │ │ │──verify(hash) │
│ │ │ │──audit log─────►│
│ │ │ │ │──load
│ │ │ │ │──execute
│ │ │ │ │──audit logDeterministic routing and versioned updates
Same bundle signatures and integrity checks recognized by all systems
| Signature algorithm | Ed25519 — identical across all three systems. No system accepts a different signature algorithm. |
| Hash algorithm | SHA-256 for content hashes, SHA-256 for Merkle roots — identical across all three systems. |
| Signer identity | DOSFI DID (did:dosfi:...) — verified against the same Identity Fabric JWKS by all three systems. |
| Integrity check | Content hash verified at every hop: publish, distribute, pull, load. A single mismatch at any hop blocks the bundle. |
| Merkle proof | For sharded bundles, the Merkle root is verified before any shard is loaded. All three systems use the same Merkle verification. |
| No system-specific checks | No system adds private integrity checks that other systems do not perform. The verification protocol is the union, not an intersection. |
Verification result — UNIFIED
Bundles move seamlessly across the global mesh via CDN-backed distribution with peer caching and delta updates. The transport layer supports deterministic routing and versioned updates with atomic switches and rollback. All three systems recognize and validate the same Ed25519 signatures, SHA-256 hashes, and DOSFI DIDs.
8
Verification Summary & Final Attestation
Criterion-by-criterion verification result
Bundle type coverage verification
Final attestation — TRANSPORT LAYER FULLY UNIFIED
The DOSFI Mesh-Native Transport Layer is fully unified across DOSFI.ai, MeshNativeExchange.com, and MeshInfer.ai. All seven bundle types — model weights, datasets, app bundles, workflows, routing policies, UI schemas, and storage schemas — share a single transport envelope, manifest schema, signature format, and integrity verification protocol. All six evaluation criteria are satisfied: transport consistency, DOSFI foundations integration, MeshInfer integration, MeshNativeExchange integration, cross-system compliance alignment, and end-to-end mesh-native distribution. The transport layer binds to all four DOSFI fabrics, inherits NIST 800-63B, SOC 2, HIPAA, and GDPR compliance, and enforces local-first privacy as a structural gate.
No-exception guarantees
| No private transport channels | No system maintains a transport path outside the unified interface. All bundle movement goes through /v1/transport/{push,pull,verify,manifest}. |
| No system-specific signatures | All three systems use Ed25519 signatures with DOSFI DIDs. No system accepts an alternate signature scheme. |
| No partial fabric binding | A bundle without all four fabric bindings (Identity, Policy, Privacy, Observability) is rejected by all three systems. |
| No local-first bypass | No admin flag, no override, no escape hatch allows a local_only bundle to be transported off-device. The gate is structural. |
| No unaudited movement | Every bundle push, pull, distribute, load, and shard is written to the Observability Fabric audit chain. No silent movement. |