CLI demos

Terminal recordings, rendered as SVG: install through deploy, local through Snowflake, the AI copilot, agentPolicy enforcement, day-2 incident response, and agent-loop compaction. Each one carries a takeaway popup with the numbers from that recording. Click play; the SVG only animates after you opt in (no autoplay, no JS).

Recorded against CLI 0.10.0

The recordings were made with CLI 0.10.0 and have not been re-recorded for 0.18.1. The output, versions, timings and costs on screen are from that recording. Where this page and a recording disagree about what the CLI does today, the page is right: see the notes under each section. For current output, follow Get Started.

Convinced? → Install in 30 seconds. Want longer-form proof of specific workflows? → See it run (narrative scenarios, ~50 s each, with takeaway numbers).

Install + run, locally

Start here. No cloud account is needed.

On the CLI that this site documents (0.18.1), fluid init my-project --quickstart scaffolds the template with fluidVersion: 0.7.5 and also writes a workspace file next to the project. The recording predates both; the contract it validates carries an older fluidVersion. See Get Started for the files the current CLI writes.

fluid init my-project --quickstart → validate → plan → apply

Install the CLI, scaffold the Customer 360 Analytics contract from the quickstart template, validate it, preview the plan, and apply it against the local DuckDB provider. Two exposes — a master table and a high-value-customer view — land as Parquet under output/.

Same contract, different cloud

Change the binding block and re-deploy. The schema, dq.rules and build stages stay as they were; the cloud-specific fields in binding change. Changing binding.platform alone is not enough: the platform, the format and the location have to agree. For example, platform: gcp with a parquet format and a local path produces a plan that emits nothing, and fluid validate warns that apply would emit nothing for that port. See Switch clouds for the three keys that move together.

GCP / BigQuery

GCP quickstart — install, change the binding, deploy

From the local Customer 360 contract to a BigQuery dataset. The `git diff` in the recording shows the binding block changing; the schema, dq.rules and build stages stay as they were.

AWS / Athena

AWS quickstart — S3 + Glue + Athena

Same Customer 360 contract, AWS provider extra installed, binding swapped to the AWS platform. S3 bucket provisioned, Glue catalog auto-created, Athena made queryable — all from fluid apply.

Snowflake

Snowflake quickstart — dry-run flow

The dry version: env-file credentials, contract validation, plan preview, and apply --mode dry-run rendering DDL without firing it. For the live-auth version see snowflake-real below.

AI copilot — full Gemini-powered flow

The fluid forge AI copilot generating a finance-domain contract end-to-end: project memory loaded, finance domain expertise pack applied (SOX + GDPR), local context discovered, a Gemini streaming call, and the contract emerging block-by-block with the agentPolicy gate. The version below is hand-scripted to follow the real-API flow; a real-capture script (scripts/demos/forge_gemini_real_capture.py) is kept for recording an actual session.

fluid forge --domain finance --llm-provider gemini --llm-model gemini-2.5-flash

The full agent flow: memory → domain pack → discovery → streaming → contract emit (schema, dq.rules, accessPolicy, agentPolicy, sovereignty) → auto-validation → memory persist.

Snowflake live-auth dry-run

The snowflake-biz-lab flow at full fidelity: env credentials sourced, real validate --strict, plan against the live account, apply --mode dry-run rendering DDL without firing it, then policy-apply --mode check over the compiled IAM bindings.

Snowflake — validate → plan → apply --mode dry-run → policy-apply --mode check

Live auth (account=acme-demo placeholder; the scrubber substitutes the real account name). No DDL fires, no RBAC mutates — just the auth + connectivity + dry-render flow you'd run before a real production deploy.

AI copilot — interview shape only

fluid forge --blank skips the LLM call entirely and just scaffolds the structured stub for the chosen domain. Useful when you know what you want and don't need an LLM round-trip.

fluid forge --blank --domain finance

The blank skeleton with finance-domain defaults pre-seeded: SOX/GDPR regulatory framework, 'training' and 'fine_tuning' denied use cases, Gold layer assignment. Fill in the expose blocks yourself — no LLM call.

Policy + IAM compilation

The policy-check → generate artifacts → policy-apply --mode check triple. Validates the access policy, compiles to cloud IAM bindings (BigQuery/Snowflake/AWS), and hands the bindings to the provider in check mode (no live IAM mutations; as of 0.18.1 --mode enforce makes none either).

policy-check → generate artifacts → policy-apply --mode check

Three commands, full policy round-trip from declarative `accessPolicy.grants` in YAML to native cloud IAM JSON, then a check-mode run that reports the bindings the provider received.

agentPolicy enforcement (LLM / AI governance)

Declare agentPolicy in YAML, validate it, see the enforcement summary, watch a replay of agent reads (allow/deny) against the policy.

agentPolicy — declare, validate, gate (validate → policy-check → audit)

The YAML block (allowedModels, deniedUseCases, canStore, auditRequired) → validate → policy-check enforcement summary → 4 replayed agent reads (gpt-4 allowed, claude-3 + training denied, unlisted model denied, gemini summarization allowed).

Long-form scenario casts

The casts below pair with the See it run page. Each tells a story (problem, CLI flow, result) in about 30-50 seconds, with takeaway numbers from the recording.

`$0.03` per data product — three providers, one contract

fluid forge data-model — same intent, three providers, real cost figures

Eight lines of intent YAML. Anthropic, OpenAI, Ollama — same flag swapped each time. The recording shows all three producing a valid contract and the same dbt project layout, with the token counts and costs of that run.

Six months → sixty seconds — source-aligned Bronze

fluid init --discover postgres://... — Bronze contract in 60 seconds

Connect, scan information_schema (47 ms), infer 28 tables / 143 columns / 12 PII candidates / 8 foreign keys, emit a complete Bronze contract.fluid.yaml, validate, apply against embedded DuckDB. 6.2 seconds total. Then show the engine swap path.

23 questions, skipped — guided UX

fluid forge — guided UX in action

47 ms welcome scan finds 3 CSVs + 2 dbt models + 1 README, infers domain (finance) and PII (5 columns). 5-mode picker. 4 questions answered (most accept the inferred default with ↵). Cost-cap progress in real time ($0.000 → $0.021 of $0.050 cap). Pre-write panel shows exactly what will + won't change.

3am Slack ping → ship in 90 seconds

PagerDuty: freshness SLA breached. fluid runs status shows 3 consecutive failures. fluid runs logs --component dlq surfaces the root cause. fluid runs diff shows what changed since the last OK run. One-line contract fix. fluid ship. 87 seconds end-to-end. Recovered 12,361 rows.

`$0.50` → `$0.05` — agent-loop compaction

Agent-loop compaction — three strategies, real before/after costs

20-turn baseline: $0.503/run, super-linear context bloat (5K → 67K → 298K tokens). Three strategies side-by-side: truncate (5.8× cheaper), summarize (9.3× cheaper), hybrid (10.5× cheaper). One env var: FLUID_COMPACTION_STRATEGY=hybrid.

How the casts are produced

The pipeline that built each SVG above:

   scripts/demos/<name>.py            ← cast generator
                ↓
        /tmp/casts/<name>.cast.raw    ← raw asciinema cast (gitignored)
                ↓
        scripts/cast-v3-to-v2.py      ← format conversion (asciinema 3.x → 2.x)
                ↓
        scripts/scrub-cast.py         ← strip API keys, JWTs, env-shaped secrets
                ↓
        svg-term --in <cast>          ← render to animated SVG (no --window;
                                          our <CliCast> component supplies
                                          the terminal chrome)
                ↓
   docs/.vuepress/public/demos/<name>.svg   ← the only file that gets committed

Two passes of secret-scanning happen:

scrub-cast.py redacts known formats (AIza…, sk-…, sk-ant-…, JWTs, KEY=…/SECRET=…/PASSWORD=… 16+ char values) and substitutes literal $SNOWFLAKE_ACCOUNT/$SNOWFLAKE_USER/$GEMINI_API_KEY env values for friendly placeholders.
Final-SVG grep in generate-demos.sh re-scans the output before keeping the file. If any leak pattern matches in the post-scrub SVG, the file is deleted and the build fails.

The .cast.raw working files live in /tmp/casts/ (gitignored) and are deleted at the end of each render.

To regenerate everything:

scripts/generate-demos.sh                 # regenerate every cast
scripts/generate-demos.sh --safe-only     # only the credential-free casts
scripts/generate-demos.sh forge-gemini    # one specific cast

Source for each cast lives at scripts/demos/<name>.py — review or fork freely.