Creator Agent

Turn a creator's documents, audio, and video into a source-grounded audience agent—without giving up control of private content or silently spending anyone's AI credits.

Creator Agent is a mobile-first platform for building an AI agent grounded in creator-approved content. Creators can add or connect knowledge, review what the system learned, configure voice and boundaries, and preview how an audience agent answers with citations.

Try the public beta

Open Creator Agent Studio · Watch the 33-second demo · Read the build story · Share feedback

The beta uses managed Auth0 sign-in and a protected API backed by PostgreSQL. It intentionally makes zero AI-provider calls: the current answer, customization, and load flows are deterministic, so trying the product does not consume the creator's or developer's model tokens. Render Free services may need up to about 50 seconds to wake after inactivity.

Creator Agent is currently most useful for:

• creators exploring a conversational layer for videos, podcasts, courses, newsletters, or documentation;
• developers studying private-by-default ingestion, grounded answers, tenant isolation, and bring-your-own-agent routing;
• early design partners willing to test onboarding, trust, customization, and source-review workflows.

Project status

The repository contains a test-first, responsive web MVP and a deployed public beta. It demonstrates the product, privacy, routing, authentication, persistence, and concurrency behavior without introducing a paid AI provider.

The default local simulator is intentionally deterministic and network-free. It makes no AI-provider calls, consumes no AI tokens, and cannot create model charges. The live Auth0 mode connects to the protected Creator Agent API and durable Neon PostgreSQL database, but it still does not invoke an AI provider.

E2E prototype video

Watch a narrated, captioned 33-second walkthrough of the creator studio, source ingestion, grounded answers with citations, agent customization, user-owned routing, and multi-user load controls. A separate WebVTT transcript is available for accessibility. The simulated product flow remains deterministic and makes no AI-provider or token-consuming requests; narration was synthesized from the published transcript without a developer API key.

For the complete build retrospective and key lessons, read Turn Your Content Into an AI Agent—Without Giving Up Control.

Available now

Current prototype boundaries

• Default local-simulator state is held in memory and resets on refresh; configured Auth0 mode persists the creator workspace through the API.
• The interface is a mobile-responsive web simulator, not yet an Expo/React Native app.
• The protected API persists creator identity, agents, versioned configuration, source privacy metadata, and private-upload lifecycle metadata. Auth0 mode can upload MP4 bytes when S3-compatible storage is explicitly configured; local mode and pasted text remain browser-only.
• Uploaded video is not scanned by the API request process. The opt-in one-shot worker requires private ClamAV configuration, performs bounded MP4 brand/movie-header/track inspection, and streams the exact full object for a malware verdict. Checksum verification, sandboxed full decoding, automatic transcription, managed transcript-review UI, and embedding are not implemented. The managed API now persists creator-provided WebVTT drafts separately and requires explicit approval, but durable transcript cues are not yet connected to retrieval.
• Pasted text uses deterministic term matching rather than model-based embeddings or generation.
• A real user-owned endpoint may create costs for its owner; Creator Agent never silently uses a platform or developer AI key.

Run the simulator

Requirements: Node.js 22 or later.

npm install
npm run dev

Open http://127.0.0.1:4173.

Development defaults to an explicit local session. To exercise managed OIDC, configure an Auth0 Single Page Application, custom API, and PostgreSQL identity store using the authentication setup guide and API guide. Production builds reject local authentication and fail closed when Auth0 or API configuration is missing.

For a public no-AI-cost beta, use the free deployment guide and included Render Blueprint. Free services sleep and have strict limits, so this path is for demos and beta validation rather than production availability.

The staged path from this MVP to a secure closed beta and public service is tracked in the production readiness roadmap. Development and CI remain deterministic and free of paid AI calls.

Useful checks:

npm test       # Core privacy, retrieval, idempotency, load, and UI tests
npm run check  # Typecheck, test, and production build
npm run scan:once # Inspect and malware-scan one durable upload; requires DB, storage, and private ClamAV env
npm run cleanup:once # Reconcile at most one tombstoned stored object; requires API DB/storage env

What to try

1. Add a pasted source, or choose Video file. Local mode can pair MP4, WebM, or QuickTime with an optional WebVTT transcript; configured Auth0 mode privately uploads MP4 only.
2. Open the audience preview and ask one of the suggested questions.
3. Open Customize and change voice preset, response depth, signature phrases, or boundaries.
4. Switch between Maya, Theo, and Jules to see isolated conversations.
5. Open Load lab and change traffic, concurrency, and queue limits.
6. Observe bounded rejection when a popular agent exceeds safe capacity.

With managed Auth0 and the optional GitHub App configured, choose Add source → GitHub repository to connect selected repositories and import one text file privately. See GitHub App setup and data boundaries.

In default local mode, simulator state resets on refresh and pasted content, selected video bytes, and WebVTT captions never leave the browser. A valid sidecar creates timestamped local knowledge immediately without calling an AI provider. In configured Auth0 mode, agent/source metadata persists and MP4 bytes upload directly to private object storage; the browser never receives storage credentials and never sends its Auth0 bearer token to storage. Managed video stays unavailable to retrieval until the separately scheduled quarantine scan and explicit transcript approval complete; the managed review UI and durable cue retrieval are still pending. See local WebVTT ingestion and private video uploads.

Zero-cost end-to-end routing

To exercise a real browser-to-agent HTTP request without calling an AI provider:

npm run dev:e2e

This starts:

• The simulator at http://127.0.0.1:4173
• A deterministic reference agent at http://127.0.0.1:4310/v1/respond

Open Route, select User-owned agent endpoint, confirm the processing boundary, and activate the prefilled local endpoint. The reference endpoint returns cited answers using approved excerpts and its health response reports aiCalls: 0.

To connect a real user-owned agent, replace the local URL with an HTTPS endpoint that implements the Bring Your Own Agent contract. Any model usage then belongs to that endpoint's owner; Creator Agent never silently falls back to a platform or developer AI key.

Not yet implemented

• Audience authentication
• Durable conversation persistence
• Upload retries, resumable/multipart upload, audit retention/export controls, and retention-policy verification
• Full sample-table/media decoding validation, checksum verification, parser sandboxing, and continuous scan scheduling
• PDF and local Markdown/plain-text file upload extraction (selected GitHub Markdown/MDX/text import is available)
• Automatic audio/video transcription and managed transcript-review UI
• Embeddings, vector retrieval, model generation, and streaming responses
• Native Expo/React Native application
• Broader agent/publishing audit events, rate limits, moderation, and account-deletion jobs
• Production monitoring, backups, alerting, and operational runbooks

Recommended MVP iteration

Keep the current deterministic simulator as a zero-cost product demo and regression suite. Add production capability through thin vertical slices that can each be tested end to end.

Iteration 1 — Durable creator workspace

1. Available: connect the managed OIDC client to a protected API and durable user record.
2. Available: PostgreSQL migrations for agents, agent versions, sources, and source visibility.
3. Available for current routes: resource-level authorization and tenant isolation in every workspace query.
4. Available: persist creator configuration and new source metadata while leaving deterministic chat in place.

Exit test: two signed-in creators cannot access or mutate each other's agents or sources.

Iteration 2 — Private video ingestion

1. Available: issue a 10-minute signed POST policy for one allowlisted format, starting with MP4.
2. Available: upload directly to private object storage without proxying large video bytes or forwarding the Auth0 token.
3. Available for scheduled scans: pin declared MIME type and exact byte size, inspect a supported ISO BMFF brand, movie duration, H.264 video track, and AAC audio track, then stream the exact object to private ClamAV in bounded chunks. Full decoding and checksum verification remain next.
4. Partially available: lease-based, concurrency-safe one-shot worker with uploaded → scanning → processing/failed; continuous scheduling and transcribing → ready remain next.
5. Available: local simulation builds timestamped chunks immediately; the managed API separately stores/version creator-provided WebVTT only after clean quarantine scanning and requires explicit approval. Next, connect approved durable cues to retrieval and later route automatic transcription to a self-hosted or creator-owned endpoint.
6. Let the creator review the timestamped transcript before approving it for public answers.

Exit test: an uploaded video becomes a reviewable, timestamped source; failed, unapproved, or deleted content never appears in chat.

Iteration 3 — Production grounded chat

1. Chunk approved transcripts and build a tenant-filtered vector index.
2. Retrieve only ready, explicitly approved sources.
3. Keep generation provider-neutral: local deterministic mode, creator-owned endpoint, or a future separately funded platform route.
4. Validate citations against supplied context and stream responses to the client.
5. Add evaluation cases for answerability, source accuracy, prompt injection, and prohibited topics.

Exit test: expected questions return supported answers with correct timestamps, and unsupported questions reliably abstain.

Iteration 4 — Mobile beta and operations

1. Build the Expo/React Native shell against the same authenticated API.
2. Add quotas, per-agent concurrency limits, moderation, abuse reporting, and audit events.
3. Add deletion workflows for originals, transcripts, chunks, embeddings, caches, and backups.
4. Add observability that uses opaque IDs and never logs uploaded content or conversations.
5. Run a small creator beta and prioritize changes from measured retrieval quality, latency, safety, and onboarding completion.

Exit test: the beta survives concurrent traffic, honors privacy and deletion controls, and exposes cost per active agent without using a developer's personal AI quota.

For each iteration: write the acceptance test first, implement the smallest end-to-end path, run npm run check, perform responsive browser QA, and merge a passing increment to main.

Non-goals for the first release

• Voice cloning or photorealistic avatars
• Autonomous posting or messaging on a creator's behalf
• Training a dedicated foundation model per creator
• Open-ended crawling of an entire social media presence
• Payments, subscriptions, marketplaces, or advertising
• Enterprise multi-team administration

Proposed stack

The architecture is intentionally provider-neutral. AI and storage services should sit behind small interfaces so cost, quality, and data-residency requirements can be revisited without rewriting product logic.

Target production user journey

1. A creator signs in and creates an agent.
2. They upload documents, audio, or video and confirm they have the right to use it.
3. Background workers extract or transcribe the content and build a searchable index.
4. The creator reviews sources and configures the agent's behavior.
5. They preview and publish the agent.
6. An audience member asks a question in the mobile app.
7. The API retrieves relevant source passages, generates a grounded response, and returns citations.

Repository layout

creator-agent/
├── apps/
│   ├── api/             # Auth0-protected API and creator identity migration
│   ├── local-agent/     # Zero-cost HTTP reference endpoint
│   └── simulator/       # Responsive React MVP and UI tests
├── packages/
│   └── core/            # Deterministic domain engine and load simulator
├── docs/
│   ├── AGENT_ROUTING.md # Bring Your Own Agent protocol and data boundary
│   ├── API.md           # Protected API setup and identity data boundary
│   ├── AUTHENTICATION.md # Auth0 OIDC setup and security boundary
│   ├── CUSTOMIZATION.md # Knowledge/style separation and evaluation
│   ├── DEPLOY_FREE_BETA.md # Render + Neon + Auth0 free beta launch path
│   ├── GITHUB_APP.md    # Free read-only GitHub App setup and import boundary
│   ├── LOCAL_VIDEO_TRANSCRIPTS.md # Zero-cost WebVTT sidecar workflow
│   ├── PRIVACY.md       # Prototype and GitHub integration privacy notice
│   ├── PRIVATE_UPLOADS.md # Signed MP4 upload and data-protection boundary
│   ├── PRODUCTION_ROADMAP.md # Closed-beta and public-launch execution plan
│   ├── SUPPORT.md       # Support and private security-reporting process
│   └── DESIGN.md        # Product, architecture, privacy, and scale design
├── package.json         # npm workspace scripts
└── README.md

The next production increment is tenant-filtered deterministic retrieval from approved durable transcript cues, alongside checksum/full-decoder hardening before any automatic transcription route can see the upload. The actual mobile and transcription-worker packages still wait on provider, privacy, and beta-cohort decisions. The deterministic core remains useful for product demos and fast policy regression tests.

Delivery milestones

Milestone 0 — Foundation

• Available: npm workspace, deterministic core, responsive simulator, Auth0 SPA integration, protected creator/workspace API, durable identity and workspace migrations, local reference endpoint, automated checks
• Available: public Free-tier beta on Render with managed Auth0 login and Neon PostgreSQL persistence
• Available: private signed MP4 upload authorization and completion verification
• Available: bounded metadata-aware uploaded → scanning → processing/failed transitions with exclusive leases
• Available: immutable content-free ingestion lifecycle audit events
• Next: broader agent/publishing audit coverage and continuous worker scheduling

Milestone 1 — Ingestion

• Available: local video staging plus configured private direct MP4 upload with exact-size/type enforcement and safe non-ready state
• Available: bounded MP4 brand, duration, H.264/AAC track validation with detected metadata persistence and invalid-object deletion
• Available: private ClamAV INSTREAM adapter, bounded full-object streaming, persisted clean/infected status, fail-closed retry behavior, and a free deterministic protocol suite
• Available: owner-scoped, versioned WebVTT draft/read/approve/reject API with timestamp validation, approval-gated readiness, content-free audit, and immediate caption erasure on source deletion
• Available: tombstone-first object deletion with lease-based retry reconciliation
• Next: sandboxed full decoding/checksum, durable creator-provided transcripts and review, real transcription, upload retry, and audit retention/export controls

Milestone 2 — Grounded chat

• Available: deterministic retrieval, prompt boundaries, citations, creator preview, BYOA routing
• Next: embeddings, tenant-filtered vector retrieval, streaming generation, video timestamps, evaluation suite

Milestone 3 — Publishing beta

• Available: simulated publishing and source-level public/preview controls
• Next: public profiles, real publish versions, abuse reporting, rate limits, moderation, quotas, closed beta

Product principles

• Grounded by default: prefer “I don't know” over unsupported answers.
• Creator-controlled: creators can inspect, disable, or delete every source.
• Transparent: clearly identify the agent as AI and show supporting sources.
• Consent-first: do not impersonate a creator or ingest content without rights.
• Measurable: evaluate answer quality, retrieval quality, latency, and cost continuously.

Key documentation

• Product and technical design
• Managed Auth0 authentication
• Protected API and durable identity
• Private video upload boundary
• Creator customization model
• Bring Your Own Agent routing contract

Share and help shape the project

If Creator Agent is relevant to your work, the most useful ways to help are:

• try the live beta and report where onboarding or trust is unclear;
• share the demo video or build retrospective with a creator who manages a large content library;
• open a GitHub issue with one concrete use case, expected question, and source type;
• star or watch the repository if you want to follow the mobile, transcription, and grounded-retrieval milestones.

Please do not include private content, credentials, access tokens, personal data, or security vulnerability details in public issues. Use the private reporting process in Support and security for sensitive reports.

Contributing

The project is pre-alpha. Review the privacy requirements, open questions, and acceptance criteria in the design document before adding infrastructure or AI providers. Keep changes small, add tests with each increment, and require npm run check before merging to main.

License

No open-source license has been selected. Until one is added, all rights are reserved.