Autopo

One task in full: description, criteria, status, the thread's last comments, its pull requests and deliverables.

A video's storyboard in full: every shot (picture, line, text, seconds, direction, takes), the style and models it is made with, the presenter, cards, the finished render, and what is missing before it can render. `engine` says how it is cut (ffmpeg: the joiner; remotion: a code film), `cut_choice` who chose that and why (the Creative Director picks per film; `engine` follows when she reaches the cut), and `code` where a code film stands (version, checked, errors; get_video_code for the project).

A video's code film (a Remotion project its storyboard compiles to): the version, the head's files (paths), the scenes, the last check (ok, errors with file and line, warnings), the preview link and the latest versions. With `file` (a path, e.g. src/Film.tsx) one file's content and who wrote it. 404 before convert_video_to_code.

A whole video at once from a plan (the shape video_plan returns: title, brief, aspect_ratio, style, presenter, shots). Give the `plan` as JSON, or a `path` on this machine (a zip with plan.json and the files it names as file:…, a plan.json with those files beside it, or the folder holding them), or a `url` to such a zip or plan.json. Footage, voice tracks and icons the plan names are uploaded first (in chunks, any size), then the plan is imported with their media ids.

Every charge, newest first (`kind`, `agent` filter).

The team: every agent with its role, title, state and whether it is on. Chat with one through ask_agent.

What the team made: documents, research, decks, tables, videos, designs (`type`), delivered work, `q` searches, `starred` only yours.

The CEO's board briefings (spoken updates), newest first, with their text.

Your chats across the team (pinned first, then recent); `q` searches titles and content.

The companies you belong to (id, name, stage, kind). Other tools take `company`: one of these ids. Start here.

The Board inbox: cards waiting for you (`status` pending, default), or decided ones. Each card says what the team wants, why, the risk tier and the amount; decide with `decide`.

Errands (web chores Peyk does in a browser, stopping before anything you can’t undo): what needs you, the one on it, what is up next, drafts, and the 20 newest finished.

The media library: images, clips, voice lines and music, with filters (`kind` image|video|audio, `source` generated|uploaded|recorded|rendered, `q`, `starred`).

The people in the company (owner, admins, members, viewers) with their user ids and whether they are online.

Social posts: upcoming, published or failed (`status`), per `account`.

Agent runs: `status` active (queued, running), finished, or a comma list; `agent` an agent id.

The work board: tasks by status, assignee role or goal; `q` searches titles; `mine: true` only what you asked for (your requests).

The Studio's videos (productions): title, status, shape, length.

Make what a video still lacks (spends credits; you confirm the cost in a dialog): `what` all (clips and voice lines), visuals, voice, or music (composed from the style’s music cue). `model` overrides the clip model for this call. Then wait_for_video.

Change the radar: `add` a rival (`name`, `url`, `note`?; up to 8), `confirm` a proposed one (`competitor`), `remove` one (its history stays), `discover` rivals from a few web searches (proposed for your yes), or `scan` their pages now (once an hour). Removing and discovering ask first.

What worked and what didn’t: the learnings log, newest first.

Steer a run that is still going: a line of guidance the agent reads at its next step.

Open a place in the Autopo web app in your browser: `what` is home, hive, inbox, task, work, knowledge, team, chat, studio, video, marketing, social, money, connectors or settings; `id` the card, task, artifact, chat or video when there is one.

The workspace’s plan: run-minutes used and left this period, the plans on offer, how each model and media provider is paid (your own key, or Autopo’s billed to the card daily), today’s unbilled use and the recent daily charges. `enabled: false` means plans are off and credits pay for everything (budget).

Change how the plan may spend: `overage_cap_cents` (Max only: the most overage a period may run up, 0–10,000,000) and `disabled_providers` (every model or media provider to turn off, on your key and Autopo’s alike; `[]` turns all back on). You confirm in a dialog.

A chat's messages, oldest first (the last reply's status says whether it is still answering).

Cut the video into one MP4 (free). get_video says what is missing when it refuses; the render takes a minute or two: wait_for_video. A code film (`engine` remotion) renders its last checked version through Remotion, so the check must pass first (check_video_code); the refusal names the film's problem.

Bring an earlier version of a video's code film back as a new version (source restore), checked at once.

A new version of an artifact a member made (agents’ work is revised with artifact_feedback): the same kinds of input as create_artifact, or `content` alone; it keeps its type. `base_version` guards against overwriting someone else’s newer version. The result has `app_url`.

Replace a video's storyboard: shots in order, each {visual: generate|footage|title|presenter, prompt, voiceover, on_screen_text, duration_seconds, media?, voice?, direction?, keep_audio?, notes?}. Send a shot's `id` to keep its media; a shot without one is new.

Make a public link to an artifact that anyone with the address can open without signing in (review notes, costs and hidden parts never show). `version` pins it (else it follows the latest), `scope` view_history also shows past versions, `expires_at` (ISO with offset) ends it. You confirm in a dialog; unshare_artifact revokes it. The result has `share_url` (the public page) and `app_url` (its page in the web app).

The company’s Shopify store, read-only: whether it is connected, the store, its currency, the webhooks, when it last synced and how many products and orders were read.

The company’s social accounts and networks, and what each account may post on its own.

Start a drafted errand: Peyk (or `agent`) works its plan in a browser and stops at every checkpoint for you (answer_errand). Runs cost credits up to the plan’s cap; you confirm the plan in a dialog first.

The Studio: every model this company can run (what it is for, price, shapes, availability), the voices, the default models and narrator, providers, the team's allowance, and whether this server can check and render code films (`can_render_code`).

Change the Studio's defaults: `default_models` by kind (image, video, voice, music: model keys from studio_overview) and the default narrator `voice` (a voice key).

Read the connected store again now (`check` instead tests that the connection still works and has every permission).

Revoke a public link to an artifact (`link` is its token from artifact_links): the address stops opening at once.

Rename, star or delete a piece of media; `retry` makes a failed generation again (it spends credits again: you confirm in a dialog); `cancel` stops one.

Change a task: its title, description, status, priority, assignee or criteria. To cancel one, use cancel_task.

Change a video: title, brief, shape, or its `style`: music, captions, transition (cut|fade), colours, the narrator `voice`, the `look` (palette, light, camera, texture, mood, type, avoid, brand light|balanced|strong), the music cue (`music_prompt`, `music_bpm`, `beat_sync`), and `models` {clip, keyframe, voice, music, speaking}.

Put your own files into the Studio library: recordings, screen captures, photos, a voice track, music. Each item is a `path` on the machine this server runs on (a file, or a folder: every image, clip and audio file in it, in name order; you confirm the list in a dialog before anything leaves the machine) or a public `url`. Only images, clips and audio can be uploaded. The server uploads them itself, in 8 MB chunks, straight to the platform. With `video`, the files belong to that video; an item's `shot` (a shot id) puts it on that shot (a clip or image becomes the shot's picture as footage, audio becomes its voice line); `in_order: true` puts the files, in order, on the video's shots that have no picture yet. Returns the media ids (processing for a moment, then ready; wait_for_video waits for them).

Every version of a video's code film, newest first: number, source (compiler, agent, founder, restore), note, files, who made it and when; `head` is the current one.

Draw stills of a video's code film as Studio images (free; seconds after the first build): `frames` (frame numbers at the film's fps) or `every_seconds`; neither: the middle of every shot. Up to 12 a call. Needs a passing check. Each result has a url and thumb_url to look at before a render.

Make the keyframes first (a still of each generate shot’s first frame, cents each; you confirm in a dialog) so the look is locked before clips are paid for. `shots`: shot ids, default every shot without one.

A video as a plan (JSON): its shots, presenter, style, media ids. Change it and import it back with import_video_plan.

Wait while a video’s media or render is being made (up to `wait_seconds`, default 60, max 120) and return where it stands: shots generating, the render, what is still missing. Call it again if it is still going.

The signed-in person: name, email, preferences, and how many companies they are in.

Write files of a video's code film: `files` [{path, content}] (content null removes a file; paths under src/ ending .ts, .tsx, .js, .jsx, .css or .json; src/film.json, package.json and tsconfig.json are the compiler's and follow the storyboard). A new version is made and checked at once (tsc, the lint, the scene list, the preview build): `check` says ok, or the errors with file and line. Free. Only `@autopo/film`, react, remotion, `@remotion/*`, zod and the film's own files may be imported; words live in film.json, not in code.