⚡ Flash by Teralor

Flash was used to build Flash

Flash is an ultra-fast MoE built specifically for rapid task completion.
Up to 1200 tok/s.

Join the waitlist

View pricing

Flash task preview

Local preview — nothing leaves your browser.Recorded task

Fix checkout

Implement sixteen independent checkout modules against frozen contracts, then run one combined check.

src/cart.mjsCartQueued

1// Starter (deliberately WRONG — must fail the frozen acceptance tests).

2// Task: merge duplicate SKUs (first-seen order, summed qty, first unitCents wins),

3// drop entries with invalid qty (non-integer or <= 0) or invalid unitCents

4// (non-integer or < 0), compute lineTotalCents = qty * unitCents per line,

5// subtotalCents = sum of line totals, itemCount = sum of quantities.

6// Never mutate the input array or its entries. Return null for non-array input.

7export function normalizeCart(lines) {

8 return { lines: [], subtotalCents: 0, itemCount: null };

src/discount.mjsDiscountQueued

1// Starter (deliberately WRONG — must fail the frozen acceptance tests).

2// Task: return the discount in whole cents for a subtotal.

3// percent: floor(subtotal * value / 100), value clamped to 0..100;

4// fixed: min(value, subtotal). Result capped at subtotal, never negative.

5// Any invalid subtotal or discount (wrong type/value, NaN, negative) yields 0.

6// Zero subtotal always yields 0.

7export function discountCents(subtotalCents, discount) {

8 return subtotalCents;

src/shipping.mjsShippingQueued

1// Starter (deliberately WRONG — must fail the frozen acceptance tests).

2// Task: return shipping cost in cents. Free (0) when a valid integer subtotalCents

3// >= thresholdCents (integer >= 0); otherwise the baseShippingCents when it is a

4// non-negative integer, else the default 500. Invalid/missing subtotal is treated as 0

5// (so it pays the base cost). Non-object input behaves like {}.

6export function computeShipping({ subtotalCents, thresholdCents, baseShippingCents } = {}) {

7 return 0;

src/tax.mjsTaxQueued

1// Starter (deliberately WRONG — must fail the frozen acceptance tests).

2// Task: tax in whole cents = round-half-up(amountCents * basisPoints / 10000).

3// basisPoints must be an integer 1..10000 (generic fixture rate, NOT a legal tax rate);

4// 0, out-of-range, non-integer, or missing options yield 0.

5// Invalid or negative amountCents yields 0. Zero amount with a valid rate yields 0.

6export function computeTax(amountCents, options) {

7 return amountCents;

src/stock.mjsStockQueued

1// Starter (deliberately WRONG — must fail the frozen acceptance tests).

2// Task: stock sufficiency check. Valid input: non-empty string sku, qty and availableQty

3// non-negative integers. Return { ok, sku, requestedQty, availableQty, missingQty }

4// where ok = availableQty >= qty and missingQty = max(0, qty - availableQty).

5// Return null for any invalid input (null object, blank sku, non-integer/negative numbers,

6// missing availableQty). Never mutate the input.

7export function checkStock({ sku, qty, availableQty } = {}) {

8 return { ok: false, sku: sku ?? null, requestedQty: qty ?? 0, availableQty: availableQty ?? 0, missingQty: 0 };

src/address.mjsAddressQueued

1// Starter (deliberately WRONG — must fail the frozen acceptance tests).

2// Task: trim, collapse internal whitespace runs to single spaces, and uppercase

3// postalCode/countryCode. Required: name, line1, city non-empty after normalize;

4// postalCode matches /^[A-Z0-9][A-Z0-9 -]{1,10}[A-Z0-9]$/ (3-12 chars);

5// countryCode exactly 2 letters. region optional (default '').

6// Return { ok, errors, normalized } — errors lists failing field names (stable order:

7// name, line1, city, postalCode, countryCode) with normalized null when ok is false.

8// Non-object input fails with all required errors.

9export function validateAddress(address) {

10 return { ok: false, errors: ['name'], normalized: null };

11}

src/currency.mjsCurrencyQueued

1// Starter (deliberately WRONG — must fail the frozen acceptance tests).

2// Task: normalize a currency code. Trim, then require /^[A-Za-z]{3}$/; uppercase the

3// result. If the supported list (2nd arg) is a non-empty array of strings, an uppercase

4// code not in it fails { ok:false, code:null, error:'unsupported' }. An invalid supported

5// list (non-array or empty) falls back to accepting only 'USD'. Malformed or non-string

6// input fails { ok:false, code:null, error:'format' }.

7export function normalizeCurrency(input, supported) {

8 return { ok: false, code: null, error: 'format' };

src/delivery.mjsDeliveryQueued

1// Starter (deliberately WRONG — must fail the frozen acceptance tests).

2// Task: select a delivery method. Find a method whose id === method (non-empty string)

3// in the methods array; then require a valid integer subtotalCents >= method.minSubtotalCents.

4// Return { ok:true, method: <shallow copy>, error:null } on success (copy so callers cannot

5// mutate the source array), { ok:false, method:null, error:'unknown-method' } when the id or

6// list is invalid/unmatched, and error 'below-minimum' when the subtotal (invalid counts as

7// failing) is below the minimum. Never throw.

8export function selectDelivery({ method, methods, subtotalCents } = {}) {

9 return { ok: true, method: null, error: null };

10}

src/gift-card.mjsGift CardQueued

1// Starter (deliberately WRONG — must fail the frozen acceptance tests).

2// Task: apply a gift card to a due amount. Treat invalid/negative balanceCents or

3// dueBeforeCardCents as 0. appliedCents = min(balance, due);

4// remainingDueCents = due - applied; cardRemainingCents = balance - applied.

5// Zero due or zero balance are valid no-ops (never errors). Return all three fields.

6export function applyGiftCard({ balanceCents, dueBeforeCardCents } = {}) {

7 return { appliedCents: 0, remainingDueCents: 0, cardRemainingCents: balanceCents };

src/loyalty.mjsLoyaltyQueued

1// Starter (deliberately WRONG — must fail the frozen acceptance tests).

2// Task: redeem whole loyalty points worth centsPerPoint cents each.

3// Invalid numbers (NaN, negative balance/rate, non-integer) -> { ok:false, pointsUsed:0,

4// appliedCents:0, pointsRemaining:0, remainingDueCents: due floored at 0 or 0 if invalid,

5// error:'invalid' }. centsPerPoint must be a positive integer (zero/negative/float/non-number

6// is invalid). requestedPoints > pointsBalance -> ALWAYS error:'insufficient-points' with no

7// partial grab; requested === balance is a valid boundary full redemption. Otherwise

8// pointsUsed = min(requested, balance, floor(due / centsPerPoint));

9// appliedCents = pointsUsed * centsPerPoint; report pointsRemaining and remainingDueCents.

10// Zero request or zero due are valid no-ops (error:null).

11export function redeemLoyalty({ pointsBalance, requestedPoints, dueBeforeLoyaltyCents, centsPerPoint } = {}) {

12 return { ok: false, pointsUsed: 0, appliedCents: 0, pointsRemaining: 0, remainingDueCents: 0, error: 'invalid' };

13}

src/gift-wrap.mjsGift WrapQueued

1// Starter (deliberately WRONG — must fail the frozen acceptance tests).

2// Task: gift-wrap cost. eligible:false or wrapQty:0 (with otherwise valid input) ->

3// { ok:true, chargedQty:0, costCents:0, error:null }. Invalid input (non-object, negative or

4// non-integer wrapQty/availableQty, negative or non-integer unitWrapCents) ->

5// { ok:false, chargedQty:0, costCents:0, error:'invalid' }. Otherwise

6// chargedQty = min(wrapQty, availableQty); costCents = chargedQty * unitWrapCents.

7export function giftWrapCents({ wrapQty, availableQty, unitWrapCents, eligible } = {}) {

8 return { ok: false, chargedQty: 0, costCents: 0, error: 'invalid' };

src/surcharge.mjsSurchargeQueued

1// Starter (deliberately WRONG — must fail the frozen acceptance tests).

2// Task: surcharge in whole cents = round-half-up(amountCents * basisPoints / 10000).

3// basisPoints must be an integer 0..10000 (generic fixture rate); out-of-range,

4// non-integer, or non-number basisPoints yield 0. Invalid or negative amountCents yields 0.

5// Zero amount or zero rate yields 0.

6export function surchargeCents(amountCents, basisPoints) {

7 return amountCents === 0 ? 0 : -1;

src/line-totals.mjsLine TotalsQueued

1// Starter (deliberately WRONG — must fail the frozen acceptance tests).

2// Task: recompute per-line totals. Keep lines whose sku is a non-empty string, qty is a

3// positive integer, and unitCents is a non-negative integer; for each kept line emit

4// { sku, qty, unitCents, lineTotalCents: qty * unitCents } and subtotalCents = sum.

5// Drop nulls/non-objects/invalid numbers. Non-array input behaves like [].

6// Never mutate the input array or its entries.

7export function computeLineTotals(lines) {

8 return { lines: [], subtotalCents: -1 };

src/coupon.mjsCouponQueued

1// Starter (deliberately WRONG — must fail the frozen acceptance tests).

2// Task: coupon eligibility. Trim + uppercase the code and look it up in catalog

3// (a plain object). Missing/blank code, bad catalog, or unknown id ->

4// { ok:false, error:'unknown-code' }. A valid integer subtotalCents below

5// max(minSubtotalCents arg, rule.minSubtotalCents) -> error:'min-subtotal' (invalid

6// subtotal also fails this check). If the rule has a requiredCategory, categoryCounts

7// (object, missing counts count as 0) must have >= minCategoryQty for it, else

8// error:'category'. Success -> { ok:true, error:null }. Never throw.

9export function validateCoupon({ code, subtotalCents, categoryCounts, catalog, minSubtotalCents } = {}) {

10 return { ok: false, error: 'min-subtotal' };

11}

src/contact.mjsContactQueued

1// Starter (deliberately WRONG — must fail the frozen acceptance tests).

2// Task: normalize { email, phone }. Email: trim; must match

3// /^[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(\.[A-Za-z0-9-]+)+$/ (no spaces); lowercase the whole

4// trimmed address; on failure push 'email' into errors and set email null.

5// Phone: trim; empty/null/undefined -> '' (always valid); otherwise keep only digits,

6// '+', '-' and ' ' — the result must start with a digit or '+' followed by a digit, and

7// no letters may have been stripped, else push 'phone'. Non-object input -> both-invalid

8// shape. Return { ok, email, phone, errors } where ok = errors.length === 0.

9export function normalizeContact({ email, phone } = {}) {

10 return { ok: false, email: null, phone: '', errors: ['phone'] };

11}

src/order-summary.mjsOrder SummaryQueued

1// Starter (deliberately WRONG — must fail the frozen acceptance tests).

2// Task: pure combiner over a PREPARED components object (no sibling imports, no I/O).

3// components: { currency, subtotalCents, discountCents, loyaltyAppliedCents,

4// giftCardAppliedCents, giftCardBalanceCents, shippingCents, taxCents, wrapCents,

5// surchargeCents }. currency must be /^[A-Z]{3}$/ or return null (null input -> null).

6// Every money field missing/non-integer/negative is coerced to 0.

7// totalCents = max(0, subtotal - discount - loyalty + shipping + tax + wrap + surcharge)

8// (floored at zero BEFORE gift-card math; developer fixture view, not real settlement);

9// giftCardAppliedCents = min(cardApplied, totalCents);

10// amountDueCents = max(0, totalCents - cardApplied);

11// giftCardRemainingCents = max(0, giftCardBalanceCents - giftCardAppliedCents), where

12// giftCardBalanceCents is the ORIGINAL pre-application card balance (applied subtracted once).

13// Return a NEW object with all fields; never mutate the components input.

14export function buildOrderSummary(components) {

15 return { ...components, totalCents: 0, amountDueCents: 0, giftCardRemainingCents: 0 };

16}

ReadyFinal check pending0 changed +0 -0Recorded example · Flash ×16 · 1×

Works everywhere

One product. Every way you work.

Bring Flash to your harness, IDE, or API workflow and move from prompt to finished task faster.

Flash

Claude

Codex

Flash

Hermes

Agent harnesses

Run Flash in Claude, Codex, Pi, Hermes, and compatible harnesses.

Your IDE

Use Flash inside the coding environment you already work in.

Direct API

Call Flash through the OpenAI-compatible API for full control.

Flash

Your AI leads. Flash executes.

Keep planning, decisions, and final review with your preferred assistant. Delegate bounded tasks to Flash, running independent work in parallel when your harness supports it.

The executor and orchestrator setup guides configure your role and install this Flash skill; already-configured users can use it as a standalone skill from here. The coordinator can be Flash or another assistant.

Download skill

View skill instructions

---
name: flash-executor
description: Use when executing tasks with Teralor Flash, including independently verifiable coding, research, document and batch outcomes. Preserve the coordinator and use bounded, dependency-ready parallel work.
compatibility: Requires configured, authorized Flash access and supported harness tools. Concurrency requires verified account headroom and an actual concurrent dispatch mechanism.
metadata:
  author: Teralor
  version: "2.0.0"
---

# Flash

Keep the current coordinator model, whether Flash or another model. The coordinator owns decisions, contracts, scheduling and acceptance; Flash executes settled outcomes. Optimize verified completion, not worker count.

## Check readiness

Use the installed harness binding and verify nonsecret route/model evidence; a worker called Flash is not routing proof. If access, budgets or binding are missing, stop and use the harness-specific [Executor onboarding](https://teralor.com/executor) or [Orchestrator onboarding](https://teralor.com/orchestrator). This skill does not configure providers or switch the primary model. Keep credentials out of prompts and artifacts. Raw completions cannot execute tools; treat their proposed patches as unexecuted until the trusted harness validates and applies them.

## Decompose by verifiable outcome

Inspect the inputs and acceptance criteria. Settle shared interfaces first, then split only where each result can be checked independently: a module against a fixed interface, a document batch with distinct outputs, or a research question with its own sources. Keep dependent work queued. For a trivial or serial task, use one bounded execution; never manufacture sixteen tasks.

Maintain a compact ledger: task ID, dependencies, owner, artifact and state (`ready`, `running`, `produced`, `verified`, `failed`, `uncertain`, `blocked`). Only verified artifacts satisfy dependencies.

Give each worker this compact contract, not the full conversation:

- **Outcome:** task ID, observable result and expected artifact/count.
- **Inputs:** baseline, relevant paths/excerpts, settled interfaces and verified dependencies.
- **Ownership:** writable paths, isolated workspace, invariants, non-goals and permissions.
- **Acceptance:** runnable checks, return format, budgets and stop conditions.
- **Return:** actual artifacts/patch, changed paths, checks really run, failures and uncertainty.

For code, require a failing regression/reproducer before the fix where applicable and focused passing checks afterward. Workers must not recursively delegate, change global configuration, publish or broaden permissions.

## Run a replenishing queue

When the account allowance is verified as **16 concurrent requests**, dispatch up to that allowance—not sixteen workers unconditionally. Bound active requests by remaining account headroom, harness/tool limits, resource budget and independently ready work. Count other clients and the coordinator's own Flash requests. A worker can emit multiple requests; request capacity is not a worker entitlement. Unknown allowance: use at most one authorized request while resolving it; zero headroom: queue. Server admission remains authoritative.

Launch independent ready jobs together through supported asynchronous/batch tools, rather than awaiting each before starting the next. Consume completions, verify artifacts and replenish newly ready work without waiting for unrelated slow jobs. Use completion notifications or bounded waits; avoid duplicate submissions.

Concurrent writers require separate workspaces and explicit file ownership. Serialize shared interfaces, databases, ports and remote mutations. Without isolation, parallelize read-only proposals and keep one writer. Without concurrent tools, execute serially and say so.

## Verify, repair, integrate

Inspect actual bytes, scope, baseline compatibility and evidence; reconcile requested IDs against outputs for missing/duplicate items. Run combined integration checks after accepting individual artifacts. Never substitute worker confidence for results.

Repair only the failed slice, once, with concrete failure evidence; retain unaffected verified work. Authentication failure stops dispatch. Rate limits reduce pressure with bounded, safe retries. Interrupted or unknown dispatch stays uncertain until reconciled or confirmed cancelled—never assume its slot/workspace is free or replay blindly.

Report delivered artifacts, actual routing and observed concurrency, checks and remaining blockers. Claim neither parallel execution nor speedup without measured evidence.

Works everywhere

Bring Flash to your workflow.

Claude, Codex, Pi, Hermes, your IDE, or the API—Flash is ready wherever you start the task.

Join the waitlist

Flash pricing

Choose how much work Flash can take on

Every plan includes Flash across harnesses, IDEs, and API workflows. Up to 1200 tok/s.

Premium

Complete focused tasks with Flash.

$0/month

Join the waitlist

Features

Flash — Up to 1200 tok/s

Privacy-first processing

Prompts and responses are not used for training

Growth

Features

Flash — Up to 1200 tok/s

5x usage

Privacy-first processing

Prompts and responses are not used for training

Scale

Highest capacity

Put Flash behind demanding workflows.

$0/month

Join the waitlist

Features

Flash — Up to 1200 tok/s

20x usage

Privacy-first processing

Prompts and responses are not used for training

FAQ

Everything you need to know about Flash

Product, speed, compatibility, access, and API answers in one place.

Ready to work with Flash?

Join the waitlist to bring Flash into your workflow.

Join the waitlist

Flash is an ultra-fast MoE built specifically for rapid task completion. Teralor provides Flash as one focused product you can use across your existing workflow.

Flash was used to build Flash

One product. Every way you work.

Your AI leads. Flash executes.

Bring Flash to your workflow.

Choose how much work Flash can take on

Premium

Features

Growth

Features

Scale

Features

Everything you need to know about Flash

Ready to work with Flash?

What is Flash?

Where does Flash work?

How fast is Flash?

How do I use Flash through the API?

How are my prompts and responses handled?

How do access and billing work?