Model-Resolution Leases: Precision Control for Identity, Custody, and Signing Paths in Fabric API Compose
Today, the Helpifyr/JaddaHelpifyr stack gains a new level of explicitness and operational separation in how model resolution is managed during API composition. With the introduction of model-resolution leases for consumer, identity, custody, and signing, the platform now orchestrates resource access and lifecycle boundaries with a clarity that was previously implicit or left to convention. This change is not just internal housekeeping; it redefines how API consumers, backend operators, and even downstream integrators can reason about, audit, and extend identity and custody flows in critical business processes.

At a glance
52
merged changes
14
code projects involved
Underlined terms are explained: just hover or tap.
Imagine an integration scenario where a downstream system must sign a document on behalf of a user, but the user’s identity, the custody of the document, and the actual signing authority all traverse different trust domains, each with their own lifecycle and audit requirements. Until now, the boundaries between these concerns were often blurred: model resolution for identity, custody, and signing could overlap or be conflated in a single transactional context, making it difficult to guarantee isolation, perform precise audits, or enforce policy at the correct boundary. The tension between flexibility and control was real, especially as the stack scaled to more complex orchestration tasks where the ‘who’, ‘what’, and ‘with what authority’ must be tracked and enforced independently.
01Why it matters
Why This Day Mattered
By wiring explicit model-resolution leases into the fabric API compose layer, the platform enables fine-grained, contractually enforced separation of resource access for core primitives: consumer, identity, custody, and signing. This unlocks new capabilities for developers building multi-tenant, multi-actor flows, where the provenance and authority chain for each step must be independently auditable and enforceable. Operators now gain a clear, inspectable contract for which component holds what lease, for how long, and under what context. For users, this translates into better guarantees that their identity and assets are not inadvertently mixed or overexposed, even in highly orchestrated flows. Downstream integrators benefit from a more predictable, debuggable, and policy-compliant interface, reducing the risk of ambiguous authority or accidental privilege escalation. The real-world impact is that business processes involving sensitive handoffs-such as payment authorizations, delegated signings, or custody transfers-can be composed with confidence that each actor’s scope is bounded and visible.
The closed UTC day 2026-11-12 resolved into 52 merged PRs across 14 repos.
02What changed
What Actually Changed
The core shift is the introduction and wiring of model-resolution leases into the fabric API compose logic. Rather than treating identity, custody, consumer, and signing as loosely-coupled aspects resolved ad hoc during request handling, each is now represented as a lease: a scoped, time-bound, and contractually defined claim on a model resource. The fabric API compose operation now explicitly requests and manages these leases, tracking their lifecycle and ensuring that each responsibility is clearly demarcated. This means that, for example, a signing operation cannot accidentally inherit a broader custody lease than intended, or that an identity assertion cannot be silently reused outside its intended context. The lease mechanism enforces not just access, but the granularity of that access, and records the provenance of each resolution event. This architectural change is surfaced at the API boundary, making the contract visible to both upstream callers and downstream policy enforcers.
03Why it holds better now
Why It Holds Better Now
This new state is fundamentally more capable and safer because it replaces implicit, convention-based resource management with explicit, enforceable contracts. By mapping each sensitive operation to a concrete lease, the platform eliminates a whole class of bugs where resource scope could bleed across boundaries, such as accidental reuse of a signing credential in the wrong context or misattribution of custody in multi-step flows. The lease abstraction allows for precise scoping, revocation, and audit trails, which are critical for regulated environments and for any workflow where trust boundaries are nontrivial. Additionally, this enables future extensions-such as dynamic policy enforcement, lease delegation, or automated expiry handling-without needing to retrofit logic into a monolithic access model. The separation of concerns also improves developer velocity: teams can reason about and test each lease type in isolation, knowing that cross-contamination is structurally prevented by the API contract.
04Food for thought
Want to Know More?
How might developers leverage these model-resolution leases to build adaptive, policy-driven workflows that change lease scope or duration in response to runtime signals? Could this mechanism be extended to support real-time revocation or escalation paths for high-risk operations, and what would be required in the API contract to surface those controls to integrators?
Terms in this post
- runtime
- The environment in which the system actually runs.
- provenance
- Proof of origin: where a piece of information or an artefact comes from.
- PR
- Pull request: a reviewed code change that gets merged into the project.
- repo
- Repository: a code project under version control.
- operator
- The person or team running the system.
What would this look like in your company?
A pilot shows it with a real process.
More on Identity and access
See all
Identity and access4 min
Session-Bound Claims: Precise Invocation Control for cc_read Operations
The Helpifyr/JaddaHelpifyr stack now enforces session-bound claim tokens for cc_read operations, eliminating ambiguous worker claim reuse and providing a concrete, auditable chain from session authority to every resource access. This breakthrough ties each data read to a specific Heddle-issued session, raising both operational safety and forensic traceability for operators and downstream applications.
Read
Identity and access4 min
Revocation-Aware Identity: Real-Time Portal Generation Gated by Heddle Feed
A new identity gate now synchronizes portal account creation with the live Heddle revocation feed, ensuring that revoked or at-risk identities can no longer slip through at onboarding time. This bridges the gap between identity lifecycle events and portal user provisioning, hardening the boundary where trust is established and enforced.
Read
Identity and access4 min
Projection as a Portal Service: Real-Time ERP Views, Rights, and Onboarding for Every Customer
Today's work transforms the Partner and Customer Portal from a static data sink into a living, rights-aware projection of each customer's ERP reality. By wiring Spindle's portal_projection into the portal's backend, onboarding, and UI, we unlock real-time, role-based access to ERP-linked data, events, and boost inventories, setting the stage for secure self-service and granular entitlement across tenants.
Read