# Businessplan: JARVIS-operated Content Machine

Date: 2026-05-24

## Executive summary

The Content Machine is an approval-first social-media production system operated by JARVIS. Its purpose is to create high-quality short-form posts for YouTube Shorts, TikTok, Instagram Reels, and later adjacent platforms with minimal human workload and no automated posting without explicit human approval.

The system does not optimize for maximum volume first. It optimizes for repeatable quality, distinct positioning, follower conversion, reviewability, and later analytics-driven scaling.

Core promise:

> JARVIS generates, scores, previews, packages, and maintains the content pipeline. The user only gives final approval before posting and occasionally steers strategy.

Non-negotiable:

> No contribution is uploaded, scheduled, posted, or published without explicit approval for the exact preview/package version.

## Strategic positioning

The channel should not become another generic AI tips account. The differentiator is the machine itself and the worldview behind it:

- AI as an operating system for real life, not prompt tricks.
- Systems over hacks.
- Human governance over blind automation.
- Transparent quality gates and constraints.
- Mechanism-first visuals instead of generic AI stock footage.
- Real artifacts, workflows, failures, and decisions.

Target viewer identity:

> Serious builders who want AI systems that survive contact with real life.

Primary value promise:

> Follow for concrete AI workflows, system boundaries, and automation decisions that are useful, auditable, and not hype theatre.

## Initial content pillars and series

### Pillar: AI Life Systems

Positioning:

- AI as a servant for practical systems.
- Human values and approvals stay outside the automation boundary.
- Useful, skeptical, precise.

Initial series families:

1. `Prompt vs System`
   - Shows why a prompt trick fails and what system replaces it.
   - Best for differentiation.

2. `AI System Autopsy`
   - Breaks down a failed workflow or bad automation idea.
   - Structure: problem -> cause -> system fix -> result.

3. `Workflow Teardown`
   - Breaks down a safe, generic workflow pattern without exposing JARVIS, the user, or private collaboration details.
   - Strong for trust while keeping the operating machine invisible to the public.

4. `One Rule, One Example`
   - One principle, one concrete application.
   - Good for clarity and repeatability.

5. `AI Hype Court`
   - A viral AI claim is tested.
   - Structure: claim -> evidence -> verdict -> better action.

## Hard no-go topics

Public content must never be about:

- JARVIS/Hermes as a named system or persona;
- the user;
- the user/JARVIS collaboration;
- private chats, private workflows, or behind-the-scenes details;
- politics, elections, persuasion campaigns, or partisan topics;
- legally sensitive loopholes, rule-bypassing, private-data misuse, or anything that could enable lawbreaking;
- morally objectionable exploitation or harm.

These topics are internal operating constraints, not public content angles. The machine may use them as blockers, but not as hooks.

## Operating model

### JARVIS responsibilities

JARVIS owns the day-to-day operation:

1. Content research and idea generation.
2. Candidate creation and prioritization.
3. Strategy scoring.
4. Script drafting.
5. Hook, retention, identity, originality, and anti-slop gates.
6. Preview generation.
7. Social-media draft generation.
8. Description/caption/hashtags/tags/title variants.
9. Approval package preparation.
10. Queue management and daily volume policy execution.
11. After platform adapters exist: upload preparation and scheduling only after approval.
12. Analytics import and feedback loop after posts are live.
13. Maintenance of scripts, tests, docs, and quality gates.

### User responsibilities

The user workload should stay minimal:

1. Define or adjust high-level strategy when needed:
   - channels/platforms;
   - daily video volume;
   - no-go topics;
   - brand/personality boundaries;
   - monetization goals.

2. Review approval packages:
   - watch preview video;
   - inspect title/caption/description/hashtags/tags;
   - reply with one explicit command.

3. Give explicit approval before posting:
   - `Freigabe alle`
   - `Freigabe YouTube`
   - `Freigabe TikTok`
   - `Freigabe Instagram`
   - `Ablehnen`
   - `Ändern: <requested change>`

4. Optional: provide source material:
   - voice notes;
   - rough ideas;
   - links;
   - transcripts;
   - screenshots;
   - lessons from real workflows.

The user does not need to:

- write scripts manually;
- create captions manually;
- generate tags manually;
- manage render folders;
- operate FFmpeg/ComfyUI/platform APIs manually;
- maintain content queues;
- remember what worked last week.

## End-to-end pipeline

### Phase 1: Strategy and idea creation

Input sources:

- JARVIS-generated ideas from content pillars.
- Research/trend notes.
- User-provided notes or voice messages.
- Public-safe workflow patterns and non-private source material.
- Later: transcripts, documents, and analytics history that are explicitly approved for public use.

Python/script support:

- `autoshorts.config.pillars`
- `autoshorts.content.brief`
- future `autoshorts.strategy.series`
- future `autoshorts.strategy.volume_policy`

Output:

- `ContentBrief` with topic, audience problem, payoff, platforms, tone, no-go rules, and target duration.

User involvement:

- Usually none.
- Occasionally approve or adjust pillars/series.

### Phase 2: Strategy scoring and candidate filtering

Each idea is scored before rendering. The machine checks whether the content can actually stop, retain, build trust, and convert viewers into followers.

Implemented / planned Python support:

- `autoshorts.strategy.score.ContentStrategyScore`
- `autoshorts.strategy.score.build_candidate_strategy_review()`
- `autoshorts.scripting.quality.should_render()`

Scored dimensions:

- hook strength;
- curiosity gap;
- viewer identity;
- target emotion;
- trust signal;
- follow reason;
- originality;
- variety / repetition risk.

Reject/defer reasons:

- generic AI-slop language;
- weak follow reason;
- no clear curiosity gap;
- too similar to recent content;
- high policy risk;
- low quality score.

Output:

- `CandidateStrategyReview` with `render_allowed=True/False`, reject reasons, and improvement suggestions.

User involvement:

- None unless JARVIS asks a strategic question after repeated rejects.

### Phase 3: Script and retention structure

JARVIS turns approved strategy candidates into structured scripts.

Python/script support:

- `autoshorts.content.script_draft`
- `autoshorts.content.to_candidate`
- `autoshorts.ideas.factory`
- `autoshorts.ideas.candidate`
- `autoshorts.ideas.testbatch`

Script structure:

- first-frame hook;
- retention beats;
- visual concept;
- caption direction;
- CTA;
- planned duration;
- quality/policy notes.

Output:

- `ScriptDraft`
- `VideoCandidate`
- `TestBatch` when batching several candidates.

User involvement:

- None by default.
- Optional: reject/edit later at preview stage.

### Phase 4: Review batch and pre-render gating

Before expensive preview/render work, JARVIS prepares text-based review and gate results.

Python/script support:

- `autoshorts.review.workflow`
- `autoshorts.review.render`
- `autoshorts.review.package`
- `autoshorts.review.approvals`

Output:

- ready candidates;
- blocked candidates;
- invalid candidates;
- concise reasons and review text.

User involvement:

- Usually none unless the batch is intentionally sent for early direction.

### Phase 5: Render planning

JARVIS creates a deterministic visual plan before generating media.

Python/script support:

- `autoshorts.rendering.shot_plan`
- `autoshorts.rendering.manifest`
- `autoshorts.rendering.preview`

Output:

- `ShotPlan`
- `RenderManifest`
- side-effect-free HTML preview.

Guardrails:

- vertical format;
- renderer-owned captions/labels;
- no baked-in text inside AI assets;
- no static slideshow defaults;
- no ComfyUI/Wan/platform calls at planning stage.

User involvement:

- None by default.

### Phase 6: Local approval preview

JARVIS creates a quick German approval preview so the user can understand and approve the concept before final English production.

Python/script support:

- `autoshorts.rendering.local_preview`
- `autoshorts.rendering.local_frame_writer`
- `autoshorts.rendering.ffmpeg_plan`
- `autoshorts.rendering.ffmpeg_renderer`
- `autoshorts.cli.demo_local_preview_video`

Output:

- PNG scene cards;
- FFmpeg concat file;
- MP4 timing preview.

Default settings:

- `540x960`
- `24fps`
- approval language: German
- final video language: English

User involvement:

- Watch preview when sent in approval package.

### Phase 7: Social post draft generation

JARVIS prepares platform-facing metadata.

Python/script support:

- `autoshorts.social.draft`
- `autoshorts.social.review`
- `autoshorts.social.delivery`

Draft contents:

- platform targets;
- title variants;
- description/caption;
- hashtags;
- tags/keywords where platform supports them;
- CTA;
- hook;
- duration;
- policy/risk notes;
- synthetic-content disclosure state later;
- approval requirement.

Platform-specific direction:

- YouTube Shorts:
  - title variants;
  - description;
  - hashtags;
  - tags/keywords if useful;
  - synthetic/altered disclosure metadata later.

- TikTok:
  - caption;
  - hashtags;
  - concise CTA;
  - trend/sound strategy later if explicitly enabled.

- Instagram Reels:
  - caption;
  - hashtags;
  - optional cover/title direction later.

User involvement:

- Inspect only the generated approval package.
- No manual copywriting required unless the user wants changes.

### Phase 8: Content preview approval package

JARVIS combines the preview video and the social draft into one approval unit.

Python/script support:

- `autoshorts.preview.package`
- future `autoshorts.preview.delivery`

Approval package includes:

- candidate id;
- preview version/fingerprint later;
- MP4 preview path;
- title variants;
- description/caption;
- hashtags/tags;
- platforms;
- final-video language;
- approval-preview language;
- quality/risk notes;
- explicit approval commands.

User involvement:

- Required.
- This is the minimum human step.
- No approval means no posting.

### Phase 9: Final render / asset generation

After approval of concept/metadata, JARVIS can prepare final production.

Possible production layers:

1. Local motion renderer + FFmpeg.
2. TTS voiceover.
3. Captions and timing.
4. Qwen Image / ComfyUI keyframes.
5. Wan/LTX image-to-video or video clips.
6. Hybrid assembly with deterministic overlays.

Guardrails:

- AI assets should not contain baked-in text.
- Captions, labels, arrows, numbers, and factual text stay renderer-owned.
- External calls and side effects are explicit boundary objects.
- Paid providers or subscriptions require separate approval.

User involvement:

- None if the already-approved package does not materially change.
- If final output differs materially from the approved preview, JARVIS must request re-approval.

### Phase 10: Pre-post check and explicit approval boundary

Before any platform action, JARVIS performs a final gate:

- exact approved package/version exists;
- approval command matches target platform;
- final media file exists;
- metadata present;
- disclosure metadata present if required;
- no credentials in logs/chat;
- no platform call unless approval state is valid.

If approval is missing, ambiguous, stale, or version-mismatched:

> do not post.

User involvement:

- Explicit approval is mandatory.

### Phase 11: Manual upload in phase 1; platform automation later

In phase 1 the user manually uploads approved final videos to YouTube Shorts and TikTok.

Implemented / planned Python support:

- `autoshorts.social.manual_posting` — side-effect-free manual posting copy pack.
- future `autoshorts.publishing.youtube`
- future `autoshorts.publishing.tiktok`
- future `autoshorts.publishing.instagram`
- future `autoshorts.publishing.queue`
- future `autoshorts.publishing.audit`

Phase-1 manual posting pack includes:

- final video file path;
- YouTube title;
- YouTube description;
- YouTube hashtags;
- YouTube tags/keywords;
- TikTok caption;
- TikTok hashtags;
- platform-specific copy instructions;
- explicit note that no platform upload was performed.

Rules:

- phase 1 performs no platform API calls;
- user manually uploads/copies metadata;
- no later automated upload/post without exact approval;
- no automatic retry that creates duplicate posts;
- every later platform action must be audited locally;
- platform credentials never enter git/chat;
- generated media stays in runtime directories.

User involvement:

- Phase 1: manually upload approved video and copy the supplied metadata.
- Later automation phase: none after explicit approval unless an upload error needs a decision.

### Phase 12: Analytics and feedback loop

After posts are live, JARVIS imports or records performance data.

Future Python/script support:

- `autoshorts.analytics.imports`
- `autoshorts.analytics.scorecard`
- `autoshorts.analytics.feedback_loop`

Tracked fields:

- views;
- average view duration;
- retention checkpoints;
- completion rate;
- rewatches;
- likes;
- comments;
- shares;
- saves;
- follows per view;
- negative feedback;
- platform;
- post time;
- series id;
- hook type;
- format family;
- title/caption variant.

JARVIS uses analytics to:

- recommend daily volume;
- adjust series mix;
- detect fatigue;
- improve hooks;
- retire weak formats;
- double down on proven formats.

User involvement:

- Review periodic summary if desired.
- Decide strategic changes when JARVIS recommends them.

## Daily volume policy

Video volume should be configurable and analytics-led.

Initial recommendation:

- Generate 1-3 candidates/day.
- Send only the best approval package(s).
- Post fewer than generated until quality and analytics are proven.

Possible later modes:

- `test_mode`: 1 post/day max.
- `growth_mode`: 2-4 posts/day if quality and analytics support it.
- `experiment_mode`: platform-specific tests with capped risk.

JARVIS should never increase volume just because generation is cheap. Cheap garbage remains garbage, merely with better margins.

## Approval language and final language

Current policy:

- Approval previews: German.
- Final social videos: English.

Reason:

- German previews make user review faster and more reliable.
- English final videos fit broader platform growth.

## Required user inputs before full operation

Minimum inputs still needed from the user:

1. Confirm initial platforms:
   - YouTube Shorts?
   - TikTok?
   - Instagram Reels?

2. Confirm target daily volume mode:
   - start with 1/day?
   - generate 3/day but send 1/day for approval?

3. Confirm hard no-go topics:
   - Already fixed: no public content about JARVIS/Hermes, the user, or their collaboration;
   - Already fixed: no politics;
   - Already fixed: no legally sensitive, morally objectionable, rule-bypassing, private-data misuse, or lawbreaking content;
   - optionally add extra brand-specific exclusions later.

4. Confirm public brand boundary:
   - faceless AI-systems education without naming JARVIS/Hermes;
   - human-present creator identity only if explicitly approved later;
   - no private collaboration or behind-the-scenes personal material.

5. Confirm monetization direction:
   - audience first;
   - affiliate later;
   - consulting/product later;
   - channel monetization later.

Everything else can be proposed and maintained by JARVIS.

## Immediate implementation roadmap

1. Strategy gate layer.
   - Implemented first slice: `ContentStrategyScore` and `CandidateStrategyReview`.

2. Content series registry.
   - Define allowed series, promise, format rules, no-go patterns.

3. Preview delivery object.
   - Wrap approval package into Telegram/local-safe delivery text plus `MEDIA:` preview path.

4. Demo content preview CLI.
   - One command creates preview video + social draft + approval package.

5. Versioned approval fingerprint.
   - Approval binds to exact package version.

6. Daily volume policy.
   - Configurable generation/posting limits.

7. Analytics schema.
   - Prepare feedback loop before real posting scale.

8. Publishing adapters.
   - Only after approval/versioning/audit boundaries are boring and tested.

## Final operating principle

The Content Machine is not a video generator. It is a governed growth engine:

```text
Research
-> Idea
-> Strategy Score
-> Script
-> Quality Gate
-> Preview
-> Social Draft
-> Approval Package
-> Human Approval
-> Final Render
-> Pre-post Audit
-> Platform Action
-> Analytics
-> Next Batch
```

Posting is not a formatting side effect. It is a controlled boundary requiring explicit human approval.