Chion, answered: verified SQL, credits, setup, and SKILL.md export

Chion is an AI analytics platform for PostgreSQL that turns plain-English questions into verified, read-only SQL with interactive D3 charts. You connect a database in Chion Studio, ask in plain English, and get a verified read-only SQL query plus an interactive D3 chart for each answer, with the exact SQL under every chart so every number is auditable. Direct-connect to Postgres, no ETL, no warehouse copy, and the reusable SQL skills you build are yours to export into Claude Code, Cursor, or Codex.

Text-to-SQL converts plain-English questions into executable SQL queries. The system combines your question with the database schema, has the LLM draft the SQL, then validates and runs it read-only. You type "revenue by region last quarter" and get the chart with the exact SQL underneath.

Conversational analytics lets you ask a question in plain English and get a chart with an explanation, then follow up while the system remembers context. Direct-connect to your Postgres, no dashboard authoring, no analyst ticket, and each answer includes the SQL so every number is auditable.

No. A prompt wrapper sends your question to a single LLM call and returns whatever SQL it writes, with no schema awareness and no validation. Chion profiles your live schema first, then a typed SQL contract restricts the model to columns that exist, a two-layer validator blocks non-SELECT in code, and read-only execution runs the result. The model never touches your database directly, and the exact SQL is visible under every chart.

Chion renders eight pre-built D3 chart types, not generated on the fly. Single-line, multi-series line, dual-axis line, stacked area, standard bar, grouped bar, stacked bar, and animated bar race. Chart selection is deterministic: the same data shape always produces the same chart type, scored by compatibility against the query result. All support zoom, pan, filtering, and data labels, and every data point traces back to the SQL that produced it.

Yes, always. The exact SQL query is displayed beneath every chart and answer. This is a core design principle: every number must be traceable to the query that produced it.

Anthropic Claude (Haiku, Sonnet, and Opus), via paid commercial API tiers whose provider terms prohibit training on customer inputs. Chion's architecture is model-agnostic: the schema profiling and two-layer validation don't depend on the model, so OpenAI and Google are available on request, and on-premise deployment is on the roadmap. Same pipeline, different proposer.

Yes. Managed cloud, dedicated GPU via CoreWeave, or fully on-premise installation. The two-layer SQL validation and AES-256-GCM credential vault run the same way in every environment. No architectural compromises across deployments: metadata and summaries in, read-only SQL out. Raw rows never cross the boundary.

No. Ask in plain English and Chion writes the verified SQL behind it. Phrase the question the way you would in Slack ("DAU last 30 days by plan tier") and the query is visible if engineering asks how the number was produced, but you never have to draft it yourself.

Most SQL generators write queries on the fly from a pasted schema. Chion profiles your live schema first, binds the model to a typed SQL contract, validates the query in two layers, and shows the exact SQL under every chart. If validation fails, a deterministic repair loop (up to 2 attempts) rewrites the query with error context. You also control the infrastructure: managed, dedicated GPU, or on-prem with the same read-only guarantees.

Dashboards show pre-built views someone else configured. Chion answers on the fly: direct-connect to Postgres, no ticket, no analyst, no wait, and each answer includes the SQL so you can verify it. It can replace a BI tool outright, or for teams that still rely on dashboards the generated SQL pastes directly into Tableau, Looker, or any PostgreSQL client.

ChatGPT writes SQL from a pasted schema but cannot connect to your database, execute the query, validate results, or render a chart. Chion does all four: live read-only connection, contract-based validation against your real columns, chart selection across eight pre-built D3 types, and full audit logging. The exact SQL is visible under every chart.

Chion direct-connects to your Postgres; Tableau and Looker require ETL first. No pipeline configuration, no dashboard build. Ask in plain English and get a verified SQL query plus an interactive chart in seconds. Pricing starts at $29 per seat.

Chion enforces four invariants most SQL chatbots skip. A typed SQL contract restricts the model to columns that exist. All queries are read-only SELECT. Every query passes a two-layer validator before execution. Credentials live in an AES-256-GCM vault, never cached in application memory. The exact SQL is visible under every chart so you can audit it.

1,000 rows / 12,000 cells, a hard cap on every query. If the result would exceed the cap, the pipeline first coarsens time grain (daily → weekly → monthly), then applies TopK ranking. It never auto-filters date ranges. Silently dropping dates would change the answer. Deterministic guardrails, no runaway queries, no unreadable dumps.

No. Schema profiling catalogs every table and column before the LLM sees anything, then a typed SQL contract restricts the model to columns that exist, a two-layer validator blocks non-SELECT in code, and a repair loop retries on failure. Entity resolution uses pgvector embeddings of real column values, so generated SQL references only columns your database actually has.

Schema profiling catalogs every table, column, data type, and foreign-key relationship up front, and the typed SQL contract enforces valid JOIN conditions and CTE structure against those real relationships. If the generated SQL violates the contract, a deterministic repair loop (up to 2 attempts) rewrites it with error context before execution. Accuracy scales with schema coverage: more metadata, sharper SQL.

Yes. Ask "top 5 products by sales per region" and Chion emits ROW_NUMBER() OVER (PARTITION BY region ORDER BY SUM(amount) DESC), filtered to rank <= 5, rendered as a grouped bar chart. ROW_NUMBER, RANK, DENSE_RANK, LAG, LEAD, NTILE, PERCENTILE_CONT, and aggregate OVER clauses all run natively for rankings, running averages, and period-over-period comparisons; the semantic layer picks PARTITION BY from the categorical columns found during schema profiling.

Yes. Ask "revenue by customer segment" and Chion emits INNER JOIN customers c ON o.customer_id = c.id ... GROUP BY segment, rendered as a bar chart. During schema profiling Chion catalogs every foreign key, column type, and relationship; the SQL contract validates each JOIN condition against those real keys before execution, so joins never reference columns that don't exist. The semantic layer picks INNER vs LEFT from your intent, handles self-joins and 5-plus-table queries, and lets the PostgreSQL planner choose join order.

Yes, because the safety lives in code, not in the prompt. A DIY n8n or GPT-to-SQL pipeline sends model-generated SQL straight to your database, so an INSERT, UPDATE, or DELETE runs if the prompt drifts. Chion routes every query through an L1 read-only SELECT check and an L2 validator that reject anything but a read-only SELECT, caps results at 1,000 rows / 12,000 cells, keeps credentials in an AES-256-GCM vault, and honors PostgreSQL row-level security on every query. The model sees only schema metadata and aggregated results, never raw rows.

Yes. Ask "customers with no orders in 90 days" and Chion emits LEFT JOIN recent_orders ro ON ... WHERE ro.customer_id IS NULL, returned as a table. Negative-phrasing questions ("products not ordered", "customers without a purchase", "features with no adopters") all emit a LEFT JOIN with IS NULL filtering on the foreign-key column; the semantic layer detects the exclusion intent from words like "without", "no", "not", "missing" and picks the anti-join pattern deterministically.

Yes. Ask "regions with avg order value > $500" and Chion emits a GROUP BY region aggregation, then filters with avg_order_value > 500, rendered as a bar chart. When a question filters an aggregated result ("regions with revenue over $1M", "cohorts with churn above 5%"), the semantic layer emits GROUP BY with HAVING; the contract enforces type-correct aggregations, picks COUNT, SUM, or AVG from each column's classification, and routes pre-aggregation filters to WHERE and post-aggregation filters to HAVING.

Yes. Ask "50/75/95th percentile of order amounts by region" and Chion emits PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY amount), one row per percentile per region. "Median" maps to PERCENTILE_CONT(0.5), "p95" to PERCENTILE_CONT(0.95), and "most common value" to PERCENTILE_DISC; the semantic layer picks continuous vs discrete from the column's classification during schema profiling.

Yes. Ask "monthly revenue, then QoQ % change" and Chion emits a WITH clause that computes monthly_total, then LAG(monthly_total) OVER (PARTITION BY product_category ORDER BY month) and ROUND(100.0*(...)/LAG(...),2) for the change, rendered as a line chart. Multi-step intent (cohort analysis, ranked subsets, running totals, recursive hierarchy traversals) lands as WITH clauses bound to your schema contract; WITH RECURSIVE is supported with an enforced depth limit, and the planner inlines non-recursive CTEs on PG 12+. You never write the CTE; Chion generates, validates, and runs it read-only.

Temporal direction in the question picks the function. Ask "daily revenue with prior day and % change" and Chion emits LAG(revenue) OVER (PARTITION BY product ORDER BY date) for the prior value and a NULLIF-guarded ratio for the change, rendered as a line chart. Backward-looking phrasing ("growth from last month") emits LAG; forward-looking phrasing ("days until renewal", "gap to upcoming order") emits LEAD. ROWS BETWEEN handles row-count windows, RANGE BETWEEN handles time-based windows, and default offset is 1 unless the question specifies otherwise.

NTILE divides a sorted partition into n equal buckets. Questions about quartiles, quintiles, deciles, and percentile-rank buckets ("revenue contribution by top 20% of customers" emits NTILE(5)) route through it. The semantic layer picks NTILE for distribution analysis, RANK for ordinal ranking, and PERCENT_RANK when you need the actual fraction (0.0 to 1.0) instead of a bucket index. Same intent, same function.

Yes. Multi-turn conversations are native. Ask "revenue by region," then "break that down by month" and the follow-up refines the prior query surgically: Chion carries forward the schema context, query history, chart state, and active filters, so only the changed parts are regenerated and everything else reuses the verified previous turn. That's how the pipeline stays fast and deterministic across long conversations without re-computing from scratch.

Often, yes. Chion direct-connects to your Postgres; Amplitude and Mixpanel require you to instrument and emit events first. If your event data already lives in Postgres, Chion queries it directly for activation, churn, feature adoption, funnel conversion by channel, DAU/WAU/MAU with stickiness, and retention cohorts out of your existing tables, with no instrumentation. If your events are in a warehouse like BigQuery or Snowflake, replicate the relevant tables to Postgres (via Fivetran, Airbyte, or a CDC pipeline). If you want session replay or experimentation features, Chion sits alongside them and answers the questions your event schema doesn't cover.

Ask Chion in plain English. "Feature adoption rate by plan tier for last month" emits the right deduplication (COUNT DISTINCT user_id), the right ratio (users-who-used / total-users), the right date filter, then one of eight pre-built D3 charts. The SQL is visible under the chart, so engineering can verify the logic. You ask the question and get the answer.

Yes. Every chart shows the exact SQL underneath. Copy it, paste it into a dashboard or a ticket, version it in dbt, drop it in a Slack thread for review. Every statement is a read-only Postgres SELECT, lint-checked for structural defects, and hard-capped at 1,000 rows / 12,000 cells, so engineering runs it as-is. Engineering can audit, optimize, or take ownership without rebuilding anything; the handoff is built in.

Yes. Ask "activation funnel for users who signed up last month, by channel" and Chion emits COUNT FILTER (WHERE step = 'signup') for the top, COUNT FILTER (WHERE step = 'activated') for completion, and a ratio guarded by NULLIF so a zero-signup channel never divides by zero. The result lands as a pre-built stacked bar chart with the activation rate annotated. Deterministic: same schema, same SQL, same chart.

Jonathan Dag founded Chion in 2025. He is a data analyst with a decade of experience at Meta, Twilio, American Express, MasterCard, and Bosch. Chion exists because every analytics tool he used either trusted the LLM blindly or made the user write SQL by hand; the curated-pipeline design (schema profiling, two-layer validation, pre-built D3 charts) is the answer to that gap. Chion is built and operated by Dagnostics LLC, a remote-first company based in Broward County, Florida, United States.

Chion converts plain-English questions into verified read-only SQL and an interactive pre-built D3 chart. It direct-connects to PostgreSQL, builds a semantic layer from your schema on connect, and validates every query in two layers before it runs. No ETL, no dashboard building, and the exact SQL is visible under every chart.

Yes, that's the point. Paste a read-only PostgreSQL connection string and Chion direct-connects, builds the semantic layer from your live schema in the background, and starts answering plain-English questions within about 60 seconds, on a 7-day trial. It works with every managed provider (RDS, Aurora, Azure Flexible/Single, Cloud SQL, Neon, Supabase) plus self-hosted PostgreSQL. The 2-minute demo video walks through a PostgreSQL 14 fixture; you see the real pipeline against your real data, not a canned fixture.

Chion generates SQL against a semantic layer built from your schema on connect. Schema profiling catalogs every table and column, a typed SQL contract restricts what the model can reference, two-layer validation blocks writes and enforces LIMIT, and the query runs read-only. The same compiled context is what makes the generator instant and accurate, and you can export it to run the same agent in Claude Code, Cursor, or Codex. No blind prompting, no invented columns.

Per seat: $29/mo Starter, $99 Pro, $299 Max; Enterprise is per-team, custom-quoted. Every plan starts with a 7-day trial. Starter includes 50 verified questions per month, Pro 250, Max 750, Enterprise unlimited. Billing is monthly only (no annual discounts today) through Stripe, renewing the same day each month; upgrades prorate to the current cycle immediately, downgrades take effect at the end of the cycle, and you can cancel in one click.

Yes. 7 days. Direct-connect your PostgreSQL database, build the semantic layer, and run real questions before you pay anything. You're testing the actual pipeline against your actual schema, not a canned demo.

Credits are the usage allotment included with your plan: Starter 50 per month, Pro 250, Max 750, Enterprise custom. Schema exploration, saved-chart reloads, and validator repair retries don't reduce that allotment, and schema questions ("what tables do I have?") stay free on every plan. Monthly plan credits reset on your subscription anniversary day and don't roll over; credit packs ($25 for 50, $45 for 100) never expire and stack on top. If you run out, wait for the reset, buy a pack, or upgrade and the difference prorates to the current cycle.

Yes. One click from the billing page. No email, no retention call, no "please don't go" screen. Your plan stays active through the end of the current billing cycle, so you keep the credits you already paid for. After that, you keep access to your question history and generated SQL.

Anytime. Upgrades are instant: the price difference prorates to the current billing cycle and the new credits are available right away. Downgrades take effect at the end of the current cycle, so you keep the credits you already paid for. No penalties, no ticket, one click from the billing page.

Hourly question caps scale with plan: Starter 3/hr, Pro 10/hr, Max and Enterprise unlimited. These rate limits are a deterministic guardrail that protects platform stability and your database from runaway query loops, alongside the 1,000-row / 12,000-cell budget and read-only SQL enforcement. No surprise overage charges. You see the cap, you stay under it, you pay what's on the plan.

Prorated refunds within 14 days of your first charge, no questions asked. After that window, cancel anytime and keep access through the end of the current billing cycle. You're never charged past what you've used. All payments run through Stripe, and refunds process back to the original payment method.

Many AI SQL tools meter you per query, so cost climbs with every question your team asks. Chion does not. Plans are per seat ($29 Starter, $99 Pro, $299 Max; Enterprise is per-team, custom-quoted), and the price scales the volume allotment, not the verification: read-only SQL enforcement, the two-layer validator, and the exportable skill library are identical on every tier. You see the hourly cap and monthly allotment up front, with no per-query overage charges.

PostgreSQL today: direct-connect, no ETL, no warehouse copy. Chion works with every major hosted provider: AWS RDS, Azure Database for PostgreSQL, Google Cloud SQL, Neon, and Supabase, plus self-hosted PostgreSQL reachable from Chion's egress. BigQuery, Snowflake, and MySQL are on the roadmap with no confirmed ship date; in the meantime, warehouse data replicated into Postgres via Fivetran, Airbyte, or a CDC pipeline is queryable against the Postgres tables.

Paste a read-only PostgreSQL connection string into Chion Studio. Create a dedicated read-only role with CONNECT, USAGE, and SELECT on the schemas you want analyzed (no superuser, no write privileges), then Chion direct-connects over TLS, profiles your live schema, and builds the semantic layer in the background, so the generated SQL references your actual tables and columns, not guesses. No ETL, no warehouse copy. Most users have a verified query and a chart on screen within about 60 seconds.

A dedicated read-only PostgreSQL role with CONNECT, USAGE, and SELECT on the schemas you want analyzed. No write privileges, no superuser, no replication role: Chion only issues SELECTs and the L1 validator enforces that in code, so elevated privileges would grant capabilities Chion cannot use. Grant only what you want Chion to see; Row-Level Security policies on your tables are honored on every query.

Yes. Replicas are the natural target. Chion only issues read-only SELECTs, which maps perfectly to a replica endpoint: zero write risk, offloaded compute away from the primary, no impact on transactional workloads. Paste the replica's host into the connection string and the semantic layer builds against the replica's schema identically to the primary. The same applies to a Cloud SQL read replica.

Yes. Chion direct-connects through PgBouncer in transaction pooling mode. Every query is a short-lived read-only SELECT, so there's no session-state binding for the pooler to break. For Supabase, use the Supavisor transaction pooler at port 6543. For Azure Flexible Server, use the built-in PgBouncer on port 6432. Deterministic execution, not ad-hoc connection churn.

Extension tables and views are queryable like any other relation: the semantic layer profiles them on connect and runs SELECTs against them. Extension-specific functions (PostGIS ST_* functions, TimescaleDB time_bucket, pgvector operators) are not in Chion's function allowlist today; the workaround is to wrap them in a materialized view that precomputes the result, and Chion queries the view directly.

Chion direct-connects to Amazon RDS (including Aurora PostgreSQL-Compatible), Azure Database for PostgreSQL (Flexible and Single Server), Google Cloud SQL for PostgreSQL, Neon, and Supabase. Self-hosted PostgreSQL reachable from Chion's egress works too. PostgreSQL 12 through 17 is supported with no server-side extensions required; standard tables, views, and materialized views are profiled into the semantic layer on connect, and PG 12+ unlocks the CTE inlining the WITH-clause queries rely on. The same two-layer validation runs identically across every host.

Neither. Chion direct-connects to Postgres with a dedicated read-only role. Create the chion_read role and grant it CONNECT, USAGE, and SELECT. The anon and service_role keys are for Supabase's PostgREST API layer, not database connections, so they're not the right auth path for Chion.

Yes. RLS enforcement is database-layer, not application-layer. Chion connects as the PostgreSQL role you provide, so Supabase Row-Level Security policies apply to every query. The LLM only ever sees schema metadata and aggregated results (never raw rows), so RLS defines exactly what Chion is allowed to aggregate.

Yes. Each Neon branch is a separate endpoint, and Chion direct-connects to whichever branch you pick. Select the branch in Neon's Connect modal, copy the credentials, and Chion builds a fresh semantic layer against that branch's schema. Common pattern: point Chion at a "staging" branch for exploratory analytics, then swap to "main" for production answers; each has its own isolated credentials.

Yes. Chion's short-lived read-only SELECTs fit comfortably inside Neon's free-tier compute and storage limits. Cold-start latency adds 1 to 3 seconds to the first question after inactivity; subsequent questions return in the normal sub-3-second range. Good fit for exploration and early-stage analytics.

Yes. Aurora PostgreSQL-Compatible uses the same wire protocol as standard RDS PostgreSQL, and Chion direct-connects to either. Point Chion at the reader endpoint for optimal read-only performance: Chion only issues SELECTs, so a reader replica is the natural fit and offloads work from the writer.

Not today. Chion authenticates with a dedicated read-only PostgreSQL role and password; token auth modes (RDS IAM, Microsoft Entra ID / Azure AD, and Cloud SQL IAM database authentication) are not supported. Credentials are stored in an AES-256-GCM vault on the server, used once per socket handshake, and never cached in application memory. Create a dedicated read-only role with a strong password and grant it CONNECT, USAGE, and SELECT. IAM database authentication is on the roadmap.

Yes. Chion direct-connects to the RDS primary endpoint. No warehouse copy, no ETL replica. During a Multi-AZ failover, the endpoint DNS updates automatically and Chion reconnects transparently on the next query. The semantic layer stays intact through failover; most answers still return in under 3 seconds once the new standby is promoted.

Yes. Aurora Serverless v2 is wire-compatible with PostgreSQL, and Chion direct-connects to its endpoint. First-query latency after auto-pause is 1 to 3 seconds while ACUs scale up; subsequent queries hit the normal sub-3-second target. If predictable latency matters more than cost, raise the minimum ACU setting on the cluster so the compute never fully pauses.

Two paths, and they apply across providers. Move the instance to a public subnet or endpoint with an allow-list for Chion's egress (simplest for trial setups). Or set up VPC peering, AWS PrivateLink, Azure VPN peering, or a Cloud NAT / TCP proxy from your private subnet to a network Chion can reach (the production pattern). Either way the database still enforces the dedicated read-only role on the server side, so the enforcement boundary is identical regardless of the network path.

PostgreSQL 12 through 17, and on RDS every version it offers (currently 11 through 16). No server-side extensions required; standard tables, views, and materialized views are profiled into the semantic layer on connect. Window functions, CTE inlining, and PERCENTILE_CONT hit their full accuracy on PG 12+, so PostgreSQL 14+ is the recommended target. Chion direct-connects identically across versions.

Microsoft retired Azure Database for PostgreSQL Single Server in March 2025; migrate to Flexible Server. Chion direct-connects to either one, so the switchover is transparent: re-paste the Flexible Server connection string and the semantic layer rebuilds against the new host. Chion connects on port 5432 or through the built-in PgBouncer pooler on port 6432, with TLS 1.2+ and sslmode=require, and runs every query read-only on both.

Grant SELECT on the auth schema to your chion_read role: GRANT USAGE ON SCHEMA auth TO chion_read; GRANT SELECT ON auth.users TO chion_read. Chion then profiles auth.users into the semantic layer so plain-English questions like "how many users signed up this month?" or "activation rate by signup channel" return deterministic SQL with no guessed column names. Chion connects to your Postgres database only; Realtime, Edge Functions, and Storage are separate Supabase services it doesn't call, but anything persisted into your Postgres tables (auth.users, public.* schemas, storage.objects metadata) is queryable.

Yes. The exact SQL sits under every chart. Copy it and paste into any PostgreSQL client, BI tool, dbt model, or script. It's a standard read-only SELECT, so it runs as-is without rewriting. Built for the handoff between the person asking and the person operationalizing.

Yes. The SQL skills you build in Chion Studio export as a portable SKILL.md / Chion.md file that runs in any AI coding tool: Claude Code, Cursor, and Codex. Export the AGENTS.md mirror for Codex or use CHION.md for Cursor, both byte-identical to the file Claude Code reads; drop it at the root of your repo and the tool routes matching questions to your verified read-only queries. Same questions resolve to the same read-only queries wherever you run them. No lock-in: the skills are yours to take with you.

A SKILL.md file is a markdown file that packages one capability for an AI tool like Claude Code. Chion's SQL skills generator compiles your verified SQL into SKILL.md files, so the Claude Code skills you export run the same read-only queries anywhere.

Connect your Postgres in Chion Studio, ask and verify the questions your team cares about, then compile and download your skills as a CHION.md file plus the skills folder. Drop CHION.md at the root of your repo and Claude Code reads it on the next conversation, routing questions to the verified read-only queries inside. The file and skills folder travel with the export; your live query history, the profiled semantic layer, and the audit log stay in Chion Studio. To update, verify new questions and recompile: the compile is deterministic, so the same verified queries always produce the same file and you can diff it across releases. No new SQL is generated against your database; it runs the queries your team already trusted.

They are byte-identical mirrors of the same compiled agent, named for the tool that reads them. Claude Code reads CLAUDE.md natively, Codex reads AGENTS.md, Cursor reads either, and SKILL.md packages a single capability. CHION.md is the root file Chion generates; the others are the same content under the filename each tool expects. Same brain, four idiomatic addresses, so you pick the filename your agent prefers.

A persona is a role, like finance, ops, or growth. Chion compiles one agent file per persona, scoped to the verified queries and trigger keywords that role uses, so the finance agent answers finance questions and the ops agent answers ops questions. The same database can produce different agent files for different personas, which is how a team shares one Postgres connection but each person gets the skills that fit their work.

A verified query is one your team ran in Chion Studio with the exact read-only SQL visible beneath the chart, reviewed, and accepted. Every verified query becomes a candidate skill, tagged by persona and ranked by how often it is reused. When you compile, the high-confidence queries promote into the agent file, each carrying a citation back to the query that proved it. Nothing is invented; the skill is the SQL your team already trusts.

Every line in a compiled CHION.md carries a citation back to the verified query that produced it, so you can trace any skill to the exact SQL your team ran and approved. This is the SQL traceability that travels with the file: it lets a reviewer confirm where each answer comes from. The live audit log of who ran what and when stays in Chion Studio; the file carries the source-query trail.

An MCP server hands the model raw access to your database schema and lets it write fresh SQL each turn, which is powerful for exploration but can hallucinate joins or columns. A CHION.md routes questions to verified, read-only queries your team already curated, so answers are deterministic and auditable. You can use both: MCP for ad-hoc schema exploration, CHION.md for the analytics you need to trust and repeat. Chion also exports to Claude, ChatGPT, and Gemini via MCP.

Yes. The exported CHION.md and skills folder are yours to keep, and they run in Claude Code, Codex, or Cursor against your own read-only database role without an active Chion subscription. You only need Chion Studio when you want to add new verified queries, recompile a persona, or refresh the semantic layer after a schema change. The skills you have already compiled stay portable and keep working.

Yes, through MCP. Beyond the file export for coding tools, your skills connect to Claude, ChatGPT, and Gemini over MCP, and to local LLMs that support skills. The same verified read-only queries answer in whichever model you choose, which is what makes the library LLM-agnostic: switch models or tools anytime and the analytics logic stays yours, not locked to any single vendor.

Yes. Chion is read-only by design. Every query is a SELECT, never INSERT, UPDATE, DELETE, or DROP, blocked by the L1 validator in code, not by LLM instruction, and an L2 lint enforces LIMIT and rejects SELECT * or invalid JOINs before execution. Credentials are AES-256-GCM encrypted in a vault, loaded once for the socket handshake over sslmode=require, and purged immediately. PostgreSQL Row-Level Security is enforced on every query, the AI model sees only schema metadata and aggregated results, never raw rows, and results are capped at 1,000 rows / 12,000 cells. Every access event is audit-logged.

Yes, every query is a read-only SELECT enforced in code (not the prompt), with credentials in an AES-256-GCM vault. Full security model on the Trust Center.

No. The LLM sees only schema metadata and controlled column summaries, never raw rows. The model proposes SQL; your database executes it; only the aggregated results of the SELECT you asked for leave your database, hard-capped at 1,000 rows / 12,000 cells. Results are rendered server-side and discarded when the session ends, and raw row-level data is never sent to LLM providers.

No, and never, not only in the demo. Chion is read-only: it cannot INSERT, UPDATE, DELETE, or DROP. Any non-SELECT is rejected in code by the L1 read-only validator before it reaches your database, not by LLM instruction. The full three-layer read-only enforcement model is on the Trust Center.

No. Chion runs on Anthropic Claude via paid commercial API tiers, and those provider terms explicitly prohibit training on customer inputs. The architecture is model-agnostic: OpenAI and Google are available on request, and on-premise deployment is on the roadmap under the same commercial terms. Raw row data never reaches any model regardless of provider.

No. Chion will never sell, license, rent, or share your data or metadata with any third party. Revenue comes from the per-team subscription plans. There is no advertising business model, no data brokerage, no secondary monetization.

Only you, under your authenticated session. Every Chion table uses PostgreSQL Row-Level Security: one customer's queries and data cannot be read by another, enforced at the database layer not the application layer. Every access event is logged to a write-only compliance log. Deterministic isolation, fail-closed on any invariant violation.

Not today. Chion is a pre-seed startup; formal third-party audits (SOC 2, ISO 27001, pen test) are not yet scoped. The security controls already shipped in code are documented on the Trust Center.

Chion processes only structural schema metadata and aggregated query results. Personal data leaves your database only when your own question asks for it, under your connected role's permissions. A formal GDPR program (DPA, Article 28 sub-processor disclosures, representative) is not yet scoped; enterprise customers can request a DPA on contact.

Email contact@chion.ai with a description of the issue, reproduction steps, and any affected endpoints. We respond within one business day. Do not publicly disclose the vulnerability until we have confirmed remediation.

Verification is deterministic, not probabilistic. Four phases: schema alignment against the profiled catalog, contract enforcement on columns and joins, an L1 read-only SELECT check, and an L2 lint for LIMIT, SELECT *, and JOIN validity. Invalid queries are rejected before they reach your database, and all queries are capped at 1,000 rows / 12,000 cells. Same question, same data, same outcome.

Yes. One-click deletion in Settings removes account info, your question history, generated SQL, schema metadata, and the pgvector embeddings that powered the semantic layer. Two categories are retained by law: billing records (7 years for tax compliance) and email delivery records (24 months, operational). Everything else is user-deletable, no retention trick.

Chion stores account info, your natural-language questions, the SQL it generated, structural schema metadata, and small category-label samples (the semantic-layer inputs), all in tenant-isolated Supabase Postgres (US) with Row-Level Security enforcing cross-tenant isolation. Chion itself runs on Supabase Postgres, Auth, Edge Functions, and Vault, so your database credentials are encrypted at rest with AES-256-GCM in Supabase Vault and loaded into memory only for the socket handshake (Load-Consume-Purge). Raw rows from your database stay in your database; query results are session-only and discarded when the session ends, never copied or persisted by Chion.

Encrypted with AES-256-GCM in a server-side vault, loaded into memory only for the socket handshake and purged immediately, never logged, never written to disk, and never returned in API responses. (Terms §3.3, §8.1)

Disconnection purges the semantic layer for that source: all profiled metadata, pgvector embeddings, and column samples are deleted. Query results are session-only and discarded when the session ends, and conversation history is deleted on account deletion, with no hidden retention and no background copies. Stored data is deleted within 30 days of termination, or sooner on request; billing records are retained for 7 years per tax requirements. (Terms §4.7, §15.3)

No. Chion does not support HIPAA-covered workloads. Do not connect databases containing protected health information (PHI). Processing PHI through the Service requires a separately executed Business Associate Agreement, which Chion does not offer today. (§6.10)