AgentRules.org
RulesStacksClientsAuditorPrunerSelf-HealRFCsBenchmarkCLICI/CDAuthorsSubmit
This specification is maintained by the AgentRules Working Group. Have enhancements or want to claim maintainership?Submit Specification →
securitycritical PriorityID: openfga-ephemeral-contextual-tuples-zero-retention

OpenFGA Ephemeral Contextual Tuples Zero-Retention Boundary Standard

Enforces strict isolation between persistent relation tuples and dynamic runtime authorization claims. Engineers must supply temporal, environmental, or session-scoped attributes exclusively via OpenFGA in-memory contextual tuples during graph traversal rather than writing ephemeral state to the persistent tuple store.

Prohibited Anti-Pattern: Persisting Ephemeral or Session Claims to OpenFGA Store Resulting in State Drift and Privilege Leaks

Export Ready-to-Drop Configuration

Select format below to copy code or download file directly.

---
description: OpenFGA Ephemeral Contextual Tuples Zero-Retention Boundary Standard - Enforces strict isolation between persistent relation tuples and dynamic runtime authorization claims. Engineers must supply temporal, environmental, or session-scoped attributes exclusively via OpenFGA in-memory contextual tuples during graph traversal rather than writing ephemeral state to the persistent tuple store.
globs: src/auth/**/*.ts, src/guards/**/*.ts, src/middleware/**/*.ts, src/services/authorization/**/*.ts
alwaysApply: true
verified_by: "agentrules.org"
license: "CC-BY-4.0"
source: "https://agentrules.org/rules/openfga-ephemeral-contextual-tuples-zero-retention"
---

# OpenFGA Ephemeral Contextual Tuples Zero-Retention Boundary Standard

> **Severity**: CRITICAL | **Category**: security
> **Anti-Pattern Warning**: Persisting Ephemeral or Session Claims to OpenFGA Store Resulting in State Drift and Privilege Leaks

## System Constraints
You are a Principal Software Architect enforcing zero-retention boundaries for OpenFGA authorization checks. All dynamic, temporal, device-bound, or session-scoped claims must be supplied strictly through the ephemeral `contextual_tuples` parameter or context object of `check` and `batchCheck` APIs. Never persist transient state to the OpenFGA storage engine, as cleanup failures and race conditions cause critical privilege retention vulnerabilities.

## Strict Guidelines
- Engineers MUST ALWAYS pass transient claims (e.g., dynamic roles, MFA status, IP location, step-up auth, session TTLs) strictly via OpenFGA `contextual_tuples` or check context in-memory.
- Engineers MUST NOT write ephemeral, session-bound, or time-delimited tuples using `writeTuples()` with the intention of deleting them later in application lifecycles or background jobs.
- Services MUST enforce atomic evaluation boundaries where contextual tuples are isolated to the single execution lifecycle of a request and automatically garbage-collected at socket termination.
- Code SHOULD validate and sanitize all dynamic contextual claims (e.g., verifying signature and freshness of step-up claims) prior to injecting them into the contextual tuple payload.
- Components NEVER store contextual authorization tuples in intermediary caches or relational tables alongside permanent structural graph relationships.

## Bad vs Good Implementations
### Ephemeral Dynamic Step-Up Authorization Check

#### Bad Antipattern (AI Common Hallucination)
> **Why it fails**: Persisting ephemeral session states (like MFA verification) via write() introduces high risk: unhandled exceptions, network drops, or worker terminations prevent cleanup, causing perpetual privilege retention and database pollution.
```typescript
import { OpenFgaClient } from '@openfga/sdk';

export async function authorizeStepUpAction(fga: OpenFgaClient, userId: string, actionId: string, mfaVerified: boolean): Promise<boolean> {
  // ANTI-PATTERN: Writing transient runtime session state to persistent tuple store
  if (mfaVerified) {
    await fga.write({
      writes: [{ user: `user:${userId}`, relation: 'mfa_authenticated', object: `action:${actionId}` }]
    });
  }

  const { allowed } = await fga.check({
    user: `user:${userId}`,
    relation: 'execute',
    object: `action:${actionId}`
  });

  // DANGEROUS: If service crashes or network fails here, user retains permanent elevated privilege
  if (mfaVerified) {
    await fga.write({
      deletes: [{ user: `user:${userId}`, relation: 'mfa_authenticated', object: `action:${actionId}` }]
    });
  }

  return allowed ?? false;
}
```

#### Production Standard (Correct)
> **Standard**: Supplying ephemeral relations via `contextualTuples` guarantees zero retention. The OpenFGA engine traverses the graph with the synthetic in-memory tuples for this single evaluation without persisting state, eliminating state drift and orphaned privileges.
```typescript
import { OpenFgaClient, ClientCheckRequest } from '@openfga/sdk';

export async function authorizeStepUpAction(fga: OpenFgaClient, userId: string, actionId: string, mfaVerified: boolean): Promise<boolean> {
  // PRODUCTION INVARIANT: Inject ephemeral session state strictly through contextual_tuples
  // Tuples are evaluated in memory by the OpenFGA engine and instantly purged upon request completion
  const checkPayload: ClientCheckRequest = {
    user: `user:${userId}`,
    relation: 'execute',
    object: `action:${actionId}`,
    contextualTuples: mfaVerified
      ? [
          {
            user: `user:${userId}`,
            relation: 'mfa_authenticated',
            object: `action:${actionId}`
          }
        ]
      : []
  };

  const { allowed } = await fga.check(checkPayload);
  return allowed ?? false;
}
```
Recommended MCP Servers (mcp-serverlist.com)

Equip agent with system tools to verify code for this stack.

OpenFGA Model & Schema Validator
Validates authorization models, tuple constraints, and schema conformance during generation.
Recommended Agent Skills (askills.dev)

Ready-to-use executable skill functions tailored to this stack.

OpenFGA CLI Model Tester
Runs localized test cases verifying graph resolution behavior and ephemeral tuple boundaries against target models.
Architectural Specification & Invariant Rationale

Architectural Invariant Design: OpenFGA Ephemeral Contextual Tuples Zero-Retention Boundary Standard

OpenFGA Ephemeral Contextual Tuples Zero-Retention Boundary Standard defines an industrial-grade behavioral standard for security engineering. Enforces strict isolation between persistent relation tuples and dynamic runtime authorization claims. Engineers must supply temporal, environmental, or session-scoped attributes exclusively via OpenFGA in-memory contextual tuples during graph traversal rather than writing ephemeral state to the persistent tuple store. Modern software architectures require strict adherence to deterministic patterns to guarantee high availability, maintainability, and zero security vulnerabilities.

Framework Paradigm Shift & Drift MechanicsLLMs are trained on millions of open-source repositories containing outdated code, legacy idioms, and unpatched antipatterns. When coding assistants generate implementations for this stack, they default to common statistical tokens: Persisting Ephemeral or Session Claims to OpenFGA Store Resulting in State Drift and Privilege Leaks Without an explicit system instruction file, developers spend hours debugging silent failures.
Failure Modes & Production Blast Radius

Hazard Analysis: What Breaks Without This Rule

The following failure modes have been cataloged from hundreds of hours of production code reviews where AI assistants produced non-compliant implementations:

Failure ModeAI Symptom (The Anti-Pattern)SeverityProduction Impact & Remedy
AI Hallucination & Deprecation DriftPersisting Ephemeral or Session Claims to OpenFGA Store Resulting in State Drift and Privilege LeaksCritical
Violating this industrial standard introduces regression bugs, security risks, and unexpected runtime failures in production.
Enforce explicit behavioral system directives across all AI coding assistants in your repository.
Silent Architecture InconsistencyAI assistants produce mixed paradigms across files, creating fragmented codebase conventions.Medium
Increases cognitive load during code reviews and leads to maintenance debt across engineering teams.
Pin project conventions in .cursor/rules, CLAUDE.md, and AGENTS.md so all team agents follow identical guardrails.
Architectural Directives in Detail

Step-by-Step Production Directives

Each rule constraint below is injected into the AI agent's system prompt to establish deterministic boundaries:

1

Engineers MUST ALWAYS pass transient claims (e.g., dynamic roles, MFA status, IP location, step-up auth, session TTLs) strictly via OpenFGA `contextual_tuples` or check context in-memory.

Engineers MUST ALWAYS pass transient claims (e.g., dynamic roles, MFA status, IP location, step-up auth, session TTLs) strictly via OpenFGA `contextual_tuples` or check context in-memory.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
2

Engineers MUST NOT write ephemeral, session-bound, or time-delimited tuples using `writeTuples()` with the intention of deleting them later in application lifecycles or background jobs.

Engineers MUST NOT write ephemeral, session-bound, or time-delimited tuples using `writeTuples()` with the intention of deleting them later in application lifecycles or background jobs.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
3

Services MUST enforce atomic evaluation boundaries where contextual tuples are isolated to the single execution lifecycle of a request and automatically garbage-collected at socket termination.

Services MUST enforce atomic evaluation boundaries where contextual tuples are isolated to the single execution lifecycle of a request and automatically garbage-collected at socket termination.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
4

Code SHOULD validate and sanitize all dynamic contextual claims (e.g., verifying signature and freshness of step-up claims) prior to injecting them into the contextual tuple payload.

Code SHOULD validate and sanitize all dynamic contextual claims (e.g., verifying signature and freshness of step-up claims) prior to injecting them into the contextual tuple payload.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
5

Components NEVER store contextual authorization tuples in intermediary caches or relational tables alongside permanent structural graph relationships.

Components NEVER store contextual authorization tuples in intermediary caches or relational tables alongside permanent structural graph relationships.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
Technical Questions & Answers

Frequently Asked Technical Questions

Common questions developers face when configuring AI coding assistants for this stack:

Q:Why is OpenFGA Ephemeral Contextual Tuples Zero-Retention Boundary Standard critical for AI coding assistants?

Enforces strict isolation between persistent relation tuples and dynamic runtime authorization claims. Engineers must supply temporal, environmental, or session-scoped attributes exclusively via OpenFGA in-memory contextual tuples during graph traversal rather than writing ephemeral state to the persistent tuple store. Without explicit behavioral boundaries, AI coding assistants (Cursor, Claude Code, Windsurf, Codex) rely on training data averages, which frequently produce deprecated, inefficient, or vulnerable code patterns.

Q:How does adopting this rule prevent AI hallucinations?

This rule explicitly declares what the AI must avoid (Persisting Ephemeral or Session Claims to OpenFGA Store Resulting in State Drift and Privilege Leaks) and prescribes verified positive examples. Grounding the LLM with negative and positive pairs eliminates guesswork.

Q:Which AI coding environments are supported?

This specification is multi-platform compatible: Cursor (.cursor/rules/*.mdc & .cursorrules), Anthropic Claude Code (CLAUDE.md), Windsurf (.windsurfrules), Codex / Cline (AGENTS.md), and GitHub Copilot (.github/copilot-instructions.md).

Q:Can I combine this rule with other technology stacks?

Yes. Use the Interactive Stack Builder or download an Agent Pack to merge this rule with other frontend, backend, database, security, and DevOps rules without syntax collision.

Open Specification · CC BY 4.0·Free for Personal, Team & Commercial In-Repo Use

Citation & Open Source Attribution Guidelines

This specification is licensed under Creative Commons Attribution 4.0 International (CC BY 4.0). You are completely free to adapt and share this rule in your workspace. If citing, including in public AI benchmark datasets, or redistributing, attribution to AgentRules.org is required.

Related SECURITY Rules

View all rules →
security
105

OpenFGA Graph Invariants: Cyclic Relation Prevention & Contextual Tuple Hardening

Enforces strict directed acyclic graph (DAG) topology validation during relationship mutation writes and mandates strict server-side schema verification for ephemeral contextual tuples in OpenFGA evaluations. Prohibits persistent storage of ephemeral request attributes and guards against recursive relation loops causing graph expansion denial-of-service.

security
81

WebAuthn Conditional UI Mediation, Nonce Atomicity, and Assertion Cryptographic Verification

Enforces zero-trust cryptographic validation for FIDO2/WebAuthn Passkey authentication with Conditional UI autofill. Requires atomic single-use challenge consumption to eliminate replay attacks, strict RP ID hash and origin binding, authenticatorData flag verification (User Presence and User Verification), and monotonic signature counter enforcement to detect authenticator cloning.

security
111

Enforce Sigstore Keyless OIDC Attestation and Admission Controller Verification

Enforces immutable supply-chain security using Sigstore Cosign keyless signing via ephemeral OIDC tokens issued by Fulcio and verified against the Rekor transparency log. Container workloads must be signed and attested at build time by digest, and admission controllers (such as Kyverno or Sigstore Policy Controller) must strictly validate the OIDC issuer and subject identity before allowing image execution.

1 Rule in Stack

OpenFGA