PXLbid — Tool Guide

PXLbid User Guide

For: experienced VFX producers and supervisors who are new to PXLbid
What this guide does: explains what PXLbid does, how to use it, and how to make the numbers match your studio

What PXLbid does (and does not)

PXLbid turns a script into a structured breakdown of sequences, shots, and assets — then prices it and produces a broad schedule.

The flow is: drop a script (PDF, DOCX, or TXT) → AI reads it and builds a first breakdown → you review and edit it → produce a bid (cost + man-days per discipline) and a first schedule (how long with N artists).

What it stops at: the bid and a broad schedule showing total calendar days by discipline and team size. Assigning work to named artists with their own rates, capabilities, and calendars is PXLflow's job, not PXLbid's — PXLbid is the pre-production estimate tool.

What's not here: per-artist scheduling, rate-card matrices, retake discounts, overtime, or batching logic. It is deliberately simple — one blended day rate, one baseline per discipline, five complexity tiers, three seniority levels. Everything you tune lives in Rates & effort, not hidden in a dozen configuration tabs.

Before you start — prerequisites

1. Access: Cris has placed your email on the allowlist. Sign in with that Google account. The first sign-in shows a warning screen — see Signing in, and the warning Google shows you below, because it looks alarming and it is not.
2. Browser: use Chrome or Edge. PXLbid runs in any modern browser, but project folders — saving your breakdowns to a folder on your own disk — only work in Chrome or Edge. Firefox and Safari have not implemented the browser API that lets a page write to a folder you choose. Everything else works there; you just cannot pick a project folder, and the app says so in its header rather than failing quietly. If you only ever want breakdowns kept in the browser, any modern browser is fine. Your breakdowns live on your machine — nothing you produce is saved to a server.
3. Your own Anthropic API key: the app needs one to run the VFX Supervisor and Producer agents. You pay Anthropic directly, on your own account — PXLbid holds no credits, no quota and no cap over you, and never sees your billing. Your key travels with each run to reach Anthropic, and is never stored, logged or written to disk. See Where your script goes (NDA) for exactly what happens to it.

Signing in, and the warning Google shows you

The first time you sign in, Google will stop you with a full-page warning saying it hasn't verified this app, and offer you a blue Back to safety button. Most people press it. Do not — you would be pressing the button that takes you away from the tool you came to try.

Here is what it is. Google runs a formal verification review for apps that ask for access to a Google account, and PXLbid has not been through it yet. It is a paperwork queue, not a security finding: nobody has looked at PXLbid and concluded anything about it. Every app in a private beta looks exactly like this until its developer pays for and completes that review, which is not worth doing for a tool being handed to a handful of testers.

What PXLbid actually asks for is your basic Google profile: your email address, your name, and your profile picture. The email is checked against the allowlist; the name and picture are what you see in the top-right corner of the app once you are in. That is the whole list. It does not read your Gmail, your Drive, or your calendar, and it cannot — it never requests those permissions.

The warning itself says the app is requesting "sensitive info". That is Google's fixed wording on this screen, printed for every unverified app regardless of what it actually asked for; it is not a description of PXLbid's request. The screen that follows this one lists the real permissions, and you can read them there before approving.

To get through it:

1. Click Advanced — the small blue text at the bottom left of the card. Not "Back to safety".
2. The card expands and a link appears at the bottom: Go to PXLbid (unsafe). Click it.
3. Google's normal permission screen follows, listing what the app is asking for. Approve it and you are signed in. If your address is not on the allowlist yet you will land on an Access pending card rather than in the app — that is the allowlist, not this warning, and it is fixed by asking Cris rather than by signing in again.

Google remembers the decision for your account, so later sign-ins normally go straight through. While the app is still unverified the grant can lapse after a while and put the screen in front of you a second time — same screen, same way past it.

If you would rather not click past a warning at all, that is a completely reasonable position — say so and you will get a straight answer about what the app touches, rather than a nudge.

Getting an Anthropic (Claude) API key

PXLbid runs on your Anthropic account, not mine. That is deliberate, and it is worth one paragraph before the steps.

If I gave you access on my key, I would be metering you: counting your runs, capping your usage, and sitting between you and the model. I do not want that, and you should not want it either. On your own key nobody holds credits or quotas over you — during the beta you can run as many breakdowns as you like, on whatever scripts you like, and the only person who can see your usage is you. You pay Anthropic directly, at cost, with no markup from me.

There are only two situations.

If you already have an Anthropic API key

Paste it into PXLbid and you are done — skip the rest of this section.

Click the gear icon in the top-right corner of the PXLbid header to open Settings, paste the key into the Anthropic API key field, and click Test connection. That sends one tiny request to confirm the key works and costs a fraction of a cent. Green means you are ready.

Any existing key works — there is nothing PXLbid-specific about it. If you would rather keep this tool's spending separate from your other work, make a second key named "PXLbid" so you can see its usage on its own line in Anthropic's dashboard, but that is a convenience, not a requirement.

If you do not have one yet

You need to create an Anthropic account, put credit on it, and generate a key. Anthropic's own documentation is the authority on all three, and it stays current in a way anything I copy here would not:

• How can I access the Claude API? — creating the account
• I created a Console organization — how do I start? — the walkthrough, with screenshots
• How do I pay for my Claude API usage? — credits and billing

The console itself is at platform.claude.com. If you have ever used Claude, the same login works.

The short version, and the three things worth knowing before you start:

1. The API is prepaid, and it is separate from a Claude subscription. You buy credits up front and draw them down. There is no monthly fee and nothing recurs. A Claude Pro or Max subscription does not include API usage — it is billed separately, which surprises people.
2. **Put credit on the account before you create the key. Open Billing and use Buy credits; credit is available immediately. $10 is a sensible start — roughly 5 to 20 breakdowns depending on script length, fewer in Deterministic Mode. This ordering matters: a key with no credit behind it will pass Test connection and then fail on your first real run, which looks like a broken app rather than an empty balance. There is also an auto-reload** option that tops up automatically when the balance drops below a limit you set — useful later, unnecessary for a trial.
3. Then create the key at API Keys → Create Key. It starts with sk-ant- and is shown once and never again, so copy it immediately. If you lose it nothing breaks — delete it and make another.

Then paste it into PXLbid as described above.

If any of that does not match what you see on screen, trust Anthropic's documentation over mine — they change their console, and these links follow it.

What it costs to run

A typical breakdown runs roughly $0.20 to $2, depending on how long the script is. Both passes default to Opus, the most capable model; dropping Pass 1 to Sonnet in Settings costs noticeably less and is a sensible choice while you are still calibrating Rates & effort. Deterministic Mode runs the pass three times and compares the results, so it costs about three times as much.

Before you spend anything, the script picker shows you an estimate of the size of the job, and no tokens are spent until you actually start a pass.

What happens to your key

Your key is stored in your browser, and it travels with each run: to reach Anthropic, the request goes through the PXLbid service, which forwards it under your key. It is never stored, never logged, and never written to disk — it exists on our side only for the seconds a run takes. The full explanation, including what happens to your script, is in Where your script goes (NDA).

Your first ten minutes — calibrate first

Every bid built on the shipped placeholder numbers is structurally right but financially fictional. Spend ten minutes now and your bids are credible.

Step 1: Set your day rate (2 minutes)

1. Click Rates & effort (top bar).
2. Rates & effort opens on 1. This project — pick your project type first, because it decides which departments exist.
3. Go to 2. Your studio > Rates & markups.
4. Enter your day rate — one blended $/man-day. This is the only number that directly affects bid cost.
• Use a realistic blended rate for your studio — don't guess. The shipped

600 is a placeholder, not a recommendation.

5. (Optional) tune overhead, contingency, and margin percentages. These are applied in the waterfall: subtotal → +overhead → +contingency → +margin → price. Shipped defaults: overhead 20%, contingency 10%, margin 25%, best/worst range ±10%, currency USD, default team size 1, feedback buffer off (15% when switched on). They compound, so they are not additive.
6. Leave hours per day as-is unless you bid on a different number (default: 7 productive hours).

Step 2: Tell it how long your work takes (5 minutes)

The single most important panel. Open Rates & effort > 2. Your studio > Effort.

At the top is "Start here: how long does your work take?" — five questions, answered in hours:

Each figure is the total mid-artist hours for one complete build, added up across every discipline it passes through — modelling plus texturing plus rigging and so on. It is not per discipline, and not per day.

The numbers already in the boxes are our suggested starting figures, not yours. Change the ones you disagree with, press Enter, then click Save. Answering these five questions sets all 68 underlying baselines for you, in proportion.

If you want to override a single discipline — just rigging, say — scroll down to the per-family rows underneath and edit that row directly.

Do this once per studio. It carries across every project you bid.

Step 3: (Optional) review complexity and seniority

1. Complexity tab — the 5 tier multipliers (trivial 0.4 … med 1.0 … epic 2.5). These are reasonable defaults; leave them unless your grades differ sharply.
2. Seniority tab — junior 1.5 / mid 1.0 / senior 0.7. Same — reasonable defaults, but flag any discipline where a senior saves more or junior is slower.

Once both your rates and your effort baselines differ from the shipped values, the gold "not calibrated yet" banner on the Bid and Schedule screens disappears. It reappears if you ever reset a resource back to the defaults — that is deliberate, because reset numbers are placeholders again.

Running a breakdown — step by step

Pass 1: VFX Supervisor

1. Click New script (or just drag a file onto the screen).
2. Upload a script: PDF, DOCX, or TXT (.doc, old binary Word, is not supported on the published site — it needs a local backend, so it only appears if you run PXLbid from source).
• Plain text, screenplay format, or PDF — the AI adapts.
• On a long script, work sequence by sequence rather than feeding it the whole thing. There is no hard page limit, but a full feature in one pass runs longer, costs more, and gives the AI less attention per scene — so the breakdown gets shallower exactly where you wanted it deepest. Around 20 pages at a time is a comfortable working size.
• Bidding a sequence at a time also matches how you actually work: you can start with the sequence that worries you most, get that number right, and move on — rather than waiting for a whole-feature pass to finish before you learn anything.
• Coming: picking a page or sequence range in the app, running passes on the ranges you choose, and merging them into one bid automatically. The merge is the fiddly part — the same hero character gets found in every range it appears in, and a naive join would bid that build several times over. That work is in progress; for now, split the script yourself and keep the bids separate, or re-run a combined pass once the ranges are settled.
3. (Optional) add notes for the VFX Supervisor — e.g., "Focus on creature decomposition. The hero's mech has 4 LODs." The AI learns these hints.
4. Check the Deterministic mode checkbox if you want 3-run consensus for production breakdowns (roughly 3× API cost, but much lower variance). Leave it unchecked for quick first passes.
5. Click Run Pass 1 - VFX Supervisor. Watch the agent stream as it reads the script and extracts sequences, shots, and assets with complexity grades.

What you get: a first-draft breakdown with one shot per scene, all assets, and a tier grade on each.

Review & edit

1. The breakdown appears in the Review phase. Read through it. You'll see tabs for Sequences, Shots, Assets, Warnings, and Clarifications.
2. Edit anything: click any shot/asset row to open a detail drawer. Change the name, sequence, complexity tier, seniority, or mark it "skip" (×) to drop it.
3. When you're happy, click Approve & continue (bottom of the screen).
• You're offered a save button (download JSON) before moving on — use it to back up your work.

Pass 2: Granular breakdown (optional)

After Checkpoint 1, you can optionally run Pass 2 to subdivide shots and tag asset departments more precisely. This step needs the original script re-attached (the breakdown JSON never embeds script text for NDA safety).

1. If the script is already attached, click Pass 2 at the bottom. A panel opens asking for scope — Whole script, One sequence, One shot, One asset, or All of one asset type — and intensity: Light, Medium or Deep. Narrow the scope when you only want to refine part of a breakdown; it is faster and cheaper than re-running everything.
2. If the script is not attached, upload it again first.
3. Run Pass 2. The agent refines the breakdown — typically splitting wide shots into multiple workable shots, adding department tags, and re-grading based on new detail.
4. Review the Pass 2 changes summary and the updated breakdown. Re-grade anything that looks off.
5. Click Bid or Schedule to move on.

Skip Pass 2 if: you're happy with the Pass 1 breakdown (one shot per scene is often enough for a bid), or you're in a hurry. You can always run it later if you reload the breakdown.

Bid

1. Click Bid (or skip straight there from Checkpoint 1).
2. You see:
• Totals card: total cost, man-days, contingency range (best–worst %), calendar days.
• Schedule by discipline: costs and calendar days per department (assuming the team sizes you set in Rates & effort → Rates & markups).
• Line items: every shot/asset × discipline with the full calculation: base hours → × complexity → × seniority → hours → days → rate → cost.
3. Re-grade any line: click a row's complexity tier or seniority badge and change it. The entire bid recomputes live. This is how you adjust the bid after review.
4. Drop a line: click the × to remove it entirely (e.g., "this shot fell out of scope").
5. Export: click the export button (top right) to download a CSV or a client quote deck.

Schedule

1. Click Schedule (from Checkpoint 1 or Checkpoint 2).
2. You see a Gantt chart showing calendar timeline by discipline.
• Dependencies (who hands off to whom) drive the order.
• Team sizes (set in Rates & effort → Rates & markups) compress calendar time (2 artists on one lane halves the duration).
• Any change to complexity or seniority in the breakdown updates the schedule live.
3. Export the schedule as needed.

The screens, one by one

Idle (start)

The blank slate. Drag a script onto the screen, or use buttons to open recent, load a JSON, or compare versions.

Ingested

Script uploaded. You see the file format, character count, and page count (PDF only). Optional: write notes for the VFX Supervisor. Toggle Deterministic mode if you want consensus (3-run, slower, ~3× cost). Then run Pass 1.

Pass 1 running

The agent streams — watch logs as it extracts sequences, shots, and assets. If it fails, the error is shown; click Retry to run again.

Checkpoint 1 (after Pass 1)

The VFX Supervisor breakdown is ready. You see tabs: Sequences, Shots, Assets, Warnings, Clarifications. Click any row to edit in a drawer. When happy, click Approve & continue to offer a backup download, then move on.

From here you can:

• Run Pass 2 (if the script is attached) for granular subdivision.
• Jump straight to Bid (skip Pass 2).

Pass 2 launcher (if you choose Pass 2)

Dialog box asking scope ("how deep should I split shots?") and intensity ("how much subdivision?"). Attach the script if needed.

Checkpoint 2 (after Pass 2)

Similar to Checkpoint 1, but the breakdown is more granular. You see a Pass 2 changes summary card at the top. Same edit workflow.

The other tabs hold the rest of the bid. Assets is every build the script needs, each with its own departments — this is where a character build or a full CG environment gets priced:

Warnings is the tab worth reading before you send anything. It is where PXLbid tells you what it was unsure about, and where a number may not mean what it looks like — a large crowd priced as one simulation, a sequence that probably wants its own FX setup line:

From here:

• Run Pass 2 again (refine further).
• Go to Bid or Schedule.

Bid

Cost breakdown and line-item detail. Re-grade lines by clicking complexity or seniority badges. Export via top-right menu.

Schedule

Gantt chart of calendar timeline. Dependencies and team sizes drive the layout.

Rates & effort

Your studio constants. Three zones (progressive disclosure):

Every section and every parameter in Rates & effort is explained in place. Hover the small info dot next to any heading, row or field and a panel opens with what that lever actually does, a worked example using your own current values, and a warning where one applies. If you are unsure what a number means, hover it before you change it — the explanations are generated from the same engines that do the maths, not written separately.

1. This project — change per show. This zone comes first because project type decides which departments exist at all:
• Project Type — kind of show (full CG drops plate prep, commercial is lighter, etc.). Filters which departments appear in the bid.
• Dependencies — production order (who hands off to whom). Used by the schedule.

1. Your studio — set these once:
• Rates & markups — day rate, overhead %, contingency %, margin %.
• Effort — one mid-artist baseline per discipline. Use Quick Tune (5 hour figures) or the per-row editor (68 rows).
• Complexity — the 5 tier multipliers. Global + per-discipline overrides.
• Seniority — junior/mid/senior multipliers. Global + per-discipline overrides.
• AI house rules — your own instructions appended to the agent prompts (see "Teaching the AI your house rules" below).

1. Data & tools:
• Download template — blank config workbook to fill in offline.
• Export current config — your live config as an editable XLSX (round-trip via Google Sheets). To export only one section, use the Export this section button on that section instead.
• Import workbook — load an edited XLSX (each tab overwrites that resource).
• Reset all to defaults — restore the shipped baselines (use if your config got corrupted).
• Prompt Lab (admin only) — edit the agent prompts and model assignments.

Quick Tune (recommended for first-time setup):

• Five cards, one per family (Characters, Environments, Props, FX, Shot work).
• Each has one multiplier (1.0 = shipped). Change it to adjust all baselines in that family at once.
• Press Enter or click away to apply. Shows consequence ("a character build is now 430 hours").

Help

This in-app guide (mirrors the Complexity Tier Rubric, the bidding model, and the five tiers). Always available.

Recent

Breakdowns auto-saved in this browser. Click one to reload it. Replaces the old server/breakdowns folder.

Compare

Compare two breakdowns side by side (useful for sanity-checking Pass 2 changes or reverting edits).

Corrections log (House rules)

Shows edits you've made to breakdowns over time. The AI learns from these patterns — if you always re-grade a certain type of shot lower, the agent picks up the habit.

Settings

Same panel as Step 1 above: Rates & effort > 2. Your studio > Rates & markups.

• Account row — Google sign-in. Sign out here.
• Anthropic API key — paste your key, test connection, clear if needed.
• Models per stage — choose which Claude model to use for Pass 1 and Pass 2. Both passes default to Opus. If you want a cheaper, faster first pass, switch Pass 1 to Sonnet here — Pass 1 quality is usually fine on Sonnet, and it is the pass you re-run most while calibrating. Can override per stage.
• Max output tokens — raise this if you see TRUNCATED warnings (very long scripts). Default is fine for most cases.

Making it yours — Rates & effort in depth

Effort matrix (Quick Tune vs. detailed)

The Quick Tune panel is the entry point. Five multipliers, one per family, applied against the shipped baselines.

If you want more control, scroll down to the per-row editor:

• 53 asset baselines (characters, creatures, environments, props, FX, etc.) + 15 shot baselines (one per discipline).
• Edit base_hours directly for a single row. That value is for a mid artist on an average shot/asset.
• default_seniority — who usually does this (defaults to mid). Can be overridden per line in the bid.

Pro tip: use Quick Tune to set the family multiplier, then the per-row editor to fine-tune a single discipline. Both work on top of the shipped defaults, so changes are idempotent.

Complexity multipliers

The 5 tiers and their multipliers:

• trivial (0.4) — near-free: hold, freeze-frame, direct reuse, cleanup. An intern could finish it.
• low (0.7) — straightforward, standard pipeline. A junior can deliver it.
• med (1.0) — the average shot — the anchor everything else scales from.
• high (1.6) — complex, hero-adjacent, tricky integration, heavy cleanup. Needs lead attention.
• epic (2.5) — set-piece, novel R&D, hero moment.

Global multipliers: set at the top. Applied to all disciplines.

Per-discipline overrides: add a row for a discipline (anim, comp, fx, etc.) and set overrides. Leave a cell blank to inherit the global.

Rubric: the plain-English definitions the AI grades by. Read and tune these if the AI is consistently mis-grading shots.

Seniority multipliers

• junior (1.5) — +50% time (still learning).
• mid (1.0) — the baseline.
• senior (0.7) — −30% time (faster).

Same structure: global + per-discipline overrides. If a rigging senior saves more than a comp senior, add a rigging row.

Settings

• day_rate — one blended $/man-day. This number alone determines bid cost. Leave blank for schedule-only, no dollars.
• currency — display currency for export.
• overhead_pct — percentage of subtotal to add for overhead (e.g., 0.2 for 20%).
• contingency_pct — percentage for contingency.
• margin_pct — markup on top.
• hours_per_day — productive hours per work day (default: 7, not 8).
• default_team_size — how many artists you put on a discipline by default. Per-discipline overrides below.

The bid calculates: subtotal → +overhead → +contingency → +margin → price. These add in sequence, and the bid shows a best–worst range (±%).

No rate-card matrix. There is one day rate. Per-artist rates with their own multipliers are handled in PXLflow, not here.

Project Type

Selects which disciplines appear in the bid and schedule. Different show types have different departments:

• Full CG — drops plate prep, match-move, roto (no plates).
• VFX heavy — includes FX, comp, lighting.
• Commercial — lighter crew.
• etc.

Leave as default if you're unsure. You can also just mark shots/assets as "skip" (×) in the bid to drop individual lines.

Dependencies

Production order: who hands off to whom. Affects the schedule Gantt chart (model → rig → layout → anim → lighting → comp, for example). Safe to leave as-is for a first pass.

Project folders

By default your work lives in this browser, and exports go to your Downloads folder. That works, but a breakdown dies with a cleared cache and cannot follow you to another machine.

Instead, give the show a folder. Click New project in the header, name it ("Thresholds", "Mickey Mouse"), and pick where it goes. PXLbid creates:

Thresholds/
  project.json      what this folder is
  breakdowns/       every completed pass, saved automatically
  bids/             for bid exports you save here
  schedules/        for schedule exports
  config/           this show's library workbook

From then on, every completed Pass 1 and Pass 2 is written into breakdowns/ as well as staying in the browser. The chip in the header shows the project name, and the path of the last file saved.

Choose the folder yourself — a NAS share, a Dropbox folder, the show's existing folder. Nothing is assumed about where it lives, so this works the same on Windows and macOS.

Things worth knowing

• Chrome or Edge only. Safari and Firefox do not support choosing a folder yet. On those, PXLbid behaves exactly as it did before and says so in the header — nothing is lost.
• You will be asked for permission once per session. Browsers drop write access when you close the tab. The header shows Reconnect — one click and it is back. Nothing on disk changes in the meantime.
• If the folder moves, the chip turns red and says "not found", and saving pauses rather than failing silently. Use locate to point at its new home, or forget to stop tracking it.
• Closing a project never deletes anything. It only stops PXLbid saving there.
• PXLbid will not overwrite a project.json it did not write, and will not create a second show inside an existing project's folder — it refuses and tells you.
• bids/, schedules/ and config/ are not yet written automatically. They are there for exports you save into them yourself.
• Privacy: the folder is local and PXLbid never syncs or uploads it. Producing a breakdown does send the script text to the Anthropic API from your browser — the folder holds the results.

Templates & Data

• Download template — empty XLSX with the same tabs as your live config. Fill it in offline and import it back.
• Export current config — download your live settings as XLSX. Edit in Google Sheets, download, import back.
• Import workbook — load an XLSX. Only the tabs the file actually contains are read; anything it does not mention is left exactly as it is.
• Reset all to defaults — one-click restore. Useful if your config got corrupted.

Export just one section

Every Rates & effort section has its own Export this section button, next to the section description:

• 1. This project → project_type + dependencies — this show's setup.
• 2. Your studio → settings, effort_baselines, complexity_multipliers, seniority_multipliers — your studio constants.

Use it to hand your studio numbers to someone without also handing over the current show, or to move one show's setup between machines. Both import back through the same Import workbook button.

The config workbook is editable in Google Sheets. Tabs:

• effort_baselines — kind, asset_type, discipline, base_hours, default_seniority.
• complexity_multipliers — global row + per-discipline overrides.
• seniority_multipliers — global + overrides.
• settings — every project-wide lever: day_rate, currency, the markups, hours_per_day, team sizes, plus the calendar, overtime, duration-scaling and render-cost blocks.
• project_type — the kind of show, plus any per-department on/off overrides.
• dependencies — production order (who hands off to whom).
• complexity_rubric — the 5-tier definitions (reference only; shown to the AI).

No other sheets. The workbook is config only — script, breakdown, and bid data never live in it.

Editing the settings tab by hand

Excel has no nested cells, so the nested settings use dotted keys, exactly as exported:

overtime.crunch_fraction        0.3
duration_scaling.weights.anim   1
render.render_min_per_frame.epic  45

Rules worth knowing before you type:

• Keep the spelling. A misspelled key is ignored and reported in the import warnings rather than silently applied.
• Percentages accept either form — 20 or 0.2 both mean 20%.
• On/off rows take TRUE / FALSE.
• holidays is a comma-separated list of YYYY-MM-DD dates. Format the cell as text first — otherwise Sheets converts a lone date into a number and the entry is rejected.
• work_week is seven comma-separated values, Mon→Sun, 1 = working day. Any other length is rejected.
• Deleting a row does not delete the value. Rows are applied on top of what you already have, so a sheet with one row changes one thing. To switch a duration-scaling discipline off, set its weight to 0 rather than removing the row.
• A tab you delete is simply not imported. That is what makes the per-section exports safe to import.

Teaching the AI your house rules

Rates & effort > 2. Your studio > AI house rules.

Tell the agent how your studio works and it applies that on every run — a department you do not have, work you never bid, naming conventions you use, or anything it keeps getting wrong for you. Plain English, one instruction per line. For example:

We never bid stereo conversion - exclude it.
Treat any vehicle appearing in more than three shots as a hero build.
We have no dedicated matte painting department - fold it into comp.

There are three boxes, one per stage: the first breakdown, the granular pass, and the bid review. Put each rule where it applies.

These are added on top of the built-in instructions, which stay in place. They refine scope, naming and conventions; they cannot change the output format. If one of your rules conflicts with the built-in behaviour, the agent follows the built-in rule and raises a warning so you can see it happened.

Your house rules are stored in your browser and are yours alone.

Where the numbers come from (and where they don't)

Every effort baseline in Rates & effort carries a provenance tag, because the honest answer differs wildly cell by cell:

• sourced — a named senior practitioner or primary data. Exactly one cell qualifies: animation, from Scott Squires (VES Fellow, ex-ILM), at 8–12.8 hours per second of screen time.
• derived — arithmetic from such a figure. Six cells.
• practitioner — Cris's own call as a working VFX/CG Supervisor, where no published figure exists.
• unsourced — a considered estimate with no public data behind it. This is most of the file.

That last number deserves saying plainly: no per-discipline artist-hour data for VFX asset builds exists publicly, at any tier. Not one cell. 52 of the 53 asset baselines and 9 of the 15 shot baselines are estimates, sitting on an explicit internal ratio spine.

So treat the absolute hours as a starting point, not a finding. What is defensible is the proportions — a creature costs more than a character, a rig costs more than a texture pass — and that is what Quick Tune scales when you answer one question. Replace the absolutes with your studio's actuals and they stop being estimates.

Where the sourced figure lands matters too. Squires' 8 h/sec describes a hero shot, so it sits at high complexity, not at the average. A med 5-second single-character animation shot is 25h (5 h/sec); the same shot graded high is 40h (8 h/sec) and epic is 62h (12.4 h/sec). Installing his number at the average would have double-counted it the moment the complexity tier was applied.

The full audit trail, including a list of rejected sources, is in src/config/effort-research.json.

How shot length changes the price

Every department scales with duration_sec, on its own curve — so estimating shot length carelessly propagates straight into the number.

• Frame-by-frame, essentially linear: animation, rotoscoping, rotoanim. 50 frames really is five times 10 frames.
• Steeply: FX, cloth/hair sim, crowd — caches break and interactions multiply over a longer run.
• Meaningfully: compositing (a 2000-frame shot is a different job from a 20-frame one: render time, and it often has to be split into sub-shots), enhancement.
• It depends: lighting. A car chase relights constantly through the shot; a locked interior does not.

Two departments depend on the camera, not the clock. If a shot is marked camera: static — a locked-off plate — matchmove becomes a single-frame line-up (SFLU): one solve, however long the shot runs. A ten-minute locked-off shot costs the same matchmove as a two-second one. DMP behaves the same way: one projection for a static camera, several (first/mid/last frame) across a long move.

If the AI can't tell whether the camera moves, it leaves the field off and the bid assumes animated — the more expensive, safer assumption. Guessing "static" is the one that makes a bid too cheap.

A crowd is two costs, not one. The crowd system — setup, simulation, caching, integration — is priced per shot and is flat in agent count, because 5 agents and 500 agents are one Houdini setup. The crowd's own asset builds are separate: the base body variants, plus the wardrobe, armour, weapons and props layered on them. Those are frequently forgotten and are often the larger number, so Pass 1 asks about them and the producer review flags a crowd shot with no crowd assets.

Where your script goes (NDA)

This is the question every producer should ask before putting a client's pages into a tool they did not write, so here is the whole answer.

Opened on this machine. The file you drop is opened and parsed in your browser — TXT directly, PDF via pdf.js, DOCX via mammoth. Loading a script uploads nothing: you can drop a script in, read it, and close the tab without a single byte leaving your machine.

Never stored. Script text is not written to browser storage, not embedded in the breakdown JSON, and not written to your project folder. That is why Pass 2 asks you to re-attach the script after a reload — it is deliberate, not a bug.

Producing a breakdown sends the text to us, then to Anthropic. This is the part no tool of this kind can avoid, so it should be stated plainly rather than glossed. To read your script, the pass sends its text to a PXLbid service we run, which adds the instructions that tell the model how to break a script down and forwards the request to api.anthropic.com using your API key on your Anthropic account. Your key travels in the same request. So two parties handle the material: us, in transit, and Anthropic.

We keep no copy of either. The service holds your script and your key in memory only for the seconds a pass takes. Neither is written to a database, saved to disk, or recorded in our logs — we log sizes, token counts and timings so we can tell whether a run succeeded, and never the content. Nobody at PXLbid can go back and read a script you ran, because there is nothing to read. Anthropic's terms govern the model side; PXLbid adds no retention of its own.

Why it works this way (changed in v0.59.0). Earlier versions sent your script from the browser straight to Anthropic, and this page said so. The instructions that make PXLbid work were shipped inside the app, where anyone could read them — and because a tester who left kept a copy, access could not really be withdrawn. Moving those instructions onto a server we control fixed that, and the cost is the extra hop described above. It would have been easy to leave the old wording in place; it is no longer true, so it is gone.

If your NDA forbids sending pages to any third-party AI service, or to any intermediary, do not run a pass on that script. The breakdown cannot be produced without that step, and no setting in this app changes it. You can still use Rates & effort, the bid and the schedule on a breakdown produced elsewhere.

The same note appears in the app itself, on the screen where you load a script.

Known limits and gotchas

1. Project folders need Chrome or Edge. Saving breakdowns to a folder on your disk uses a browser API that Firefox and Safari do not implement. On those the header says "no project folder" and everything else works as normal — nothing is lost, and nothing fails silently. This is a browser limitation, not something PXLbid can work around.

1. .doc (old Word binary) is not supported — use PDF, DOCX, or TXT. The static build does not extract from old .doc format.

1. Script text is never saved — Pass 2 needs the script re-attached after a page reload. This is intentional (NDA-safe). The breakdown JSON is saved, but not the script.

1. Browser storage only — everything lives in this browser on this machine. No sync, no server. Clearing your browser's site data deletes all saved breakdowns and your library config.
• Use Recent and Export (download JSON) to back up work.
• Use Export current config (in Rates & effort → Templates & Data) to back up your rates & effort and round-trip it via Google Sheets.

1. 20-breakdown history cap — only the 20 most recent breakdowns are kept. Older ones are pruned automatically.

1. Your library is entirely yours — never shared with anyone. Cris and other users have their own libraries.

1. Unsaved Rates & effort edits — each Rates & effort tab saves independently. If you

change something and switch tab, zone, or press Back, you are asked whether to discard it. Press Save first to keep it.

1. No server-side diagnostics — the service that relays a pass logs only

sizes, token counts and timings, never your script, your key or the output. So when something fails there is no record of what you were working on for us to inspect. If a run fails, use the Feedback dialog and include what you were doing; do not assume we can see the problem.

• During the current beta the Send button may be disabled. That means

the collection endpoint is not switched on yet — it is not a bug in your browser. Use Copy instead and email the copied report to Cris. The dialog says which mode it is in.

Sending feedback

Click Feedback (top bar). A dialog opens asking for a message.

What gets sent: your message, the project title (if any), the app state (which screen you're on, recent clicks), and the app version.

What never gets sent: the script, the breakdown, your bid, your API key, your library config, or any sensitive data.

Use this to report bugs ("Pass 2 crashed"), confusing UX ("the Export button is hard to find"), or ideas ("add a lock/unlock toggle").

Workflow tips

• Calibrate once, bid many times. Set your rates and effort baselines in Rates & effort once, and every new project uses them.
• Use Quick Tune for fast setup. Five multipliers get you 90% of the way. Fine-tune disciplines later if needed.
• Deterministic Mode for production. Three-run consensus is slower and costs ~3× as much, but variance drops sharply. Use it for client quotes.
• Re-grade in the Bid. That's where producers live — complexity and seniority are the levers you use.
• Save JSON backups. After Checkpoint 1, download a JSON. Reload it with "Load JSON from disk" if something goes wrong.
• Export config regularly. Use Rates & effort → Templates & Data → Export current config to back up your tuning, round-trip it through Google Sheets if you want to collaborate.
• Compare versions. From the start screen, Compare versions... puts two breakdowns side by side — useful for checking Pass 2 changes or undoing edits. It lives on the start screen, not in the top bar.

Troubleshooting

"Test connection" fails. Check the key was pasted whole — it starts with sk-ant- and is long. If it was, the key itself has been rejected: it may have been deleted from your Anthropic account, or copied from a different organisation. Make a new one at platform.claude.com/settings/keys.

"Test connection" passes but a real run fails. Almost always an empty balance. The test is a one-token request and can succeed on a near-zero account while a full pass cannot. Open Billing and buy credits — and remember API credit is separate from a Claude Pro/Max subscription. PXLbid names this case explicitly when it happens and links you straight there.

A run fails, or the breakdown comes back empty. Try a shorter script first to confirm the key and connection work at all. If a specific script reproduces it, tell us via Feedback and say which model was selected in Settings — the model matters and it is the first thing we will check.

The bid totals look wrong. Check the gold "not calibrated" banner. If it is showing, the numbers are our placeholders, not yours — see Your first ten minutes. If it is not showing, the figures are coming from your own Rates & effort values, and the fastest way to find the culprit is Rates & effort > Rates & markups (day rate and markups) before Effort.

Everything disappeared. Your work lives in this browser profile on this machine. A different browser, a different machine, or cleared site data all start empty. Check Recent first; if it is empty, the data is not recoverable from our side — we have no copy of it.

The app went blank or showed an error card. Press Reload PXLbid on the card; your breakdown and library are saved and will come back. Use Copy error report first and send it to us — that report is the only record of what happened.

Questions this guide does not answer: send them through the Feedback button — gaps in this document are useful feedback too.