How to Set Up Identity-Locked Character Asset Management for AI Video

Every AI-generated character is built from a stack of digital artifacts: training images, LoRA weights, trigger words, recommended inference settings, and reference documents that describe the character's visual traits. When these artifacts are scattered across local drives, Slack threads, and random cloud folders, teams run into identity drift. One editor uses an outdated LoRA. Another changes the classifier-free guidance scale. The character's jawline shifts, the hair color drifts a shade, and suddenly your protagonist looks like a different person in Scene 12.

Identity-locked character asset management solves this by treating character data as a single, versioned, access-controlled unit. Think of it as a "character vault" where every artifact that defines a character's appearance lives together, is versioned together, and is secured together.

The concept borrows from traditional VFX pipeline management, where studios have long maintained asset libraries for 3D models and textures. The difference with AI video is that the core asset is a trained model file, typically a .safetensors LoRA ranging from 50 MB to 200 MB depending on rank and base model. That single file can reproduce a character's face across unlimited generations, which makes it both incredibly valuable and uniquely vulnerable.

A custom-trained LoRA can be the primary IP for an entire video production. If someone outside your team gets access to it, they can generate content featuring your character without your permission. This is why "identity-locked" is not just a description of consistency controls. It describes the security posture required to protect character IP at the model level.

A professional character asset is not a single file. It is a collection of related artifacts that need to stay synchronized. Here is how to structure the stack from bottom to top.

Training Dataset Layer

The foundation is the set of reference images used to train the character LoRA. For most production-quality characters, this means 30 to 50 high-resolution images showing the character from different angles, in different lighting conditions, and with varied expressions. Store these as lossless PNGs or high-quality JPGs in a dedicated subfolder.

Why keep them? If your team needs to retrain the LoRA for a newer base model (say, migrating from SDXL to Flux or a future architecture), the original training set is irreplaceable. Without it, you are starting from scratch.

Model Weights Layer

This is the LoRA file itself, typically in .safetensors format. The .safetensors format is the industry standard because it prevents arbitrary code execution during loading, unlike older .ckpt files that can contain embedded Python code.

Tag each LoRA with metadata:

• Base model it was trained against (e.g., SDXL 1.0, Flux.1 Dev)
• Training rank (common values: 16, 32, 64, 128)
• Trigger word(s) used during training
• Recommended weight for inference (e.g., 0.7 for photorealism, 0.85 for stylized work)
• Training date and dataset version
• Seed values used for any reproducibility benchmarks

Character Bible Layer

A character bible is a text document or PDF that describes the character's physical attributes, wardrobe rules, color palette, personality notes, and any generation constraints. This is the human-readable companion to the model weights.

When stored in a workspace with Intelligence Mode enabled, character bibles become searchable through AI chat. A team member can ask "What is the hex code for Maya's eye color?" and get a cited answer pulled directly from the document, instead of scrolling through a 40-page PDF.

Output Samples Layer

Keep a curated set of approved generation outputs alongside the model. These serve as a visual reference for what the character should look like and help new team members calibrate their expectations before generating anything.

Build Your Character Vault on a Free Workspace

Get 50 GB of free storage with granular permissions, Intelligence Mode for searchable character bibles, and audit trails for every file access. No credit card required.

Sign Up Free

Unauthorized access to character models is a top security concern for AI studios. A leaked LoRA does not just expose a file. It exposes the ability to generate unlimited content featuring your character. Traditional DAM systems were designed to protect finished media assets like logos and brand photos. Character model files require a different security model because the risk is generative, not just distributive.

Role-Based Permissions for Model Files

Not everyone on a production team needs the same level of access. A practical permission structure looks like this:

• Lead Character Artist: Full read/write access to training datasets, model weights, and character bibles. Can upload new versions and deprecate old ones.
• Animators and Editors: Read access to model weights and character bibles. Can load LoRAs into their inference pipeline but cannot download the raw .safetensors file or modify the master copy.
• Directors and Producers: Read access to character bibles and output samples. Can review and approve character designs without touching the technical files.
• External Collaborators: Access only to output samples and style guides. No access to model weights or training data.

Fastio's granular permissions work at the organization, workspace, folder, and file level, which maps cleanly to this kind of tiered access structure. You can give an external colorist access to reference images in one folder while keeping the model weights in a locked subfolder they cannot see.

Audit Trails for IP Protection

Every interaction with a character model should be logged. If a character LoRA leaks, you need to trace who accessed it, when, and from where. This is not paranoia. It is standard practice in any production where character IP has commercial value.

Fastio's audit trails cover file operations, memberships, and access changes, giving studios the paper trail needed for IP enforcement. If a dispute arises over unauthorized character usage, timestamped access logs are the first thing a legal team will ask for.

File Locks for Concurrent Access

When multiple team members work with the same character assets, file locks prevent conflicting edits. An artist retraining a LoRA can lock the model file so that no one else overwrites it mid-training. Once the new version is ready, they unlock it and the team picks up the update.

Characters change over the course of a production. A protagonist might age, get a new hairstyle, or switch to a different wardrobe in Act 3. Each change requires a new LoRA or an updated training set, and your asset management system needs to handle this without breaking the older versions that are still needed for earlier scenes.

Semantic Versioning for LoRAs

Borrow from software development and use semantic versioning for character models:

• Major version (v2.0): Base model migration (e.g., SDXL to Flux) or significant character redesign
• Minor version (v1.1): New outfit, hairstyle change, or aging adjustment
• Patch version (v1.0.1): Training refinement to fix a specific artifact like hand rendering or profile angle consistency

Store each version as a separate file with a clear naming convention: maya-v1.0.0-sdxl-rank32.safetensors. This makes it obvious at a glance which character, version, base model, and training configuration the file represents.

Maintaining Parallel Versions

In a production with flashbacks or time jumps, you may need to generate the same character at different ages simultaneously. Keep parallel version branches in separate subfolders:

/characters/maya/
  /v1-young/
    maya-v1.2.0-flux-rank32.safetensors
    training-data/
    character-bible-young.pdf
  /v2-adult/
    maya-v2.0.0-flux-rank64.safetensors
    training-data/
    character-bible-adult.pdf
  /approved-outputs/
    maya-young-reference-grid.png
    maya-adult-reference-grid.png

Deprecation Workflow

When a new version replaces an old one, do not delete the previous version immediately. Move it to an archive folder. Old versions may be needed for reshoots of earlier scenes, and storage is cheaper than re-training a LoRA from scratch.

Tag deprecated versions with a note explaining why they were replaced (e.g., "Replaced by v1.1.0: fixed left-profile artifact at CFG > 7").

AI agents can automate the repetitive parts of character asset management. Instead of manually looking up trigger words, checking version numbers, or verifying that everyone is using the approved LoRA, an agent connected to your workspace handles these tasks on demand.

What Agents Can Do With Character Data

When your character vault lives in a workspace with Intelligence Mode enabled, agents can:

• Search character bibles using natural language. Ask "What are Maya's trigger words for the rain scene outfit?" and get a cited answer from the indexed PDF.
• Check version compliance. An agent can compare the LoRA filename an editor is using against the latest approved version in the workspace and flag mismatches.
• Generate character briefs. Pull metadata from multiple character files and compile a production-ready summary for a new team member or external collaborator.
• Monitor access patterns. Use activity summaries to flag unusual access to sensitive model files, like a download from an IP address that has never accessed the workspace before.

MCP Integration

Fastio's MCP server provides agents with tools for storage, AI, workspace management, and workflow operations through Streamable HTTP at /mcp. An agent can authenticate, list files in a character workspace, read metadata, and even trigger Intelligence Mode queries, all through a standardized protocol that works with Claude, GPT-4, Gemini, or any MCP-compatible client.

For teams already using agent workflows, the Fastio MCP documentation covers the full tool surface. The agent onboarding guide is a good starting point for connecting a new agent to your workspace.

Ownership Transfer for Client Work

Studios that build character assets for clients can use ownership transfer to hand off the finished vault. An agent creates the workspace, organizes the character stack, enables Intelligence Mode for searchability, and then transfers the entire organization to the client. The studio can retain admin access for ongoing support while the client takes full ownership of their character IP.

Here is a step-by-step process for setting up identity-locked character asset management, whether you are a solo creator or running a multi-person production.

Step 1: Choose Your Storage Platform

You need a platform that supports granular permissions, file versioning, and ideally AI-powered search. General-purpose options like Google Drive or Dropbox handle basic file storage but lack the permission granularity and intelligence features that character management demands. S3 gives you raw storage with fine-grained access policies, but you will need to build metadata, search, and collaboration layers yourself.

Fastio provides a middle ground: shared workspaces with folder-level permissions, Intelligence Mode for AI-powered search over uploaded documents, and audit trails that log every access event. The free agent plan includes 50 GB of storage and 5 workspaces, which is enough for most independent productions.

Step 2: Create Your Folder Structure

Organize each character as a self-contained unit. A proven structure:

• /characters/{name}/model/ for .safetensors files
• /characters/{name}/training-data/ for reference images
• /characters/{name}/bible/ for character description documents
• /characters/{name}/outputs/ for approved generation samples
• /characters/{name}/archive/ for deprecated versions

Step 3: Upload and Tag Assets

Upload your character stack and add metadata. At minimum, each LoRA file should have its trigger words, base model, rank, and recommended weight documented in the character bible or in a companion README file within the same folder.

Step 4: Enable Intelligence Mode

Turn on Intelligence Mode for the workspace. This indexes your character bibles and any text-based files, making them searchable through semantic search and AI chat. Your team can then query character details without opening individual files.

Step 5: Set Permissions

Configure folder-level permissions based on the role structure described earlier. Lock the model weights folder to authorized artists only. Keep output samples accessible to the broader team.

Step 6: Establish a Version Protocol

Document your versioning convention and deprecation rules. Share this as a pinned note or top-level README in the character workspace so every team member follows the same process.

Step 7: Connect Agent Tooling

If your production uses AI agents for pipeline automation, connect them to the workspace via MCP or API. Test that agents can query character metadata and retrieve the correct file versions before going into full production.