How to use
AlchemyLake

What it is

AlchemyLake turns governed data into governed creative: chat narratives and imagery today, richer media next. Every generation is metered by a real credit ledger and stored — with its prompt, model, status, and cost — in your private Vault. When you bind a data source, every figure in the output is traceable to the exact rows the model saw. Nothing ships without its record. Truth, made visible.

Think of it as the layer between your lakehouse and everything you publish: board narratives, investor updates, campaign copy, release notes, and imagery — produced under governance, sealed to their source, and billed per use.

Use cases — who uses this, and for what

AlchemyLake is for anyone who has to turn trusted numbers into words or pictures and cannot afford a hallucinated figure. A few concrete flows:

The common thread: the output is only as trustworthy as its source, and here that link is enforced and visible.

By lane, across industries

Every lane below is free to try on your Dawn Grant — 50 credits, no card.

Chat · 1 credit

• Financial services — FP&A binds the certified loan-performance table and drafts the monthly board narrative; delinquency and NIM commentary quoted from the actual ledger, not paraphrased from a dashboard screenshot.
• Public sector / transit — bind monthly ridership and draft the board-meeting performance narrative in the agency’s own voice, every figure the same one riders would see on the dashboard.
• Retail / CPG — a category manager binds weekly POS data and gets the Monday-morning sell-through brief for regional VPs, replacing a Sunday-night analyst writeup.
• SaaS — RevOps binds the MRR/churn table and generates the exec summary for Monday’s leadership sync — the same paragraph an analyst used to write by hand.

Report · 10 credits

• Investor relations — bind quarterly KPIs and produce the board deck’s narrative section as a sealed PDF, citations and verification printed on the page, ready to attach to the packet.
• Manufacturing — a plant quality manager binds defect-rate data and generates the weekly quality report distributed to line supervisors, every figure checked against the certified table.
• Public sector / compliance — bind audit-log rollups and produce the quarterly compliance report for regulators, with a sha256 of the exact data baked into the file.
• Nonprofit — a program director binds outcomes data and produces the funder-facing impact report — the numbers a grant officer will fact-check are already sealed to source.

Templates · posters, one-pagers, social, campaign packs

• Marketing — bind campaign-performance rows and run the campaign-pack recipe: poster, report, and social copy in one call, every number matching to the decimal.
• HR / people analytics — bind attrition and eNPS data and generate the quarterly people-ops one-pager for the leadership offsite.
• Sales ops — bind pipeline data and produce the QBR KPI poster for the regional kickoff, with the exact figures the CRM shows.
• Events — bind registration data and create the day-two attendance recap poster for social, minutes after doors close.

Presentation · 40 credits (5 slides)

• Finance / FP&A — bind the quarterly KPI table and walk into the board meeting with a finished .pptx: charts, a read-aloud script under every slide, and answers prepared for the questions the CFO will actually ask.
• Consulting / client services — bind the engagement’s metrics and generate the Monday steering-committee deck — the notes section carries the talk track, so anyone on the team can present it.
• Sales — bind pipeline data and produce the QBR deck with the exact numbers the CRM shows, plus Q&A prep for the renewal conversation.
• Ops / plant management — bind weekly output and defect data and hand shift leads a five-slide stand-up deck they can read verbatim.

Infographic · 45 credits

• DTC / e-commerce — bind this week’s sales data and generate a milestone social post where the actual number renders correctly in the image, not as a caption guess.
• Real estate — a regional brokerage binds MLS data and creates a market-update poster with the real median price and days-on-market for the newsletter.
• ESG / sustainability — bind emissions data and create the ESG-report cover infographic with the certified year-over-year reduction number.
• Manufacturing / ops — bind the safety log and create a plant-floor poster celebrating “45 days without a recordable incident” — pulled from the log, never typed by hand.

Video Briefing · 40 credits

• Executive comms — a chief of staff binds quarterly metrics and generates the all-hands opener with the real ARR figure captioned on screen.
• Product / growth marketing — bind usage data and create the launch-day social clip captioning the actual adoption number, not a rounded guess.
• Field ops / safety — bind incident data and produce a toolbox-talk opener with the real safety streak on screen.
• Investor relations — a 30-second earnings-day teaser clip with the exact reported figure captioned, safe to post the moment the release goes out.

Music · 50 credits

• Brand / marketing — bind a growth curve and generate a score whose tempo and arc rise with the actual trajectory, used as the launch-video bed.
• Internal comms — generate the all-hands opening sting whose energy matches this quarter’s real growth story, instead of a generic stock license.
• Podcast / content — bind quarterly metrics and generate a dynamic intro stinger that shifts mood release to release with the real numbers.

Podcast · 25 credits

• Executive comms — bind the week’s numbers and publish a 3-minute two-host briefing the leadership team can play on the commute — the analyst voice lands the figures, the interviewer asks what an executive would ask.
• Accessibility / inclusive comms — bind the same figures behind a written report and produce an audio version — same numbers, same seal, a different modality, transcript included.
• Field ops — a regional ops director binds this week’s output data and gets a spoken brief for site managers to play at shift-change.
• Customer success — bind usage and NPS data and create a Friday audio digest for the account team, replacing a written summary nobody reads.

Quick start

1. Open app.alchemylake.com and press Start free.
2. Sign up with email and password, then verify with the emailed code.
3. You land in the Studio with the 50-credit Dawn Grant already in your wallet — no card required.
4. Pick a lane — Analyst, Infographic, Report, Presentation, Video Briefing, Music, or Podcast — type a prompt, press Transmute (or ⌘+↩).
5. Optionally Bind a governed source first so every figure is sealed to its data.
6. Your result appears sealed with its model and cost, and is saved to the Vault.

The Studio

The Studio has three zones on desktop:

• Left rail — navigation (Studio, Vault, Admin if you hold the role, Docs) and your credit wallet with a top-up button.
• Center — the work — the Crucible: the prompt composer, the ember progress line while a model runs, and your latest sealed result.
• Right — the craft — lane selection (Analyst / Infographic / Report / Presentation / Video Briefing / Music / Podcast), one-click templates, the governed-source binder (with CSV/Excel upload), your brand kit, scheduled deliverables, the developer key panel, and the exact cost of the next run with your balance after it.

On phones the rail collapses into a top bar that always shows your balance.

The eight lanes — analyst, deep research, infographic, report, presentation, video briefing, music, podcast

The Crucible renders eight kinds of deliverable, and every lane binds to governed data — that is the product. When you bind a source, the Insight Engine first computes an analyst-grade statistical dossier from the exact rows — trend with fit quality (OLS R²), outliers (IQR fences, z-scores), correlations (Pearson r), segment shares and growth, concentration (HHI, Gini), and a period × segment pivot — all by code, never by a model. An expert panel (statistician, visualization lead, technical writer, enterprise consultant, and the lane’s own craft specialist) then designs the deliverable around that dossier, honoring your direction. Figures appear only as fact tokens the platform substitutes deterministically, so a number is either computed from your data or it does not appear.

On every bound render the grounded text that drove it — the plate note, storyboard, sonic legend, transcript, or speaker script — is returned with the asset, so you can audit exactly what the data contributed. Media lanes can take a minute or two; the ember line shows progress. Every result is credit-metered, stored in your Vault, and — when bound — provenance-sealed with the source name, row count, and data sha256. Failed or safety-blocked runs are refunded automatically.

Numbers are checked, not trusted. The platform derives the facts deterministically before generation, and verifies the output after: every numeric claim is matched against the facts and raw cells, and the result ships with a verification score (the ✓ chip — open it to see every checked number). Reports print the verification on the document itself; decks seal it into the closing slide.

Templates turn this into one-click deliverables: KPI poster, executive one-pager, social copy, board deck, audio briefing, boardroom video briefing, data score, and the campaign pack. Pick one in the right rail or start from the template gallery.

Governed sources — Bind → Transmute → Seal

This is the platform’s signature move, and it works in every lane. The right rail offers Bind · governed source: pick a dataset and the model is constrained to figures derivable from that data — nothing invented. In the Analyst lane the narrative itself is constrained; in Infographic, Video Briefing, Music, and Podcast the Insight Engine first derives the figures (and the data’s trajectory) from the bound rows, and only that grounded brief drives the render. The sealed result then carries its provenance: source name, row count, and a sha256 fingerprint of the exact data the model saw.

• Sample Lakehouse (demo) — three curated tables (weekly active users, revenue by region, campaign performance) built in so you can experience source-bound generation immediately.
• Unity Catalog (Databricks) — connect your own workspace from Studio’s Databricks panel (host, personal access token, SQL warehouse) and explicitly allowlist tables by browsing your catalog; those appear here as governed sources with the same seal. The connection is private to your account — encrypted at rest, with access scoped to you alone — and your data never leaves your lakehouse except as the rows you bind. Hold several workspaces, switch which is active, or disconnect at any time; nothing is exposed until you explicitly select it.
• Your uploads (CSV · Excel · PDF · Word · text) — drop a .csv, .tsv, .xlsx, .xls, .pdf, .docx, .txt or .md into the binder’s upload slot and it becomes a governed source of your own: tables are extracted and parsed (up to 5,000 rows × 60 columns); documents with no table bind as a sectioned corpus — headings, computed word counts, excerpts — so even unstructured files get the full treatment. Fingerprinted (sha256), private to your account, deletable at any time. No Databricks required — every lane, including Deep Research, works on an upload.
• Genie spaces (Databricks AI/BI) — when your active connection has a Genie space configured, ask a question in natural language and the answer’s result table is bound as a governed source — so a Genie answer can become a sealed poster, report, or campaign pack. On craft lanes your prompt doubles as the data question; if it’s pure direction, the platform distills a concrete data ask from the brief and retries automatically. Follow-up questions continue the same Genie conversation in your workspace, the seal records the Genie reasoning, SQL, and conversation id, and answers backed by a curator-certified trusted asset are badged on the seal. You can score a space’s curation health and certify it with live probe questions from the connection card (Studio → Databricks → Genie space health).

Try it: bind revenue.monthly_by_region and ask Chat for “a 3-bullet executive summary of Q2 revenue with exact figures” — every number traces to the bound rows. Then switch to Image with the same source bound and direct “a dawn-over-the-lake growth poster for the exec review” — the poster’s headline figures come from the same rows, and the grounded brief returns with the asset.

Databricks — install the App, or call it from Genie

AlchemyLake ships as an installable Databricks Asset Bundle so your team can run governed creative inside the workspace, right next to the data. There are three ways to connect, from zero-code to fully embedded:

Install the App (one command):

git clone https://github.com/zorost/Alchemy-Lake
cd Alchemy-Lake/databricks
# edit the workspace host in databricks.yml, then:
databricks bundle deploy  -t prod
databricks bundle run alchemylake_app -t prod

Open the App URL the CLI prints, paste your alk_… developer key (or bind it from a Databricks secret), then Load governed sources → pick one → Transmute. Every render is credit-metered and provenance-sealed exactly like the web app. The App runs on your workspace compute under SSO; in this connected mode the specific rows you bind (and your prompt) are sent to the AlchemyLake platform to produce and seal the render, and are never used for training. To keep inference entirely inside your workspace, see Data security & residency.

Beyond Genie — what AlchemyLake adds to a Genie workspace:

Genie answers questions about your data — tables and charts, inside the workspace. AlchemyLake picks up where that answer stops: it turns the same governed rows into finished deliverables Genie does not make — a board-ready PowerPoint with a read-aloud script and Q&A prep under every slide, an enterprise PDF dossier with a statistical appendix and an Excel evidence workbook, a deep-research investigation that asks Genie a planned sequence of follow-up questions and seals the findings, a designed infographic with the exact figures rendered in-image, an animated video briefing with narration, a two-host audio podcast about the quarter, even a score whose tempo follows your growth. Every one of them provenance-sealed (source · rows · sha256) and figure-verified — so a Genie answer can leave the workspace as something you can present, attach, publish, or play.

The integration is honest about cost and quality, too: the Studio shows a per-question DBU estimate before you ask (Genie compute bills inside your own workspace — the first 150 DBUs per user per month are free on Databricks’ Genie meter), the seal carries Genie’s own reasoning, generated SQL, and a trusted-asset badge when the answer came from a curator-certified query, thumbs up/down on any Genie-bound result flows straight back into your space’s own feedback loop, and Genie space health (Studio → Databricks → your connection) scores the space’s curation 0–100 with concrete fixes and can certify it by replaying real questions through the live API.

Walkthrough — give Genie / Agent Bricks the power to render:

AlchemyLake speaks MCP (Model Context Protocol), which Databricks agents can call as an external tool. The result: an analyst asks an agent a question, the agent answers it with Genie, then hands the numbers to AlchemyLake to render the sealed deck, dossier, infographic, video briefing, or podcast.

1. In the Studio’s right rail, open Developer access and mint a key. It is shown once — store it in a Databricks secret: databricks secrets put-secret alchemylake api_key
2. In your workspace, open Agents (Agent Bricks) → your agent → Tools → Add tool → MCP server, and register:

   {
     "mcpServers": {
       "alchemylake": {
         "url": "https://app.alchemylake.com/api/mcp",
         "headers": { "Authorization": "Bearer {{secrets/alchemylake/api_key}}" }
       }
     }
   }

   The same block works in Claude Desktop, Cursor, and any MCP-capable client.
3. The agent discovers thirteen governed tools: list_governed_sources · upload_source · get_wallet · render_governed_chat · render_deep_research · render_infographic · render_report · render_presentation · render_video_briefing · render_music · render_podcast · list_recipes · run_recipe. Every render tool accepts a source_id so the output is bound, verified, and sealed — and chat returns a thread_id the agent can pass back to keep one continuing conversation (Genie sources stay in context across turns).
4. Pair it with a Genie space in a multi-agent supervisor: Genie answers the question from your lakehouse; AlchemyLake turns the answer into the deliverable. Try: “Ask Genie for Q2 revenue by region, then render_presentation on the result — 8 slides, titled Q2 Momentum.”

The full bundle, App source, and SQL function live in the /databricks directory of the repository, with a step-by-step README.

Credits & pricing

Your balance is always visible in the left rail (desktop) or the top bar (mobile). The ledger is append-only: every grant, charge, and refund is a permanent entry, so your balance is always the exact sum of its history. Prices are held in an editable rate-card; a superadmin can retune any lane from the Admin console without a deploy.

The Vault

Every generation — succeeded or failed — is recorded with its prompt, model, status, and credits charged. Images are stored privately and served through short-lived signed links that only work while you are signed in. If an image stops loading after about an hour, reload the page to mint fresh links.

Top-ups & billing

The Top up button in the wallet opens a secure checkout for the $5 / 500-credit pack. The balance updates within seconds of payment — the ledger is credited idempotently, so a retried payment can never double-credit.

The platform currently runs checkout in test mode: use card number 4242 4242 4242 4242 with any future expiry and any CVC. No real money moves until launch.

Roles & admin

• member — generate, top up, view your own Vault.
• admin — adds the Admin console: platform stats, user list with balances, recent generations with verification scores, the approvals queue (release or reject gated deliverables), and the audit log of sensitive actions.
• superadmin — adds the power to grant credits, change user roles, toggle a user’s approval gate (their deliverables need admin release before download), and retune the rate-card live (with a margin guardrail that blocks below-cost prices).

If you hold a role, Admin appears in the left rail. Role checks are enforced server-side; the interface only reflects them.

Developers — CLI, REST API, MCP server & keys

One key (alk_…) opens three doors: a real CLI, a public REST API, and an MCP server. Create the key in Studio → Developer · MCP & keys; it is shown once, hashed at rest, revocable anytime.

The CLI — zero-install via npx:

export ALCHEMYLAKE_API_KEY=alk_YOUR_KEY

# bring your own data — CSV, Excel, PDF, Word, text (≤6MB, no Databricks needed)
npx alchemylake upload ./q3-actuals.xlsx
# → registered: up.1a2b3c ("q3-actuals", 812 rows × 9 cols)

# every governed source visible to your account
npx alchemylake sources

# render any lane, sealed and verified
npx alchemylake render report --prompt "Board brief" --source up.1a2b3c
npx alchemylake render deep_research --prompt "Why did Q3 dip?" --source up.1a2b3c
npx alchemylake render chat --prompt "Break it down by region" \
  --source genie:dbx1 --thread th_abc   # Genie stays in context

# scriptable: --json + jq
npx alchemylake vault --limit 5 --json | jq -r '.[0].asset_url'

The REST API — /api/public/v1, OpenAPI at /api/public/v1/openapi.json:

# create a bound, sealed generation (kinds: chat, deep_research, image,
# video, music, voice, report, deck — or pass "recipe" instead of "kind")
curl -s https://app.alchemylake.com/api/public/v1/generations \
  -H "Authorization: Bearer alk_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"kind":"chat","prompt":"3-bullet exec summary with exact figures",
       "source_id":"sample:revenue.monthly_by_region"}'

# register your own file as a governed source (base64, ≤6MB)
curl -s https://app.alchemylake.com/api/public/v1/sources \
  -H "Authorization: Bearer alk_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"filename":"q3.csv","content_base64":"'"$(base64 -i q3.csv)"'"}'

# queue a long lane and poll (pass "wait": false, then GET until settled)
curl -s https://app.alchemylake.com/api/public/v1/generations/GEN_ID \
  -H "Authorization: Bearer alk_YOUR_KEY"

# wallet · sources · rate-card · recipes
#   GET /me   GET /sources   GET /rates   GET /recipes

The same key drives the MCP server — from Databricks Genie / Agent Bricks, Claude, Cursor, or any MCP client. Your agent gains thirteen tools: list_governed_sources, upload_source, get_wallet, render_governed_chat, render_deep_research, render_infographic, render_report, render_presentation, render_video_briefing, render_music, render_podcast, list_recipes, and run_recipe — every render metered by your credit wallet and sealed with provenance.

1. In the Studio’s right rail, open Developer · MCP & keys and press Forge a new key. Copy the alk_… key — it is shown once.
2. Add the server to your MCP client:

{
  "mcpServers": {
    "alchemylake": {
      "url": "https://app.alchemylake.com/api/mcp",
      "headers": { "Authorization": "Bearer alk_YOUR_KEY" }
    }
  }
}

In Databricks, register the same URL as an external MCP server for Genie / Agent Bricks and any agent can answer with sealed, brand-governed creative drawn from your governed data.

The public health probe used on the landing page is real and unauthenticated:

$ curl -s https://app.alchemylake.com/api/health
{"web":"ok","api":"ok"}

Security & governance

• Provenance by construction — bound generations record the source, row count, and a sha256 of the exact rows the model saw. The seal is stored with the generation and shown on the output.
• Data residency — your Unity Catalog tables stay in your lakehouse; only the rows you bind (and your prompt) are used for a render. In the default connected mode those are sent to the AlchemyLake platform to produce and seal the output; a no-egress deployment keeps all inference inside your workspace. Bound data is never used for training.
• Least-privilege keys — developer keys are hashed at rest, shown once, and individually revocable.
• Server-side role checks — member / admin / superadmin boundaries are enforced in the API, never just the UI.
• Append-only ledger — every credit event is immutable, so billing is auditable end to end.

Data security & residency

AlchemyLake is built so your governed data stays governed. Your Unity Catalog tables never move in bulk; only the specific rows you bind for a given render are ever read, and bound data is never used to train any model. What differs between deployments is where the inference runs.

Connected mode is the default and works today across all five lanes — fastest to adopt, with a provenance seal (source · row count · sha256) on every render. No-egress mode is the enterprise / regulated path: text runs on Databricks Foundation Model APIs and imagery on a Model Serving endpoint in your own workspace, so no prompt or row ever leaves your Databricks tenant, and inference is billed as your own Databricks compute. If a specific media model cannot be hosted on Model Serving, that lane is turned off in strict mode or routed through an egress you approve — the numbers-bound text core always stays in.

Turning it on is self-service: add your workspace’s Foundation Model serving endpoint when you connect it in Studio’s Databricks panel, then switch your text residency to “workspace” in account settings. The prerequisite lives on the Databricks side — Foundation Model APIs / Model Serving enabled and, for strict isolation, network policies or PrivateLink — which your workspace admin configures. Email info@zorost.com if you’d like help planning that rollout.

Licensing

AlchemyLake uses a layered license — the license for a given piece of code depends on where it lives, so the platform can stay commercial while the building blocks that help you integrate are open.

Your data and your outputs. Using AlchemyLake does not grant us rights to your data: bound rows are used only to produce your render and are never used to train models, and the creative you generate is yours to use. Access is a free credit grant plus optional paid credits; developer keys are issued to you and are revocable.

Installing from Databricks. The Asset Bundle installs the App source into your workspace for in-workspace use under the platform (proprietary) license; the MCP client and SDK you may embed elsewhere are Apache-2.0.

Full texts: LICENSE and the LICENSES directory. A public Terms of Service and Privacy Policy are being published ahead of general availability. Licensing questions: info@zorost.com.

Content credentials & safety

Content credential (C2PA-aligned). Free-tier images carry a subtle visible watermark and an embedded provenance manifest: the generator (AlchemyLake), the model, the generation id, and any governed sources the image was sealed to. This aligns to the C2PA “content credentials” model so a downstream tool can read where the asset came from; cryptographic C2PA signing is on the roadmap.

Safety. Every prompt is screened before any credit is charged, and chat output is screened before it is returned. Clearly prohibited requests — sexual content involving minors, weapon- or bioweapon-building instructions, credible incitement of violence, malware/credential theft — are refused with no charge. Ordinary business, data, marketing, technical, and artistic work is allowed. If a safety block ever fires on a run you already started, the credits are refunded automatically.

FAQ

• Is my data used to train models? No. Bound rows are sent only to produce your render and are not used for training.
• Do I need Databricks to use AlchemyLake? No — the web Studio and the Sample Lakehouse work standalone. Databricks unlocks binding your own Unity Catalog tables and running the App in-workspace.
• What happens if a generation fails? You are auto-refunded the credits; the attempt is still recorded in your Vault.
• How is this different from a raw LLM? A raw model will happily invent a number. AlchemyLake constrains the model to a governed source and seals the output to it — so a figure is either derivable from your data or it does not appear.
• Can I automate it? Yes — via the MCP server, the Databricks App, or ai_render() in SQL/Genie.

Troubleshooting

• “insufficient credits” — your balance is below the mode’s cost. Top up, or switch to chat (1 credit).
• Image shows a broken link after ~1 hour — the signed link expired. Reload the page.
• Payment succeeded but the balance didn’t move — wait ~10 seconds and reload; the webhook credits asynchronously. If it persists, contact support with your receipt.
• MCP tool call returns “Unauthorized” — your key is missing or revoked. Forge a new alk_… key in Studio → Developer and update your client config.
• ai_render() raises a connection error — the serverless compute needs external network access enabled; otherwise use the MCP path. See databricks/sql/ai_render.sql.
• Signed out unexpectedly — sessions expire periodically for security; sign in again.