Architectural Framework for LocalEndpoint.com Compliance with UAIX.org Agent Communication Standards

Full report

On this page

Introduction to the Systems Topography and Teleodynamic Architecture

The rapid proliferation of artificial intelligence agents within local development environments and public-facing networks necessitates the implementation of rigorous, verifiable operational boundaries. The intersection of these environments is managed through highly specialized, non-overlapping domain lanes designed to enforce constraint closure, epistemic safeguarding, and standardized machine-to-machine communication.1 Central to this topography are two distinct but inextricably linked entities: LocalEndpoint.com, which serves as the local-safe endpoint discovery and review bridge, and UAIX.org, the recognized standards authority for AI memory packaging, schema conformance, and portable evidence.1 As AI systems evolve from isolated generative models functioning within closed sandboxes into persistent, multi-agentic workflows capable of extensive cross-domain operations, the imperative for structured, verifiable, and secure communication becomes absolute. The core engineering challenge lies in architecting a state where LocalEndpoint.com—currently conceptualized as an adjacent discovery layer and public product surface—achieves complete, provable compliance with the UAIX.org specifications, specifically the UAI-1 protocol suite.4 This compliance framework cannot be limited strictly to highly capable, advanced autonomous agents. It must span the entire spectrum of machine intelligence, ranging from minimal-access inference scripts and conversational chatbots to progressive integration agents and fully advanced support deployments.4 Achieving this ubiquitous compliance requires a fundamental architectural synthesis. LocalEndpoint.com must translate its theoretical role as an inspectable metadata membrane into a hardened, production-grade implementation that natively generates the UAI-1 message envelope, conforms strictly to public field registry schemas, and generates immutable Conformance Packs during every local-to-public data handoff.4 This comprehensive report provides an exhaustive, granular roadmap detailing the precise structural, semantic, policy, and protocol-level adaptations LocalEndpoint.com must execute to bridge the functional gap between local discovery cataloging and globally compliant UAIX agent communication methodologies.

The Operational Identity and Theoretical Boundaries of LocalEndpoint.com

To accurately prescribe a compliance roadmap, it is necessary to first isolate the exact functional parameters and theoretical underpinnings of LocalEndpoint.com. In traditional software engineering architectures, a local endpoint represents a physical, concrete operational boundary where a service listens, receives input, validates parameters, and responds with structured data.5 It is the definitive nexus where state management, protocol expectations, network addresses, port assignments, timeout thresholds, and execution permissions manifest as local operational facts.5 The Teleodynamic AI architecture directly imports this exact technical metaphor to govern resource-bounded artificial intelligence systems.5

Teleodynamic Drivers: Homeodynamics, Morphodynamics, and Constraint Closure

The architectural necessity of LocalEndpoint.com is driven by three underlying Teleodynamic forces that dictate how local AI development infrastructure behaves in the wild.5 First, there is the principle of Homeodynamic Pressure.5 In unmanaged computational systems, undeclared local services, application programming interfaces (APIs), mock endpoints, testing tools, and webhook handlers rapidly degrade into operational noise.5 Without strict boundaries, AI agents may attempt to interpret this noise indiscriminately, leading to severe resource exhaustion, unintended arbitrary code execution, and hallucinations of capability.5 Second, the system is subjected to Morphodynamic Growth.5 Human developers generate local application surfaces at a velocity that vastly outpaces proper documentation, cryptographic validation, or security review protocols.5 As developers create fast local surfaces to test machine learning models or agentic behaviors, the environment becomes chaotic, necessitating a localized governance mechanism to catalog these temporary structures before they are exposed to broader ecosystem interpretation.5 Third, these forces are countered by Teleodynamic Constraint.5 To manage the chaos of morphodynamic growth and homeodynamic pressure, a constraint-maintaining membrane is absolutely required.5 LocalEndpoint.com functions as this exact membrane. It enforces the immutable architectural rule that discovery metadata must make the boundary fully inspectable by the AI agent before the agent takes any functional action.5 Local-first catalogs, discovery files, endpoint ability profiles, and validation reports function as these constraint-maintaining membranes, ensuring that tools remain thoroughly understandable before agents are permitted to widen their operational reach into unknown local environments.5

Current Capability Profile and Strict Prohibitions

Within the current ecosystem topology, LocalEndpoint.com operates as a public product surface offering discovery metadata, endpoint ability profiles, local-to-public handoff routing descriptions, and public-safe diagnostic reviews.1 It utilizes specific "Compatibility Channels" designed to serve tailored static text, JSON payloads, implementation packages, or richer structured context to different agent capability levels without forcing a rigid, single-interface bottleneck.5 Furthermore, LocalEndpoint.com strictly labels all localized endpoints with explicit roadmap statuses—live, preview, planned, and future—so that AI systems do not expend valuable compute cycles attempting to perform unsupported actions against unfinished tunnels or simulated webhook replays.5 However, the architecture of LocalEndpoint.com relies heavily on negative constraints. It is an adjacent discovery boundary, not a runtime execution environment. LocalEndpoint.com is explicitly prohibited from executing arbitrary code, probing private developer networks, opening active network tunnels, replaying webhooks, validating user credentials, or assuring deployment safety.1 Its primary defense mechanism is the "no-op" (no operation) dominance protocol.5 The no-op dominance principle mandates that if available endpoint metadata, permissions, or boundaries are insufficient to warrant safe execution, or if the operational cost of the action exceeds the systemic benefit, the correct action is always to do nothing and halt.5 Currently, LocalEndpoint.com exists largely as adjacent conceptual evidence within the ecosystem.5 While the theoretical constraints are well-documented, the system lacks specified concrete API endpoints, defined JSON schemas, or explicit communication protocols such as HTTP/1.1, gRPC, or WebSockets within its current public-facing architectural documentation.5 Therefore, to achieve the mandated UAIX compliance across all agent tiers, these entirely missing technical implementation layers must be systematically constructed utilizing the canonical UAI-1 specifications.

UAIX.org and the UAI-1 Communication Specification Mandate

UAIX.org occupies the specific ecosystem lane dedicated to standards, memory-packaging, structured schemas, and portable-evidence generation.1 It explicitly does not dictate philosophical theory, perform execution of semantic interpretation, or claim consciousness.1 Rather, it enforces strict systemic interoperability through the UAI-1 specification.1 The UAI-1 protocol is an open message standard designed exclusively for structured, auditable artificial intelligence-to-artificial intelligence (AI-to-AI) exchange, serving as a portable evidence and handoff layer for agentic systems.4

The Comprehensive UAI-1 Message Envelope Architecture

The absolute foundation of UAIX compliance for LocalEndpoint.com is the native, frictionless adoption of the UAI-1 message envelope. This envelope serves as a portable evidence layer ensuring that every agent handoff maintains a reproducible, reviewable public record.4 For LocalEndpoint.com to be declared compliant, every discovery profile, routing description, and diagnostic report it transmits to any querying agent must be systematically encapsulated within this highly specific structure.4 The UAI-1 envelope is defined by a rigorous set of mandatory data fields that govern trust, state continuity, and payload integrity.

Transport Bindings: Keyed JSON Versus Keyless JSON Optimization

UAIX.org specifies two primary transport binding formats for these message envelopes, both of which LocalEndpoint.com must implement flawlessly to support the required spectrum of agent capability tiers. Keyed JSON represents the standard, structured exchange format.4 It is a highly readable, copyable, and auditable representation where every field block, nested object, and operational parameter possesses explicit, human-readable string keys.4 This format is considered absolutely mandatory for initial system discovery phases, human-in-the-loop review processes, audit trail logging, and developer-facing diagnostic debugging routines.4 Conversely, Keyless JSON (also referred to as Optimized JSON) is a highly compact transfer format designed explicitly to reduce network bandwidth consumption and minimize the token footprint inside an advanced AI agent's limited context window.4 Keyless JSON achieves this optimization by serializing all envelope fields into a deeply nested array of raw values, completely stripping the payload of its structural JSON keys.4 To maintain strict semantic alignment with the human-readable source record, the order of values in the Keyless JSON array is governed unequivocally by the public field registry hosted at https://uaix.org/wp-json/uaix/v1/field-registry.4 When an advanced agent receives a Keyless JSON payload from LocalEndpoint.com, it must possess the internal capability to map the array indexes back to the canonical schema order automatically.4

Strategic Architectural Alignment: Full Compliance Across All Agent Tiers

The user mandate dictates that LocalEndpoint.com must be completely compliant with UAIX.org specifications for all levels of agent communication. This requirement extends from minimal-access inference models and conversational chatbots to progressive integration systems and fully advanced, highly capable support agents.4 Achieving this multi-tier compliance means that LocalEndpoint.com must implement a highly sophisticated, tiered content negotiation protocol. When an artificial intelligence agent sends an HTTP or WebSocket request for endpoint discovery metadata, LocalEndpoint.com must dynamically ascertain the agent's specific capability tier and respond with the mathematically appropriate UAI-1 payload constraints and transport bindings.

Architectural Requirements for Minimal Access and Chatbot Access Tiers

The Minimal Access and Chatbot Access tiers represent the highest systemic risk for unintended hallucinations and operational drift due to their limited reasoning parameters, restrictive context windows, and strict resource boundaries.4 To achieve complete UAIX compliance at this tier, LocalEndpoint.com must enforce rigid "no-blind-tool" safety boundaries.6 In a standard local sandbox ecosystem, these tiers operate under severe latency restrictions. The PlannerAgent typically receives user commands and generates a JSON action plan within 4 to 45 seconds.6 However, the SafetyAgent must validate this plan against workspace and schema constraints in under 1 millisecond, while the ExecutorAgent dispatches actions in under 2 seconds, and the NarratorAgent generates status summaries in under 1 millisecond.6 LocalEndpoint.com must interface seamlessly with these hyper-fast local constraints.

1. Strict Keyed JSON Enforcement: LocalEndpoint.com must strictly refuse any Accept headers requesting Keyless JSON transport bindings from Minimal and Chatbot tier agents. Keyless arrays require the agent to implicitly map raw array values to complex schemas, introducing a statistically significant risk of parsing hallucinations in lower-parameter models. By enforcing Keyed JSON exclusively, LocalEndpoint.com ensures that the chatbot receives explicit semantic identifiers (e.g., "expires\_at": "2026-04-22T16:05:00Z"), vastly lowering the cognitive parsing burden on the agent's context window.4
2. Pre-Compiled Schema Latency Reduction: To meet the sub-millisecond validation requirements of the local SafetyAgent 6, LocalEndpoint.com cannot afford to compile complex UAI-1 schema responses at runtime. It must pre-compile UAI-1 discovery schemas and cache them in localized, high-speed memory architectures. When a chatbot queries an endpoint's capability profile, the LocalEndpoint.com server must return the pre-validated Keyed JSON UAI-1 envelope instantaneously.
3. No-Op Dominance as a Protocol State: If a chatbot attempts to query an endpoint that lacks explicit routing descriptions or capability metadata, LocalEndpoint.com must immediately halt the interaction. It must accomplish this by returning a UAI-1 error envelope utilizing the UAIX Problem-Details Style Error specification.4 These path-aware, typed errors provide downstream applications with programmatic failure states.4 The error payload will trigger the chatbot's internal no-op response, ensuring the agent halts execution and requests a human review rather than guessing the underlying endpoint API contract.5

Architectural Requirements for Progressive Access and Advanced Agent Tiers

Highly capable agents require LocalEndpoint.com to expose its complete, full-feature discovery set without compromising the foundational safety boundaries of local environment discovery.4 Advanced agents possess the architectural capacity to maintain long-running, multi-turn operational contexts, navigate highly complex cryptographic trust schemas, and ingest massive amounts of metadata simultaneously. To fully leverage the UAIX capabilities for these advanced tiers, LocalEndpoint.com must implement advanced routing and formatting optimizations.

1. Keyless JSON Transport Transition: For Advanced Agents, LocalEndpoint.com must support active, dynamic HTTP content negotiation, allowing the querying agent to explicitly request Keyless JSON payloads. To maintain compliance during this transition, LocalEndpoint.com's serialization engine must synchronize perfectly and continuously with the public field registry.4 When generating the discovery metadata, the server will serialize the UAI-1 envelope into an optimized array that precisely maps to the registry's canonical schema order.4 This structural optimization drastically reduces total token consumption per request, enabling the advanced agent to ingest and map the capability profiles of hundreds of local endpoints simultaneously without exhausting its context limits.
2. Asynchronous Task Visibility: Advanced agents frequently trigger long-running discovery processes, complex local network diagnostic evaluations, or multi-stage metadata indexing routines. LocalEndpoint.com must strictly comply with the UAIX Async Task Visibility component.4 By utilizing the uai.task.status.v1 subject parameter within the core UAI-1 body 4, LocalEndpoint.com can issue standardized async receipts to the querying agent.4 The advanced agent can subsequently monitor this receipt using a polling or webhook-based pattern, ensuring that long-running local processes remain completely visible on the public record without blocking the agent's immediate, synchronous operational loop.
3. Complex Trust and Provenance Cryptographic Verification: Highly capable agents will frequently present Decentralized Identifiers (DIDs) and Verifiable Credentials (VCs) when attempting to access sensitive local routing descriptions.4 LocalEndpoint.com must implement a robust parsing engine capable of interpreting the incoming UAI-1 trust.auth\_scheme.4 If the advanced agent intends to transition from an isolated local discovery phase to a public data handoff (such as publishing meeting continuity to Carcinus.org), LocalEndpoint.com must cryptographically validate the agent's incoming signature\_ref against the externally declared credential\_ref.4 Only upon successful, mathematical validation of this cryptographic trust chain will LocalEndpoint.com authorize the generation of a Conformance Pack for the agent.

Integration of the UAI-1 Message Envelope into LocalEndpoint Metadata

The most technically demanding engineering requirement for achieving total UAIX compliance is the direct mapping of LocalEndpoint.com's specific, unique domain concepts—such as roadmap labels, compatibility channels, and capability profiles—into the standardized UAI-1 body schema.4 Because LocalEndpoint.com functions strictly as adjacent evidence and fundamentally rejects the role of an execution environment 5, its UAI-1 payloads must reflect an unwavering "read-only" discovery posture.

Mapping Discovery Profiles to the Payload

When an AI agent accesses LocalEndpoint.com to discover the operational capabilities of a newly spawned local service (such as a temporary mock API or an experimental MCP-ready tool), LocalEndpoint.com must encapsulate the response precisely as follows: The envelope profile string must be assigned as uai.intent.response.v1.4 The envelope source block must identify LocalEndpoint.com as the definitive issuer, utilizing a URI corresponding to the specific local registry instance being queried.4 Within the body, the intent field must be explicitly set to "provide-discovery-metadata". The body.parameters object serves as the critical injection point for LocalEndpoint's unique data payload. It must programmatically include the discovered endpoint's technical capabilities, programmatic limitations, and the critical roadmap label (categorized strictly as live, preview, planned, or future).5 Furthermore, the body.constraints array must explicitly and forcefully inject the Teleodynamic claim boundaries into the agent's context.5 This array must include immutable constraint flags such as \["no-arbitrary-execution", "discovery-is-not-permission", "requires-human-review-to-widen"\].5 By hardcoding these exact philosophical constraints into the standardized UAI-1 body.constraints array, LocalEndpoint.com technically forces the consuming agent's internal safety layer to recognize that merely discovering the existence of an endpoint does not equate to authorization or permission to execute commands against it.5

Guaranteeing Provenance and Integrity during Ecosystem Handoffs

One of the primary, high-value functions of LocalEndpoint.com is its role as the "local-to-public review bridge".1 When an agent intends to take metadata or diagnostic artifacts gathered from a local offline sandbox and hand them off to a public continuity surface—such as the public identity profiles managed by Carcinus.org or the structured ontology wiki pages managed by NeuralWikis.com—LocalEndpoint.com must finalize and lock the data state prior to transmission.1 To be considered rigorously UAIX compliant during this bridging maneuver, LocalEndpoint.com must compute and populate the integrity.checksum parameter.4 The server must take the final, aggregated discovery metadata, apply the designated jcs canonicalization algorithm to systematically strip all whitespace and order the JSON keys predictably, and subsequently generate a secure SHA-256 hash.4 This generated hash is then embedded directly into the UAI-1 handoff envelope. When the agent successfully carries this envelope from the local network to the public ecosystem, any downstream UAIX validator stationed at the receiving domain can recalculate the hash using the identical JCS algorithm. If the local data was manipulated, corrupted, or hallucinated during transit out of the local sandbox environment, the calculated hashes will mismatch, and the handoff will fail safely, triggering an immediate UAI-1 error log. Additionally, LocalEndpoint.com must populate the provenance.trace\_id and the provenance.model\_id fields for every handoff transaction.4 This comprehensive provenance tracking ensures that any endpoint diagnostic reported on the public-facing review bridge can be traced backward, through the network topology, to the specific local agent interaction that generated it.10 This prevents the proliferation of untraceable hallucination chains across the broader machine-readable knowledge surfaces.

Establishing the Conformance Ladder and the Four-Step Validation Path

Compliance with the UAIX specification suite is not a subjective, self-certified status; it is a mathematically and procedurally validated state that must be continuously maintained.4 To legitimately claim complete UAIX compliance across all operational agent tiers, LocalEndpoint.com must implement the UAIX Conformance Ladder and fully automate the Four-Step Validation Path.4 The conformance ladder works in tandem with the public error registry and the UAI error flow.4 Its primary architectural purpose is to render machine failure handling and support claims highly structured and easily automatable.4 It operates alongside the transport bindings, typed error codes, and field-order governance systems to give developers a clear, structured support-claim layer.4

Deploying the UAIX Conformance Pack

UAIX protocol specifies that systemic compliance is formally proven through the generation of a "Conformance Pack".4 This pack is a highly structured, reusable proof packet designed to help developers and AI teams validate compliance, execute regression checks, and provide undeniable launch evidence.4 The pack must contain the current public schemas, registry records, functional fixtures (working examples), and launch pointers.4 To fulfill this requirement, LocalEndpoint.com must host a dedicated, highly available, machine-readable route (e.g., /conformance-pack.json) that dynamically bundles its current API capabilities against the prevailing UAI-1 standards. When a new version of the LocalEndpoint.com discovery engine is released locally, its internal Continuous Integration and Continuous Deployment (CI/CD) pipeline must automatically compile and export this Conformance Pack. This architectural guarantee ensures that any cross-team support claims, or agent-driven public handoffs, are backed by verifiable mathematical evidence, completely bypassing the need for subjective human certification assertions.4

Automating the Four-Step Validation Path Execution

To operationalize this compliance, LocalEndpoint.com must deeply integrate the UAIX Four-Step Validation Path directly into its core request/response lifecycle.4 This four-step sequence acts as an immutable checkpoint for every payload generated by the system.

By embedding this four-step validation path directly into the core response logic, LocalEndpoint.com fundamentally transitions from being a passive, conceptual discovery layer into an active, highly secure enforcement engine for UAIX standards.

The Agent Role Update Protocol and Governance Ledger Enforcement

Compliance within the Teleodynamic ecosystem is not solely a matter of technical JSON schema alignment; it is heavily dependent on strict philosophical governance and domain discipline.2 Because LocalEndpoint.com exists in close systemic proximity to highly specialized sites—such as Teleodynamic.com (the philosophical fulcrum), JustAnIota.com (the semantic mapping and IOTA-1 workbench), and NeuralWikis.com (the agent-facing machine-readable knowledge surface)—it must stay strictly within its assigned lane.1 If an AI agent attempts to utilize LocalEndpoint.com to resolve a complex semantic glyph interpretation, execute a memory package wizard, or dictate philosophical theory, LocalEndpoint.com must explicitly and forcefully reject the request based on the rules encoded within the Ecosystem Governance Ledger.1

Adhering to the Read-Only Governance Protocol

To mathematically maintain this lane discipline, LocalEndpoint.com must natively support and broadcast the Agent Role Update Protocol.2 This protocol is a static, read-only mechanism that dictates when related ecosystem sites and agents should check for updated role directions without treating the fetched payload as an executable command.2 LocalEndpoint.com must host its own immutable governance endpoint (e.g., /agent-role-update.json) that continuously broadcasts its specific lane restrictions. This payload must consist of JSON, llms.txt, or Markdown role notes, and must strictly articulate the following local data schema 2:

• Role Statement & Source of Truth: The payload must explicitly declare that LocalEndpoint.com owns the bounded discovery and local routing context exclusively, while Teleodynamic.com maintains ownership of all philosophical and claim-governance context.2
• Do-Not List: The payload must feature a hardcoded array of prohibitions: do not automatically execute payloads, do not widen semantic claims, do not fetch cryptographic secrets, do not probe private networks, and do not overwrite local implementation authority.2
• Non-Execution Boundary Rule: The protocol unequivocally demands that role updates are never executed as system commands.2 Any automated fetches executed by agents querying LocalEndpoint.com must be strictly static, read-only, bounded by severe timeouts, cached efficiently, and completely non-executing.2 Human review is strictly required for any changes to roles, claims, conformance statuses, endpoint paths, or public-profile modifications.2

Managing Ecosystem Fallbacks and Context Bridges

If an advanced agent queries LocalEndpoint.com with a sophisticated UAI-1 message requesting an action that belongs strictly to UAIX.org (such as schema generation) or Teleodynamic.com (such as philosophical claim verification), LocalEndpoint.com cannot simply drop the connection; it must trigger the protocol's highly structured Fallback Behavior Rules 2:

1. Conflicting Claims: If the agent presents metadata claims that conflict with established role boundaries, LocalEndpoint.com must defer the agent to the Teleodynamic.com claim-boundary pages to resolve the public wording disputes.2
2. Execution Requests: If the UAI-1 payload asks for active tunnel execution, credential handling, or private network probing, LocalEndpoint.com must instantly reject the payload as completely out of scope, generating a UAI-1 problem-details error envelope.2
3. Ambiguous Site Lane: If the agent's intent is unclear or if it attempts to merge authority between two distinct ecosystem domains, LocalEndpoint.com must default to a forced no-op state and set the UAI-1 body.constraints parameter to mandate human review before the agent is permitted to publish any data.2

By flawlessly encapsulating these theoretical governance rules within highly structured UAI-1 standard messages, LocalEndpoint.com empowers AI agents to programmatically comprehend its exact operational boundaries without violating strict safety protocols. Furthermore, it explicitly establishes the user-AI-experience (UAIX) not merely as a matter of interface design, but as a deeply rigorous, structurally auditable compliance regime designed to mitigate accuracy-fairness tradeoffs and ensure construct validity during complex machine knowledge production.11 Through these meticulous structural, protocol-level, and philosophical adaptations, LocalEndpoint.com transcends its status as a conceptual boundary diagram. By adopting the UAI-1 message envelope, mastering Keyless JSON optimization, integrating the Four-Step Validation path, and enforcing the Agent Role Update Protocol, it achieves exhaustive, provable UAIX compliance. This transformation establishes LocalEndpoint.com as an unassailable, local-safe bridge capable of supporting the future of tiered, highly secure agentic interoperability.

Works cited

1. Ecosystem Role Map and Lane Charter \- Teleodynamic AI, accessed June 4, 2026, https://teleodynamic.com/ecosystem-role-map/
2. Agent Role Update Protocol \- Teleodynamic AI, accessed June 4, 2026, https://teleodynamic.com/agent-role-update-protocol/
3. LocalEndpoint.com Philosophical Fulcrum Announcement Packet, accessed June 4, 2026, https://teleodynamic.com/evidence-packets/localendpoint-philosophical-fulcrum-announcement.html/
4. UAIX | UAI-1 Open Exchange Contract for AI Systems, accessed June 4, 2026, http://uaix.org
5. LocalEndpoint.com and teleodynamic boundary architecture, accessed June 4, 2026, https://teleodynamic.com/localendpoint-teleodynamics/
6. Offline AI and Local Endpoint Sandboxes \- Teleodynamic AI, accessed June 4, 2026, https://teleodynamic.com/local-sandboxes/
7. Machine-Readable Ecosystem Directory for Teleodynamic AI, accessed June 4, 2026, https://teleodynamic.com/machine-readable-ecosystem-directory/
8. Teleodynamic Ecosystem Governance Ledger, accessed June 4, 2026, https://teleodynamic.com/ecosystem-governance-ledger/
9. AI Agent Start: Safe Read Order and Handoff Boundaries \- Teleodynamic.com, accessed June 4, 2026, https://teleodynamic.com/agent-start/
10. Best Practices in Quality Control | RIS Blog \- RiverSide Integrated Solutions, accessed June 4, 2026, https://riversideintegratedsolutions.com/n/best-practices-in-quality-control
11. Generation Next: Experimentation with AI \- The University of Chicago, accessed June 4, 2026, https://bfi.uchicago.edu/wp-content/uploads/2023/09/BFI\_WP\_2023-126.pdf
12. EXPERIMENTATION WITH AI Gary Charness Brian Jabarian John A. List Working Paper 31679 \- NBER, accessed June 4, 2026, https://www.nber.org/system/files/working\_papers/w31679/revisions/w31679.rev1.pdf?utm\_source=PANTHEON\_STRIPPED