How Chion works, what it costs, and what you can export

Chion is an AI analytics platform for PostgreSQL that turns plain-English questions into read-only SQL, code-validated before it runs, with interactive D3 charts. You connect a database in Chion Studio, ask in plain English, and get a code-validated read-only SELECT 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 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.

You ask in plain English and get a chart with an explanation, then follow up while Chion carries the earlier turns forward. It direct-connects to your Postgres, so there is no dashboard to author first and no ticket sitting in an analyst queue, and each answer carries the SQL underneath it 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.

Two code validators check the statement before it runs, and you read the executed SQL underneath the chart it produced. Every number traces to that query, and you can copy it into your own client and run it against the same role.

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. Managed cloud is what ships today; dedicated GPU compute and on-premise model hosting are Enterprise roadmap items discussed under contract.

Managed cloud today. Dedicated GPU compute and on-premise model hosting are Enterprise roadmap items discussed under contract. The two-layer SQL validation and the AES-256-GCM credential vault are the same code path in every environment.

No. Ask in plain English and Chion writes the code-validated 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. Chion runs as managed cloud today; dedicated GPU compute and on-premise model hosting are Enterprise roadmap items discussed under contract.

A dashboard shows the views someone configured in advance, and a question outside them goes back into a queue. Chion answers against the live schema instead: you ask, you get the chart, and the SELECT that produced it sits underneath so you can read the logic. A team that still runs dashboards can paste that SELECT straight 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 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 code-validated SQL query plus an interactive chart. 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 applies the row-level security policies attached to the role you supply. The model receives your table and column names, the rows your query returned for the narrative, and sampled column values.

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 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 code-validated 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 while you ask your first question, 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 46-second connect and ask demo runs against a PostgreSQL fixture; on the trial the same pipeline runs against your own schema.

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 grounds the generator in your real tables and columns, and you can export it to run the same agent in Claude Code 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. The monthly allotment is credits, not questions: 50 on Starter, 250 on Pro, 750 on Max, unlimited on Enterprise. 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.

Chion starts at $29 per seat per month on Starter, metered in monthly credits, with a 7-day trial and cancellation at any time. Schema questions do not consume credits on any plan, and every plan runs the same code-validated read-only execution path, so the plan you pick is a volume decision rather than a capability one.

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 the account moves to read-only, and data retention is governed by section 4.7 of the Terms of Service.

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.

Fees are non-refundable except as required by applicable law, which is what the Terms of Service say. Cancel anytime and you keep access through the end of the cycle you already paid for. The 7-day trial is there to run the pipeline on your own schema before any charge, and all payments run through Stripe.

Chion does not charge per query. 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 validation: 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 while you ask your first question, so the generated SQL references your actual tables and columns, not guesses. No ETL, no warehouse copy.

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 broader privileges would grant capabilities Chion cannot use. Grant only what you want Chion to see; the Row-Level Security policies attached to the role you supply are honored on every query.

Yes. Replicas are the natural target. Chion only issues read-only SELECTs, so a replica endpoint fits: no write path, and the scan load stays off the primary. 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 model receives your table and column names, the rows your query returned for the narrative, and sampled column values, so those policies decide what can be read in the first place.

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; later questions skip that wait. 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. Plaintext is decrypted into memory for a single request, held for at most 60 seconds or five reads, then purged. 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; later queries skip that wait. 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. A query you save and review compiles into a portable SQL skill for Claude Code and Codex. The bundle ships CHION.md, CONNECT.md, and a skills/ folder holding one SKILL.md per role. CHION.md carries the seven Layer 1 rules in full; each SKILL.md inlines the seven-line quick reference. You activate it with a move or a symlink: skills/ goes into the directory your tool reads, which is .claude/skills/ for Claude Code. From there the tool routes a matching question to your saved query. Renaming CHION.md to CLAUDE.md or AGENTS.md is a host convention you adopt, not something the compiler writes. No lock-in: the compiled files 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 the SQL your team saved into SKILL.md files, one per role, so Claude Code and Codex CLI run the same read-only queries.

Connect your Postgres in Chion Studio, ask the questions your team cares about, save the ones a reviewer accepts, then compile and download your skills as a CHION.md file plus the skills folder. Claude Code reads CLAUDE.md at a repo root, so rename or symlink CHION.md to CLAUDE.md and move the skills folder to .claude/skills/. On the next conversation the agent picks both up and anchors a matching question on the saved read-only query that owns it, instead of writing one from the raw schema. 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, save new questions and recompile: the slot-filling pass runs at temperature 0, so the same saved queries produce the same file structure and you can diff it across releases.

Chion compiles only one of those three. SKILL.md is the per-role file, one folder per role under skills/. It inlines the seven Layer 1 rules as a seven-line quick reference, next to that role's trigger keywords and saved scripts. The full rule text lives in CHION.md at the workspace root. CLAUDE.md and AGENTS.md are host conventions, not compiler output. Claude Code reads CLAUDE.md at a repo root and Codex reads AGENTS.md, so rename or symlink CHION.md to whichever your tool expects.

A role is an archetype like finance-analyst or product-analytics. Each export compiles one role today.

A saved query is one your team ran in Chion Studio with the exact read-only SQL visible beneath the chart, reviewed, and accepted. Every saved query becomes a candidate skill, tagged by role and ranked by how often it is reused. When you compile, the high-confidence queries land in the agent file, each carrying a [src=] tag back to the query that proved it, and anything the compiler could not source is marked for review. The skill is the SQL your team already read, not a fresh guess.

Slot bodies in a compiled CHION.md carry a [src=] tag back to the saved query that produced them, and anything the compiler could not source is marked for review, so a reviewer can tell evidence from inference. This is the SQL traceability that travels with the file. 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 anchors a question on the saved read-only queries your team already curated, so the model writes against reviewed logic instead of the raw schema and the source query stays inspectable. 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 Markdown files on your disk, and section 5.2 of the Terms of Service gives you ownership of the output Chion generates for you. They read back through Claude Code or Codex against your own read-only database role. You need an active subscription to save new queries, recompile a role, or refresh the semantic layer after a schema change. A file compiled before a schema change is not re-validated against the new schema, so check it after your tables move.

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 saved 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.

Read-only removes the write risk, not every risk. Every statement is a SELECT, rejected in code by the L1 validator if it is not, and results are capped at 1,000 rows or 12,000 cells. Read-only does not stop an expensive scan, a sensitive read the connected role can reach, or prompt injection. RLS applies as the policies attached to the role you supply. The model receives your table and column names, the rows your query returned for the narrative, and sampled column values.

Read-only removes the write risk, not every risk. Every statement is a SELECT enforced in code rather than in the prompt, credentials sit in an AES-256-GCM vault, and results stop at 1,000 rows or 12,000 cells. It does not stop an expensive scan, a sensitive read the connected role can reach, or prompt injection, so scope the role to what you are willing to expose. Full security model on the Trust Center.

It sees some of them. The model receives your table and column names, the rows your query returned for the narrative, and sampled column values used to match your wording to your columns. Your database executes the SELECT, the result stops at 1,000 rows or 12,000 cells, and it renders server-side and is discarded when the session ends. Scope the read-only role to what you are willing to sample.

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 under the same commercial terms, and on-premise model hosting is an Enterprise roadmap item discussed under contract. Whichever provider runs, the model receives your table and column names, the rows your query returned for the narrative, and sampled column values.

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. Chion's own tables carry PostgreSQL Row-Level Security scoped to your authenticated session. Access events are written to an audit table fire-and-forget: the write is best-effort and never blocks the response, so treat it as a signal, not a complete ledger.

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 your table and column names, sampled column values, and the rows your query returned. Personal data leaves your database when your own question asks for it, under the permissions of the role you connected. 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. It reaches the founder directly. Chion does not publish a response-time commitment yet, so say in the subject line if it is time-sensitive. Do not publicly disclose the vulnerability until we have confirmed remediation.

Validation 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, and Edge Functions, and your database password is sealed in an AES-256-GCM envelope. Plaintext is decrypted into memory for a single request, held for at most 60 seconds or five reads, then purged. 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. Plaintext is decrypted into memory for a single request, held for at most 60 seconds or five reads, then purged. Credentials are 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)