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
| Capability |
Current implementation |
| Managed creator authentication |
The live beta uses Auth0 Universal Login with OIDC Authorization Code and PKCE, in-memory token caching, stable sub identity, and login/logout/error states. |
| Protected creator API |
GET /v1/me validates Auth0 JWT signature, issuer, audience, expiration, RS256, subject, and read:creator permission before returning an internal creator ID. |
| Durable creator identity |
PostgreSQL maps verified (issuer, sub) values to an opaque internal UUID without storing profile data or access tokens. |
| Owner-scoped workspace API |
Authenticated routes create, list, read, and version agents plus private-by-default source metadata. Every database path includes the verified internal owner ID. |
| Durable studio synchronization |
Auth0 mode loads or bootstraps the creator's agent, restores customization, and persists configuration plus new source metadata updates. Local mode remains network-free. |
| Free GitHub App integration |
The minimum-permission integration path can list selected repositories and import one Markdown/MDX/text file (up to 1 MB) as preview-only knowledge. Tokens stay server-side and no AI call is made. Public GitHub App registration is the remaining launch step; see the launch guide. |
| Creator studio |
A seeded creator can manage an agent and its knowledge sources in a responsive web interface. |
| Text ingestion |
Document or audio-transcript text can be pasted, chunked, and indexed in browser memory. Local video can use a creator-provided WebVTT sidecar immediately; the managed API can durably store and version a validated WebVTT draft after quarantine scanning without an AI call. |
| Private MP4 upload |
In managed Auth0 mode, an MP4 up to 250 MB uploads directly to private S3-compatible storage through a 10-minute, exact-key/type/size policy. The Auth0 token is sent only to the API, never to storage. Local mode still stages the file without a network request. |
| Quarantine scan boundary |
A zero-AI one-shot worker safely claims uploaded sources with PostgreSQL leases, validates bounded MP4 metadata, then streams the exact full object in 1 MB chunks to a private ClamAV daemon. Only a clean verdict persists duration/codecs plus malware status and moves the source to Awaiting transcription. Invalid or infected files are deleted and disabled; scanner outages stay quarantined for bounded retry. |
| Honest video status |
A video without captions remains Awaiting transcription, and a durable upload stops at Uploaded. Local mode can build timestamped chunks immediately. The managed API requires a clean quarantine verdict and explicit transcript approval before moving the source to ready; replacement revokes public visibility. |
| Source privacy |
Sources are preview-only by default and require explicit approval for public answers. Processing, disabled, preview-only, and deleted sources are excluded from public retrieval. |
| Grounded chat |
A deterministic local retrieval engine answers from approved text and returns source citations or says that it lacks enough information. |
| Multi-user conversations |
Maya, Theo, and Jules have isolated histories; one audience member cannot read another's conversation. |
| Agent customization |
Creators can version voice presets, response depth, signature phrases, prohibited topics, greeting, tone, and behavioral boundaries. |
| Zero-cost preview |
Style and grounded-answer previews run locally without network requests or AI usage. |
| Bring Your Own Agent |
A creator can explicitly route generation to a trusted endpoint using the documented contract. Only approved excerpts and bounded history are sent. |
| Local agent endpoint |
A deterministic HTTP reference agent supports real browser-to-endpoint testing and reports aiCalls: 0. |
| Load lab |
Adjustable traffic, concurrency, and queue limits demonstrate tenant-aware capacity and graceful overload. |
| Deletion |
Deleting a source immediately removes its chunks from retrieval in the simulator. |
| Durable storage cleanup |
API deletion tombstones durable metadata before removing the object and records physical completion. A zero-AI lease-based reconciler retries tombstoned objects after transient storage failures. |
| Immutable ingestion audit |
PostgreSQL records content-free creator/system events for source authorization, upload completion/failure, scan claims/results, tombstoning, and physical storage deletion. Database triggers reject event updates and deletes. |
| Automated validation |
Core, UI, routing, privacy, idempotency, upload-validation, and load tests run through npm test; npm run check also typechecks and builds every workspace. |
| Continuous integration |
A read-only, secret-free GitHub Actions workflow runs locked installation, typecheck, tests, production build, and production dependency audit on main and pull requests. |
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
- 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.
- Open the audience preview and ask one of the suggested questions.
- Open Customize and change voice preset, response depth, signature phrases, or boundaries.
- Switch between Maya, Theo, and Jules to see isolated conversations.
- Open Load lab and change traffic, concurrency, and queue limits.
- 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
- Available: connect the managed OIDC client to a protected API and durable user record.
- Available: PostgreSQL migrations for agents, agent versions, sources, and source visibility.
- Available for current routes: resource-level authorization and tenant isolation in every workspace query.
- 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
- Available: issue a 10-minute signed POST policy for one allowlisted format, starting with MP4.
- Available: upload directly to private object storage without proxying large video bytes or forwarding the Auth0 token.
- 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.
- Partially available: lease-based, concurrency-safe one-shot worker with
uploaded → scanning → processing/failed; continuous scheduling and transcribing → ready remain next.
- 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.
- 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
- Chunk approved transcripts and build a tenant-filtered vector index.
- Retrieve only ready, explicitly approved sources.
- Keep generation provider-neutral: local deterministic mode, creator-owned endpoint, or a future separately funded platform route.
- Validate citations against supplied context and stream responses to the client.
- 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
- Build the Expo/React Native shell against the same authenticated API.
- Add quotas, per-agent concurrency limits, moderation, abuse reporting, and audit events.
- Add deletion workflows for originals, transcripts, chunks, embeddings, caches, and backups.
- Add observability that uses opaque IDs and never logs uploaded content or conversations.
- 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
| Area |
Choice |
| Mobile app |
Expo + React Native + TypeScript |
| API |
Node.js + TypeScript (Fastify or NestJS) |
| Background jobs |
Redis-backed worker queue |
| Primary database |
PostgreSQL |
| Vector search |
pgvector |
| File storage |
S3-compatible object storage |
| AI providers |
Provider adapters for transcription, embeddings, and generation |
| Authentication |
Managed OIDC-compatible authentication |
| Observability |
Structured logs, traces, error tracking, and product analytics |
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
- A creator signs in and creates an agent.
- They upload documents, audio, or video and confirm they have the right to use it.
- Background workers extract or transcribe the content and build a searchable index.
- The creator reviews sources and configures the agent's behavior.
- They preview and publish the agent.
- An audience member asks a question in the mobile app.
- 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
Creator Agent — это платформа для создания AI-агента, опирающегося на собственные документы, аудио и видео автора, чтобы аудитория могла задавать ему вопросы и получать ответы со ссылками на источники из этого контента.