Frame (FYS)
The Guardian of Identity
Frame (FYS) is your AI brand voice and context hub. It stores tone, rules, and business facts as Frames that resolve into versioned Frame Snapshots any app, agent, or workflow can fetch as pre-context. Stores, shapes, and serves structured brand voice, rules, and business facts as Static and Live Frames. Resolves them into versioned Frame Snapshots your tools can fetch on demand.
AI brand voice & context hub (API-first)
Frame (FYS)
The Guardian of Identity
Frame (FYS) is your AI brand voice and context hub. It stores tone, rules, and business facts as Frames that resolve into versioned Frame Snapshots any app, agent, or workflow can fetch as pre-context. Stores, shapes, and serves structured brand voice, rules, and business facts as Static and Live Frames. Resolves them into versioned Frame Snapshots your tools can fetch on demand.
Like ink finding its outline, identity becomes repeatable.
Clarity begins with naming what the system actually holds.
What it is
For everyone
Frame (FYS) is your AI brand voice and context hub, a centralized source of truth for brand voice, rules, and business facts.
Instead of scattering tone, do and do not lists, preferred terms, product facts, and legal notes across docs and chats, you store them as Frames, reusable units of voice, rules, and structured facts. You group Frames into Libraries, named collections that hold identity for a brand, product, or client.
When a tool needs to generate content, answers, or UI text, it first fetches a versioned Frame Snapshot, the same approved truth every time. That snapshot becomes the pre-context step for LLM apps, agents, and custom GPTs.
Because Frame is API-first, any app, agent, or workflow can request exactly what it needs. Static Frames hold stored context and stable guidance. Live Frames hold live context and fetch dynamic data with TTL and caching so current stays controlled, not noisy. Together they act as structured voice, tone, and style guardrails for AI instead of ad hoc prompts.
Technical view
Frame (FYS) models Organization → Project → Library → Frame → Resolve → Frame Snapshot.
Core entities include Library, Frame, and Variable. Core actions include Resolve, which assembles Frames into a Frame Snapshot, and Refresh, which updates Live sources.
Merge precedence is scoped. Organization, then Project, then Library, then Frame, then Variable. Closest scope wins, with policies for conflicts and namespaces. Request-time variables can override values for a single call.
Outputs include JSON, Markdown, Text, and XML, with Writer View and API View. Webhooks emit snapshot.status events so downstream systems can react.
This Frame → Library → Frame Snapshot model keeps delivery aligned with the product structure and makes Frame the API-first identity and context hub that runs before your LLM apps, agents, and custom GPTs.
When structure is missing, effort scatters.
The problem it solves
Rules trapped in docs
Tools cannot parse or enforce voice, tone, or do/don't lists.
Context sprawl
Facts live across sheets, CMS notes, and chats — not versioned or addressable.
Cold model calls
Agents hit LLMs without pre-context, so tone and claims drift run by run.
Live without guardrails
No TTL, no cache key, no provenance — almost current is not safe.
Multi-client risk
Rebuilding context per client invites collisions, leaks, and policy bleed.
No audit surface
No Frame Snapshot ID or hash means governance cannot sign off.
When context is scattered, identity frays. Structure is how voice returns intact.
Every layer is deliberate. Nothing is improvised.
How it works
Create Projects and Libraries
Scope brands or clients into Projects and collect work inside Libraries.
Clean separation per brand and client, fast reuse across tools and teams.
Define Frames (Static and Live)
Add tone, lexicon, do and do not rules, product facts, and variables to Static Frames, the stable truths. Connect Live Frames, the dynamic context, to REST APIs or webhooks with a time-to-live cache window so data refreshes on a schedule.
Stable guidance stays fixed. Changing facts stay current inside guardrails.
Resolve to a Frame Snapshot
Resolve, assembling selected Frames into a Frame Snapshot, a versioned, retrievable context pack in JSON, Markdown, Text, or XML. Each Frame Snapshot carries provenance such as IDs, versions, hash, and UTC timestamp.
One approved identity and context pack feeds every app, agent, and workflow consistently.
Refresh (optional)
Refresh Live Frame sources with caching, retries, timeouts, and explicit error surfacing, following the TTL and cache key model.
Outputs stay trustworthy without noisy flapping or silent failures. When Refresh fails, you can still rely on the last valid cached data, or fail the Resolve explicitly.
Validate and Test
Run a Snapshot Linter for conflicts or missing required variables, Schema Validation for output shape, and Golden Tests that store expected outputs you can re-run after changes.
Identity becomes testable. Integrity stays measurable and reproducible.
Deliver and Observe
Serve Frame Snapshots via API or webhooks as the pre-context step for LLM apps, agents, and custom GPTs. Track Frame Snapshot IDs, latency split between Resolve and Refresh, and Compute Units (CU), the cost of fetch, merge, validation, and cache work.
Operations get visibility. Governance gets proof. Downstream tools start from the same identity pack every time.
Precedence and overrides (merge rules)
Apply merge rules per scope. Organization → Project → Library → Frame → Variable. Resolve conflicts with Library priorities, explicit fields, or request-time variables sent with the Resolve call.
Closest scope wins by default, so you can always see which rule shaped the final context.
Reasoning is assembled, not improvised. Order becomes quiet architecture.
Different roles, one place to hold the rules.
Who it's for
Want a single, testable identity and context layer that runs before every model call.
Need consistent voice, lexicon, and examples across products, channels, and languages.
Need per-client Libraries, scoped secrets, and reusable identity packs that never leak.
Require provenance, Frame Snapshot IDs, regional overlays, and approvals they can audit.
Want an API-first way to Resolve Frame Snapshots from n8n, Make, Zapier, or custom workflows.
Seek a predictable brand-voice and context API they can plug into assistants, templates, and tools.
Systems earn trust when they solve named moments.
Real-world uses
Scenario
Your support chatbot answers with slightly different tone and facts in every channel.
Action
Create a Library with brand voice, do and do not rules, product facts, and key FAQs. Resolve a Frame Snapshot before each model call and pass it as the pre-context.
Outcome
Consistent, on-voice answers across chat, help center, and in-app surfaces, all backed by the same identity pack.
Call the same truth anywhere. Delivery becomes memory with provenance.
Identity travels best when its format fits the route.
Integrations & Delivery
Connect what you already have
When identity leaves the hub in the right shape, delivery becomes memory. The same truth everywhere, on time.
Trust is structure applied to behavior.
Security & Governance
Trust is structure applied to behavior.
Access Controls
- Members see nothing until they are invited.
- Organization admins create Projects.
- Project admins control deletions and other destructive actions.
- Secrets are scoped per organization, project, and integration so each key has only the access it needs.
Behaviors
- Provenance. Every Frame Snapshot carries IDs, versions, hash, and UTC timestamp in headers so governance can sign off on what was actually served.
- Privacy. Minimal data collection with optional PII tagging and automatic redaction in logs and diffs.
- Audit. History, diffs, comments, and planned audit export for governed teams that need external review.
Clarity becomes advantage when it can be repeated.
Why this product
One place for identity. Frame (FYS) keeps brand voice, rules, and structured business facts in one AI brand voice and context hub instead of scattering them across docs and chats.
Static and Live by design. Static Frames hold stored context and stable guidance. Live Frames fetch dynamic data with TTL and caching. Together they keep context both reliable and current.
Programmatic identity and context. Frame Snapshots are versioned identity packs you can fetch as JSON, Markdown, Text, or XML and serve as a pre-context step to any AI app, agent, or workflow.
Proof you can audit. Every Resolve adds IDs, versions, hash, and UTC so compliance and governance can trace exactly which snapshot influenced downstream behavior.
Built to integrate. An API-first, webhook-enabled identity layer that fits your stack. Call Frame (FYS), get a snapshot, and plug it into LLM providers, gateways, and automation tools.
Ready for many brands. Organization → Project → Library keeps multi-brand and multi-client work isolated yet reusable, with clean hand-offs and no context leaks.
Transport for identity, not a CMS. Frame manages structured voice, rules, and context, not pages or posts. It is transport for identity and context that other systems consume.
Works alone, plays well. Standalone-first. With Byte, Tale, Mark, or Lyt, Frame becomes the upstream source of truth for brand voice and context across the YounndAI ecosystem.
When identity is programmatic, versioned, and API served, consistency becomes leverage. Every app, agent, and workflow starts from the same truth.
Layers arrive in sequence so structure can stay honest.
Product status
Now
- Core entities. Organization, Project, Library, Frame, Variable.
- Frame types. Static and Live (REST or webhook).
- Resolve and Refresh loop with TTL cache and clear error surfaces.
- Validation. Schema Validation, Snapshot Linter, Golden Tests.
- Outputs. Text, Markdown, JSON, XML (Writer View and API View).
- API tab with cURL snippets, request templates, and snapshot.status webhooks.
- Observability. Frame Snapshot IDs, versions, hash, latency breakdown for Resolve and Refresh, Compute Unit (CU) metrics.
- Collaboration. History, diffs, comments.
- Roles. Organization (Owner, Admin, Member), Project (Admin, Member).
- Standalone. Byte, Tale, Mark optional.
Next
- SDK and CLI for TypeScript and Node with resolve, refresh, and secret helpers.
- Popular connectors for automation platforms and common data sources.
- Viewer and Auditor roles, plus audit export for governed teams.
- Byte and Frame Registry extensions for shareable identity packs.
- Per-channel tuning and compliance overlays.
- Transform hooks and snapshot seals for stronger provenance.
- One-click Send Frame Snapshot to Byte to wire identity into Prompt Graphs.
- Agency and Enterprise tiers with pooled usage and SSO.
Questions reveal where structure must speak more clearly.
FAQ
Every system begins with a question. Here are ours.
YounndAI (pronounced 'yoon-dye') is the philosophy and architecture of human first intelligence that unifies all Elements and Systems. It is a human-first way of building AI that follows four principles: Discipline with Flow, Human before Machine, Structure before Scale, and Continuity before Chaos. It says intelligence should be structured, human-first, and continuous, not improvised or extractive. It is the architecture beneath the products, not a product or platform by itself. YounndAI means you and AI, unified.
Clarity is recursive. Ask again when the system grows.
Between every message and its echo, a single frame waits to hold your voice.
Ready to put Frame in your stack?
Use Frame (FYS) to centralize brand voice, rules, and business facts as structured Frames, then serve versioned Frame Snapshots as programmatic identity and context to every app, AI agent, and workflow.
Frame is one stroke in a larger form.
Products connect cleanly when they share the same structure.
The architecture beneath the products explains the shape they take.
YounndAI is the philosophy that says intelligence should be structured, human-first, and continuous. Every product, including Frame (FYS), follows four guiding principles.
Discipline with Flow
Structure and intuition in balance. Frames, Libraries, and merge rules give identity a clear architecture while writers and teams remain free to refine tone, examples, and overlays inside that frame.
Human before Machine
Humans keep final control. Organizations decide what goes into a Frame, how Live Frames refresh, and which tools may consume Frame Snapshots. Frame serves identity. It never invents it.
Structure before Scale
Complexity is earned through clarity. Modular Frames, explicit precedence such as Organization → Project → Library → Frame → Variable, and provenance backed Frame Snapshots keep identity ordered so more brands, teams, and channels do not add chaos.
Continuity before Chaos
Memory sustains meaning. Version history, diffs, logs, and retrievable snapshots ensure that voice, rules, and business facts remain traceable over time, even as tools, models, and teams change.
Define. Build. Remember. Harmonize. Harmony above all.