# AI Disclosure Source: https://docs.critique-labs.ai/ai-disclosure How Critique AI uses artificial intelligence, what it does and does not do, and how customer content is handled # AI Disclosure **Last Updated:** August 5, 2026 Critique AI provides a document-grounded assistant designed to help you work with your own materials. This page explains what the assistant does, what it does not do, and how we handle your content. It supplements our [Terms of Service](/terms-of-service) and [Privacy Policy](/privacy-policy). ## What the Assistant Does The assistant retrieves information from your documents and related sources to produce grounded answers with citations. Quoted passages are checked against the source. Claims that cannot be supported are flagged rather than invented. ## What It Does Not Do The assistant does **not**: 1. Guarantee correctness of every answer 2. Provide professional advice (legal, engineering, zoning, medical, financial, or otherwise) 3. Replace human judgment Outputs are probabilistic and may contain errors. Citations, quote verification, and abstention reduce but do not eliminate that risk. **Material decisions require human review** before you rely on or republish an output. ## Model Providers We use frontier models via Anthropic and OpenAI enterprise APIs. We do not publish specific model names; naming a particular model publicly would create an availability obligation we do not make. Under those enterprise API terms, API inputs and outputs are not used by the providers to train their shared models. ## Customer Content and Training **Customer content is never used to train shared or public models.** Anonymous demo uploads on chat.critique-labs.ai are session-only, deleted at session end, and never used for training. See our [Privacy Policy](/privacy-policy) for collection, subprocessors, retention, and security details. ## Your Responsibility You own your documents, prompts, and submitted content. You are responsible for having the rights to upload that content and for reviewing outputs before acting on them. Decisions remain with you. ## Contact Questions about this disclosure: [support@critique-labs.ai](mailto:support@critique-labs.ai) # Build agentic search endpoints with an agent Source: https://docs.critique-labs.ai/api-platform/agent-created-apis Turn one research task into a fully functioning, hosted search endpoint with structured output and cited sources Critique API is the all-in-one agentic search endpoint builder. Give a coding agent one natural-language research task and it can create a fully functioning, hosted endpoint with live web search, source retrieval, citations, structured JSON, and a callable contract. Critique handles the search crawler, retrieval pipeline, model workflow, structured-output layer, and endpoint deployment. The agent creates the endpoint, reads the server-returned schemas and examples, calls it immediately, and integrates it into your project with ordinary HTTPS. ## Set up your agent Create a key under [Billing & API Keys](https://critique-labs.ai/en/billing), then make it available to your coding agent as an environment variable. ```bash theme={null} export CRITIQUE_API_KEY="your-api-key" ``` Never paste the key into a prompt, source file, URL, or commit. Open [API Studio](https://critique-labs.ai/en/design) and select **Set up an agent** beside the manual API description form. * **Copy prompt** copies the current, server-provided integration prompt (select **Show prompt** to read it before copying). Paste it into any agent chat; it works without installing anything. * **Copy & open ChatGPT** or **Copy & open Claude** copies the prompt and opens a new chat. * **Use it in Claude Code, Cursor or Codex** shows, per tool, the one-line install (`npx skills add …` or the Claude Code plugin commands) and how to invoke the skill. * **Documentation your agent can read** links the LLM documentation index, the full-documentation bundle, this guide, and the OpenAPI contract. A browser chat can help plan the endpoint, but it still needs a connected tool or coding environment that can read `CRITIQUE_API_KEY` and make HTTPS requests in order to create or run one. Describe the reusable behavior, required inputs, exact output fields, freshness requirements, and preferred sources. For example: > Create a private API that accepts a company name and returns its latest > funding round, amount, date, investors, and primary-source URLs. Then show > me how to call it from this project. ## Use the skill without a CLI The skill works through ordinary authenticated HTTPS requests. It can use `curl`, JavaScript `fetch`, an IDE HTTP tool, or the existing HTTP client in any project language. Python and the Critique CLI are not required. The agent reads the lifecycle contract from the skill, sends `X-API-Key: $CRITIQUE_API_KEY`, and uses the `integration` object returned by the server as the source of truth for running the new endpoint. ## Install the CLI (optional) The optional, open-source CLI package is `critique-api-cli` and has no third-party runtime dependencies. Its source is available on [GitHub](https://github.com/parthh01/critique-api-cli). ```bash theme={null} pipx install critique-api-cli critique-api --help ``` The CLI is a standalone convenience for terminal workflows. It does not need to be installed into the user's application or added to that project's dependencies. After setting `CRITIQUE_API_KEY`: ```bash theme={null} critique-api create \ --prompt "For a company name, return its latest funding round, investors, date, amount, and primary-source citations." ``` ## Install the skill The skill lives in the public [`parthh01/critique-api-cli`](https://github.com/parthh01/critique-api-cli) repository. Install it into Claude Code, Cursor, Codex or any other agent supported by [skills.sh](https://skills.sh) with one command (it writes the skill into each tool's own skills directory; add `-g` to install for all projects instead of the current one): ```bash theme={null} npx skills add parthh01/critique-api-cli -y ``` Or install it as a Claude Code plugin from the repo's marketplace: ```text theme={null} /plugin marketplace add parthh01/critique-api-cli /plugin install critique@critique-labs ``` | Tool | Install | Invoke | | ----------- | ------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- | | Claude Code | the two `/plugin` commands above, or `npx skills add parthh01/critique-api-cli -a claude-code -y` | `/critique:create-critique-apis` (plugin) or `/create-critique-apis` (skill) | | Cursor | `npx skills add parthh01/critique-api-cli -a cursor -y` | Type `/` in Agent chat and pick the skill | | Codex | `npx skills add parthh01/critique-api-cli -a codex -y` | `$create-critique-apis` | Each tool also applies the skill automatically when a task matches its description. Make sure `CRITIQUE_API_KEY` is exported in the shell the agent runs in. The integration prompt, these per-tool commands (`clients`), and the resource URLs are also available without authentication for automated discovery; the raw skill files remain downloadable as a zip for agents that fetch them directly: ```bash theme={null} curl --fail-with-body https://api.critique-labs.ai/v1/agent-integration ``` ## Documentation for agents This documentation is written to be read by LLMs as well as people: * [`llms.txt`](https://docs.critique-labs.ai/llms.txt) is the index of every page. Agents should fetch it first when they need something a prompt does not cover. * Every page is available as Markdown: append `.md` to a page URL that does not already end in `.md` (this page is `https://docs.critique-labs.ai/api-platform/agent-created-apis.md`). * [`llms-full.txt`](https://docs.critique-labs.ai/llms-full.txt) bundles every page into one file, each prefixed with a `Source:` line, for a single fetch. * [`openapi.json`](https://api.critique-labs.ai/openapi.json) is the machine-readable contract for every endpoint. ## Endpoint lifecycle All management and runtime requests use the `X-API-Key` header. These examples assume `CRITIQUE_API_KEY` is set in the environment. ### Create The only required create field is `original_prompt`. ```bash theme={null} curl --fail-with-body --request POST \ https://api.critique-labs.ai/v1/design-api \ --header "Content-Type: application/json" \ --header "X-API-Key: $CRITIQUE_API_KEY" \ --data '{ "original_prompt": "For a company name, return its latest funding round, investors, date, amount, and primary-source citations." }' ``` The response is wrapped in `response`. Treat `response.integration` as the authoritative handoff: it contains the final callable URL, authentication contract, request and response JSON Schemas, an example request, runnable code, and a short agent handoff. ```json theme={null} { "response": { "id": 42, "api_name": "Latest company funding", "stub": "latest-company-funding", "inputs": [{ "name": "company", "type": "string" }], "output_format": { "company": "string", "amount": "number", "date": "string", "investors": [{ "name": "string" }] }, "integration": { "method": "POST", "url": "https://api.critique-labs.ai/v1/user-defined-service/latest-company-funding", "request_schema": {}, "response_schema": {}, "example_request": { "company": "" }, "code": { "curl": "...", "python": "...", "javascript": "..." }, "agent_handoff": "..." } } } ``` Do not construct the runtime URL from the stub when an `integration.url` is available. The server-returned integration object is the source of truth. ### Inspect and modify ```bash theme={null} # List your private endpoints curl --fail-with-body \ --header "X-API-Key: $CRITIQUE_API_KEY" \ https://api.critique-labs.ai/v1/design-api # Inspect one endpoint curl --fail-with-body \ --header "X-API-Key: $CRITIQUE_API_KEY" \ https://api.critique-labs.ai/v1/design-api/42 # Send only the fields that should change curl --fail-with-body --request PATCH \ https://api.critique-labs.ai/v1/design-api/42 \ --header "Content-Type: application/json" \ --header "X-API-Key: $CRITIQUE_API_KEY" \ --data '{ "inputs": [ { "name": "company", "type": "string", "required": true, "default": null }, { "name": "region", "type": "string", "required": false, "default": null }, { "name": "max_results", "type": "number", "required": false, "default": 10 } ], "output_format": { "company": "string", "amount": "number", "announced": "boolean", "investors": [{ "name": "string" }] } }' ``` Input names must begin with a letter or underscore and may contain letters, numbers, and underscores. Supported input types are `string`, `number`, and `boolean`. Output formats support nested objects and one-item array schemas in addition to `string`, `number`, `boolean`, and `integer` values. #### Optional inputs and defaults Each input carries `required` (default `true`) and `default` (default `null`). Inputs created before these keys existed are required with no default, and nothing about them changed. * A non-null `default` must match the input's `type` and makes the input optional whatever `required` says. * Callers may omit any optional input (sending `null` counts as omitting it). The endpoint fills in the default, or, when the default is `null`, tells the agent the value was not provided. * A missing required input responds `400`; the message lists only the missing required fields, with optional ones shown as `name?: type`. * `integration.request_schema` marks only required inputs as required and carries each default; `integration.example_request` and the code samples include every required input plus every optional input that has a default. `max_results` is a reserved input name. An endpoint whose output contains a list is created with an optional `max_results` (type `number`, default `10`); the runtime asks the agent for at most that many items and caps every top-level list field of the response at that value (nested lists are left to the agent). The value must be a number of at least 1 and is floored to an integer. ### Versions Every endpoint version is its own resource with its own `id`; all versions share the endpoint's `stub`. A version is a **draft** while `frozen_at` is `null` (editable; at most one per endpoint) and **released** once `frozen_at` is set (immutable; edits respond `409`). The **live** version is what the unversioned URL `/v1/user-defined-service/{stub}` runs: the released version with the highest number, or the only draft when nothing has ever been released, which is the normal state of a freshly created endpoint. Every response carries `version`, `frozen_at`, `is_live`, `live_version` and a `versions` list for the whole lineage. ```bash theme={null} # Release the current draft: it becomes immutable and live curl --fail-with-body --request POST \ --header "X-API-Key: $CRITIQUE_API_KEY" \ https://api.critique-labs.ai/v1/design-api/42/release # Create the next version: copies v42 into a new editable draft curl --fail-with-body --request POST \ https://api.critique-labs.ai/v1/design-api/42/versions \ --header "Content-Type: application/json" \ --header "X-API-Key: $CRITIQUE_API_KEY" \ --data '{"version_notes": "added the funding_stage output field"}' # List the lineage; add ?all_versions=true to GET /v1/design-api for every version curl --fail-with-body \ --header "X-API-Key: $CRITIQUE_API_KEY" \ https://api.critique-labs.ai/v1/design-api/42/versions ``` If the version you copy is the current draft it is released first, so callers on the unversioned URL keep the behaviour they tested. Creating a version while another unreleased draft exists responds `409`: release or delete that draft first. Publishing a version to the marketplace also releases it. Creating a version from an older released one is how you revert; the copy becomes live once you release it. Always call `integration.url`. For the live version it is the unversioned URL; for a draft that is not live, and for an older release, it is the pinned URL `/v1/user-defined-service/{stub}/v{n}`, the only URL that runs that version. `integration.versioned_url` is always the pinned URL. A pinned version that does not exist responds `404`. ### Run POST a body matching `integration.request_schema` to `integration.url`: ```bash theme={null} curl --fail-with-body --request POST \ https://api.critique-labs.ai/v1/user-defined-service/latest-company-funding \ --header "Content-Type: application/json" \ --header "X-API-Key: $CRITIQUE_API_KEY" \ --data '{ "company": "OpenAI" }' ``` A successful runtime response contains the structured result, its source list, and usage information: ```json theme={null} { "response": { "company": "OpenAI", "amount": 6600000000, "date": "2024-10-02", "investors": [{ "name": "Thrive Capital" }] }, "context": [ { "id": 1, "metadata": { "title": "Source title", "url": "https://example.com/source", "content": "Relevant source content" } } ], "info": { "token_usage": 123 } } ``` Preserve `context` when displaying or storing researched output so its source URLs remain available to users. ### Delete Deletion is permanent. Confirm the endpoint ID before calling: ```bash theme={null} curl --fail-with-body --request DELETE \ --header "X-API-Key: $CRITIQUE_API_KEY" \ https://api.critique-labs.ai/v1/design-api/42 ``` ## Optional domain controls Runtime bodies may include `include_domains` or `exclude_domains` as an array of domain strings. They are mutually exclusive. ```json theme={null} { "company": "OpenAI", "include_domains": ["openai.com", "sec.gov"] } ``` ## Error handling * `400` or `422`: correct the request or schema; do not retry unchanged. * `401`: verify that `CRITIQUE_API_KEY` is available without printing it. * `404`: list endpoints and confirm that the ID belongs to the current key. On a `/v{n}` invocation, confirm the version exists with `GET /v1/design-api/{id}/versions`. * `409`: the version is released (immutable) or the endpoint already has an unreleased draft. Create or release a version instead of retrying. * `429`: respect the rate limit before retrying. * `504`: the research request exceeded the service deadline. See [API rate limits](/api-reference/rate-limits) for current plan limits. # API Studio Source: https://docs.critique-labs.ai/api-platform/api-studio Create, test, and integrate a private API from the browser ## Overview API Studio turns a natural-language description into a private, callable research endpoint. The manual builder is available at [critique-labs.ai/en/design](https://critique-labs.ai/en/design). If you want a coding agent to create and integrate the endpoint for you, select **Set up an agent** beside the API description form. You can copy the setup prompt, open it in ChatGPT or Claude, or follow the per-tool steps for Claude Code, Cursor, and Codex to install the downloadable skill package. The manual builder and agent workflow create the same kind of private API. Endpoints created by an agent appear under **Saved designs** in API Studio. ## Creating an API Write a natural language description of your desired API functionality: * Purpose and use cases * Required inputs and exact output fields * Research behavior and preferred sources * How to handle missing or conflicting information Customize your API configuration: * Input request format * Output response format * Detailed API instructions Test your API with sample requests and responses: * Enter an input request * View the output response * Review the returned source context * Revise API instructions if needed In the **Run** step, copy the endpoint URL, request schema, example payload, or generated JavaScript, Python, and cURL code. Keep the API key in the `CRITIQUE_API_KEY` environment variable. ## Versions Every saved API is versioned. The Studio header shows the version you are editing (`v1`, `v2`, ...) and its state: * **Live**: the version the unversioned endpoint URL runs. A freshly created API is live and still editable, so edits go live immediately until you release it. * **Released**: immutable. Select **Release** to lock a version in; from then on the unversioned URL runs the newest released version. * **Draft**: an editable working copy that is not live, created with **New version** after a release. It runs only at its pinned `/v{n}` URL until you release it. Select **New version** to copy the current version into a new draft (if the current version is the draft, it is released first). An API can have only one draft at a time. Publishing a version to the marketplace also releases it, and older versions stay callable at their pinned URLs. The **Run** step always shows the URL that runs the version you are looking at. ## Build with an agent See [Build APIs with an agent](/api-platform/agent-created-apis) for setup, endpoint lifecycle commands, and the runtime response contract. ## Best Practices ### Writing Descriptions * Be specific about functionality * Name every required input * Define the exact output shape and value types * State freshness and source requirements * Explain how to represent missing information ### Testing * Validate all endpoints * Test edge cases * Check error responses * Verify rate limits ## Pricing * **\$0.50 per million tokens** (including internal processing tokens). * Rate limits exist for the free and pro tiers. See [API rate limits](/api-reference/rate-limits) and the [pricing page](https://critique-labs.ai/en/pricing) for details. Use the **API Reference** navigation to inspect the complete HTTP specification. # Example API Integration Guide Source: https://docs.critique-labs.ai/api-platform/consuming Learn how to integrate the Example API into your application ## Getting Started with Example API This guide will walk you through integrating our Example API into your application. This API allows you to fetch and analyze data programmatically. ### Prerequisites * An API key from the Critique AI marketplace * Basic knowledge of JavaScript/HTTP requests * A development environment set up ## Step-by-Step Integration ### 1. Authentication Setup First, you'll need to include your API key in the request headers: ```javascript theme={null} const headers = { 'Content-Type': 'application/json', 'X-API-KEY': 'your-api-key-here' }; ``` Never expose your API key in client-side code. Always store it securely in environment variables or a secure configuration system. ### 2. Making API Requests Here's a complete example of how to fetch data: ```javascript theme={null} async function fetchData(input) { const url = "https://api.critique-labs.ai/v1/published-service/example-api"; const requestData = { "input": input // Your input parameter }; try { const response = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json', 'X-API-Key': process.env.CRITIQUE_API_KEY }, body: JSON.stringify(requestData) }); const data = await response.json(); if (data.error) { throw new Error(data.error); } return { formattedOutput: data.response, sources: data.context }; } catch (error) { console.error("Error fetching data:", error); throw error; } } ``` ### 3. Handling the Response The API returns two main components: 1. `response`: The formatted output data 2. `context`: Source information and metadata ```javascript theme={null} // Example usage try { const result = await fetchData("example-input"); console.log("Data:", result.formattedOutput); console.log("Sources:", result.sources); } catch (error) { // Handle any errors } ``` ## Response Format The API returns data in the following structure: ```javascript theme={null} { "response": { // Formatted output data }, "context": { // Source information and metadata } } ``` ## Best Practices 1. **Rate Limiting** * Remember, while your balance is 0, your rate limit is *10 requests per minute*. When you add credits, your rate limit will increase to 100 requests per minute. See [API rate limits](/api-reference/rate-limits) for peak throttling, fair use, and full details. * Implement proper rate limiting in your application * Cache responses when possible * Use batch requests when available 2. **Error Handling** * Always implement robust error handling * Provide meaningful error messages to users * Log errors for debugging 3. **Security** * Store API keys securely * Use environment variables * Implement proper access controls ## Example Implementation Here's a complete example using async/await and proper error handling: ```javascript theme={null} require('dotenv').config(); // For loading environment variables class APIService { constructor(apiKey) { this.apiKey = apiKey; this.baseUrl = "https://api.critique-labs.ai/v1/published-service/example-api"; } async getData(input) { try { const result = await this.makeRequest(input); return this.processResponse(result); } catch (error) { this.handleError(error); } } async makeRequest(input) { const response = await fetch(this.baseUrl, { method: 'POST', headers: { 'Content-Type': 'application/json', 'X-API-Key': this.apiKey }, body: JSON.stringify({ input }) }); return response.json(); } processResponse(data) { if (data.error) { throw new Error(data.error); } return { outputData: data.response, sources: data.context }; } handleError(error) { // Implement your error handling logic console.error("API Error:", error); throw error; } } // Usage const apiService = new APIService(process.env.CRITIQUE_API_KEY); apiService.getData("example-input") .then(data => console.log(data)) .catch(error => console.error(error)); ``` ## Need Help? If you encounter any issues or need support: * Check our [API Documentation](/api-docs) * Visit our [Support Portal](/support) * Contact us at [api-support@critique-labs.ai](mailto:api-support@critique-labs.ai) Remember to replace placeholder values with your actual API credentials and endpoints. ``` ``` # API Marketplace Source: https://docs.critique-labs.ai/api-platform/marketplace Browse and discover APIs from the Critique AI community ## Overview The Critique AI Marketplace is your hub for discovering and integrating community-created APIs. This guide will help you navigate and make the most of the marketplace features. ## Browsing the Marketplace ### Search and Filters The marketplace offers powerful search and filtering capabilities to help you find the right APIs: Search APIs by title or description to quickly find what you need Filter APIs by: * Number of active users * API call volume * Response latency * Categories ## How it works Once you design an API, you can publish it to the **marketplace**, where others can utilize and pay for them. The pricing model is **token-based**: * **Revenue sharing**: API publishers earn **\$0.05 per million tokens** used by paid consumers. # API Platform Overview Source: https://docs.critique-labs.ai/api-platform/overview Turn a research use case into a fully functioning, hosted agentic-search endpoint ## All-in-one agentic search endpoints Describe a research use case and Critique returns a fully functioning, hosted endpoint with live web search, source retrieval, citations, structured JSON, and a callable contract. You do not need to build or operate the crawler, retrieval pipeline, model workflow, structured-output layer, or deployment. Unlike conventional API providers that focus on simple data storage and retrieval, Critique AI’s agentic API builder allows for: * **Dynamic, intelligent processing** using agentic search capabilities. * **Automated multi-step reasoning and execution**, adapting to the complexity of each request. * **Composable API design**, where users can build and monetize their own AI-driven endpoints on the marketplace. For a deep dive into how the API platform works, read our blog post: [What is Agentic Search](https://critiquebrowser.app/en/blog/What-Is-Agentic-Search). ## Key Components Create and deploy APIs using natural language prompts Discover and integrate public APIs from other creators Share your APIs and earn from their usage Easily integrate APIs into your applications ## How It Works Describe your API's functionality using natural language Our platform uses a multi agent system instantiated as a DAG to create a production-ready API that is deployed and ready to use. Publish your API to the marketplace and earn revenue from its (paid) usage. # API Platform Privacy Policy Source: https://docs.critique-labs.ai/api-platform/privacy-policy Privacy policy for the Critique AI API Platform This Privacy Policy describes how we collect, use, and handle your information when you use our API Platform services. By using our services, you agree to the collection and use of information in accordance with this policy. ## Data Collection ### Platform Data We collect information necessary to provide and improve our services, including: 1. Account Information: When you register for our service, we collect your email address, name, and organization details to create and manage your account. 2. Usage Information: We automatically collect data about how you interact with our platform, including API calls, request patterns, and service utilization metrics. 3. Payment Information: For paid services, we collect billing details and maintain records of transactions. Credit card information is processed by secure third-party payment processors and is not stored on our servers. 4. Technical Data: We collect IP addresses, browser information, device identifiers, and other technical data necessary for service operation and security. ### API Data In the course of providing our services, we collect: 1. Request and Response Data: Information about API calls, including timestamps, endpoints accessed, and response status. 2. Performance Metrics: Technical data about API performance, latency, and reliability. 3. Error Information: Data about failed requests and system errors to maintain service quality. ## Data Usage and Processing We use the collected information for the following purposes: 1. To provide, maintain, and improve our services 2. To process your transactions and manage your account 3. To detect and prevent fraud, abuse, and security breaches 4. To analyze service performance and optimize our systems 5. To communicate with you about service-related matters 6. To comply with legal obligations ### Data Analysis and Service Improvement We collect anonymous performance metrics and usage patterns solely to improve our services. This data is: 1. Stripped of all personally identifiable information 2. Aggregated and analyzed in bulk 3. Used exclusively for service optimization and enhancement 4. Never sold or shared with third parties for marketing purposes ## Data Protection ### Security Measures We implement appropriate technical and organizational measures to protect your data, including: 1. Industry-standard encryption for data in transit and at rest 2. Access controls and authentication requirements 3. Regular security assessments and monitoring 4. Incident response procedures ### Your Rights You have the right to: 1. Access your personal data 2. Request correction of inaccurate data 3. Request deletion of your data 4. Export your data in a machine-readable format 5. Object to certain data processing activities 6. Withdraw consent where processing is based on consent ## Data Sharing and Third Parties We do not sell your personal information or API usage data to third parties. We may share your information only in the following circumstances: 1. With your explicit consent 2. To comply with legal obligations 3. To protect our rights, privacy, safety, or property 4. In connection with a business transfer or merger 5. With service providers who assist in our operations, subject to strict confidentiality obligations ## Data Retention We retain your information for as long as necessary to provide our services and comply with legal obligations. Audit and query event logs are retained for 12 months. Documents and conversations are retained for the life of the account (or, for enterprise customers, the contract term plus 30 days unless otherwise agreed). Upon account deletion: 1. Remaining customer data will be deleted within 60 days, except for backups that age out under policy 2. De-identified operational telemetry may be retained only where it cannot reasonably identify the customer, users, or confidential content 3. Legal and billing records will be retained as required by law Customer content is never used to train shared or public models. We do not sell personal data or use customer content for advertising. For the full platform Privacy Policy, including subprocessors and security posture, see the [Privacy Policy](/privacy-policy). ## Changes to This Policy We may update this Privacy Policy from time to time. We will notify you of any changes by: 1. Posting the new Privacy Policy on our website 2. Sending you an email notification for material changes 3. Obtaining your consent where required by law ## Contact Us If you have questions about this Privacy Policy or our data practices, please contact us at: * Email: [support@critique-labs.ai](mailto:support@critique-labs.ai) ## Updates Last Updated: 2/10/2025 # Publishing Your API on Critique Marketplace Source: https://docs.critique-labs.ai/api-platform/publishing Learn how to monetize your custom APIs through the Critique marketplace ## Revenue Model When Pro users utilize your published API, you earn credits based on their usage: * You earn \$0.05 per million tokens when Pro users use your published APIs * Enterprise usage provides further revenue opportunities The more users that integrate your API into their applications, the more credits you earn! ## Publishing Process First design a private API at [https://critique-labs.ai/design](https://critique-labs.ai/design): * Provide an initial prompt to design the API (a chat-like interface will be available soon) * Review the API inputs and make sure they make sense for the API you want to create * Check the generated endpoint stub (i.e., /my-cool-api) and make sure it looks right. Note that sometimes a unique identifier is added to the end of the stub (i.e., /my-cool-api/af4922). This is fine and expected. * IMPORTANT: Check the configuration instructions and make sure you cover all the cases you want to support as well as the cases you don't want to support * MOST IMPORTANT: Test the API to ensure it works as expected. If you don't like the output, you can edit the configuration instructions and test again. Required information: * API Title * Description * Project URL (optional) * Category selection * Tags (recommended) Once published, APIs cannot be deleted to maintain reliability for dependent users. Review: * API documentation * Usage examples * Integration guides * Terms of service Track: * Usage statistics * User feedback * Performance metrics * Revenue generation * Create new versions of your API if needed ## API Visibility Your published API will be showcased in the marketplace with: * API title and description * Your username as publisher * Last update date * Category and tags * Usage statistics * Average response time * Active user count * User ratings ## API Usage Your API listing includes three main sections for users to interact with: ### 1. General API Information * API Title and Description * Input Request and Output Response Formats * Categories and Tags * Project URL (optional) * Total Unique Users who have used your API * Total Calls made on your API ### 2. Code Samples Example implementations will automatically be generated for your API in: * JavaScript * Python * cURL ### 3. Test Endpoint An interactive environment where users can: * Test your API with sample inputs * Validate responses * Check latency and average tokens per call ## Best Practices Write concise but detailed explanations of your API's functionality and use cases Include comprehensive guides, examples, and edge cases Add relevant tags to improve marketplace discoverability Maintain and improve your API based on user feedback and usage patterns ## Support For questions about the publishing process: * Email: [support@critique-labs.ai](mailto:support@critique-labs.ai) * Documentation: [API Reference](https://docs.critique-labs.ai/api-reference/search) * Discord: [Join our community](https://discord.gg/GAWJNMFt) ## Terms of Service Before publishing, review our: * [API Terms of Service](/docs/api-terms-of-service) * [Privacy Policy](/docs/api-privacy-policy) * [Revenue Sharing Agreement](/docs/revenue-sharing) Ensure your API complies with our terms of service and content guidelines. # Critique AI API Marketplace Revenue Sharing Agreement Source: https://docs.critique-labs.ai/api-platform/revenue-sharing-agreement Terms and conditions governing revenue sharing and responsibilities for API publishers on the Critique AI platform. # Critique AI API Marketplace Revenue Sharing Agreement ## 1. Introduction This agreement outlines the revenue-sharing model and responsibilities for users who publish APIs on the **Critique AI API Marketplace**. By publishing an API, you agree to the terms stated below. ## 2. Revenue Sharing Model * API publishers earn **\$0.05 per million tokens** consumed by paid users of their API. * All API usage, including internal processing tokens, is billed at **\$0.50 per million tokens**. * Payouts are processed on a monthly basis, subject to compliance with the terms outlined herein. ## 3. Publisher Responsibilities By publishing an API on the marketplace, you affirm that: * Your API does not facilitate or promote illegal, harmful, or unethical activities. * You are responsible for maintaining and updating your API to ensure reliable performance. * You will not attempt to manipulate, game, or exploit the system for fraudulent gains. ## 4. Indemnification & Liability Critique AI provides experimental AI-driven APIs and ensures responses are grounded and accurate to the best extent possible. However: * **We do not guarantee the correctness, completeness, or reliability of API responses.** * **Critique AI is not liable for any direct or indirect consequences of API usage, including but not limited to financial, legal, or reputational damages.** * **Publishers assume full responsibility for how their APIs are used and agree to indemnify Critique AI against any claims arising from misuse or third-party actions.** ## 5. Right to Refuse Payment & Termination Critique AI reserves the right to **withhold or refuse payments** and/or **terminate an API publisher's account** under the following conditions: * Evidence of **fraudulent activity**, including artificial inflation of API usage. * Use of the API for **malicious purposes**, such as misinformation, illegal activities, or unethical manipulation. * Any attempts to **bypass or exploit platform safeguards**. * **Violation of applicable laws or regulations**. ## 6. Amendments & Modifications Critique AI reserves the right to modify this agreement at any time. Continued participation in the API Marketplace constitutes acceptance of any updated terms. *** For further details, feel free to contact us at [support@critique-labs.ai](mailto:support@critique-labs.ai). # API Platform Terms of Service Source: https://docs.critique-labs.ai/api-platform/terms-of-service Terms of service for the Critique AI API Platform These Terms of Service ("Terms") govern your access to and use of our API Platform services ("Services"). By using our Services, you agree to be bound by these Terms. If you do not agree to these Terms, do not use the Services. ## Account Terms You must register for an account to access our Services. By registering, you agree that: 1. You will provide accurate, current, and complete account information 2. You will maintain the security of your API keys and credentials 3. You are responsible for all activities that occur under your account 4. You will promptly notify us of any unauthorized use of your account 5. We reserve the right to suspend or terminate accounts at our discretion ## Acceptable Use ### Prohibited Activities You may not use our Services to: 1. Violate any applicable laws or regulations 2. Engage in malicious or harmful activities 3. Attempt to gain unauthorized access to our systems 4. Interfere with other users' access to the Services 5. Generate or distribute malware, spam, or harmful content 6. Reverse engineer or decompile our Services 7. Exceed rate limits or circumvent usage restrictions ### Service Protection We maintain sole discretion to: 1. Determine what constitutes malicious behavior 2. Deny service to any user or entity 3. Remove or disable access to any content or integration 4. Suspend or terminate accounts without prior notice 5. Report violations to law enforcement authorities ## API Usage ### Service Limitations 1. API calls are subject to rate limits and usage quotas 2. We may modify or impose new limitations at any time 3. Services are provided "as is" without warranties 4. We do not guarantee uninterrupted or error-free service 5. We may modify or discontinue features without notice ### Performance Standards 1. Free and self-serve tiers are provided without an uptime warranty 2. Uptime targets, support response times, and service credits apply only under a paid enterprise or government agreement 3. Scheduled maintenance will be announced in advance when practicable 4. Emergency maintenance may occur without notice 5. We do not promise 24/7 staffing or assistance under these Terms ## Intellectual Property ### Ownership Rights 1. We retain all rights to our Services and technology 2. You retain rights to your content and implementations 3. Our trademarks may not be used without permission 4. You grant us license to process your API requests ### Licenses 1. We grant you a limited, revocable license to use our Services 2. You may not sublicense or transfer your rights 3. Open source components are subject to their respective licenses 4. API documentation may be used for implementation only ## Payment Terms ### Billing 1. You agree to pay all applicable fees 2. Fees are non-refundable unless required by law 3. We may change pricing with 30 days notice 4. Accounts with unpaid balances may be suspended 5. You are responsible for applicable taxes ### Refunds and Payouts 1. Refunds and payouts are issued at our discretion 2. Disputed charges must be reported within 60 days 3. Account termination does not relieve payment obligations ## Termination ### Account Termination 1. You may terminate your account at any time by contacting [support@critique-labs.ai](mailto:support@critique-labs.ai) 2. We may terminate accounts for Terms violations 3. Termination results in immediate access revocation 4. You remain liable for pre-termination charges 5. Certain Terms survive account termination ### Service Discontinuation 1. We may discontinue Services with 90 days notice 2. We will provide reasonable migration assistance 3. You are responsible for extracting your data 4. Unused prepaid fees will be refunded ## Liability and Indemnification ### Limitation of Liability 1. Neither party is liable for indirect, special, incidental, or consequential damages 2. For free and self-serve users, our aggregate liability is limited to the greater of fees paid in the prior 12 months or US \$100 3. We do not warrant third-party services or content 4. Force majeure events excuse performance 5. Enterprise and government liability caps are set only in negotiated agreements ### Indemnification You agree to indemnify and hold us harmless from claims arising from: 1. Your content and implementations, including uploads you lacked rights to make 2. Your violation of these Terms 3. Your violation of third-party rights 4. Your publication or sharing decisions Critique does not offer vendor indemnity to free or self-serve users. AI-generated outputs are probabilistic and may contain errors; Critique does not indemnify against third-party claims arising from the content of or reliance on AI-generated outputs. You must review outputs before relying on or republishing them. See also the platform [Terms of Service](/terms-of-service). ## Changes to Terms 1. We may modify these Terms at any time 2. Continued use constitutes acceptance of changes 3. Previous versions will be archived and available ## Governing Law 1. These Terms are governed by the laws of the United States 2. Disputes will be resolved in the courts of the United States 3. You waive class action rights 4. Invalid terms shall be replaced with valid equivalent ## Contact Information For legal notices: * Email: [support@critique-labs.ai](mailto:support@critique-labs.ai) ## Updates Last Updated: 2/10/2025 # Agent Integration Source: https://docs.critique-labs.ai/api-reference/agent-apis/agent-integration https://api.critique-labs.ai/openapi.json get /v1/agent-integration Return the copyable prompt and discovery links for coding agents. # Create a new version of an endpoint Source: https://docs.critique-labs.ai/api-reference/agent-apis/create-a-new-version-of-an-endpoint https://api.critique-labs.ai/openapi.json post /v1/design-api/{api_id}/versions Copies the endpoint (and its graph) into a new, editable draft. If the source is the current draft it is released first (made immutable and, as the newest released version, live), so callers on the unversioned URL keep the behaviour they tested. An older, already-released source is left unchanged and stays where it is. The new draft runs only at its pinned /v{n} URL until it is released or published. Creating a version while the endpoint already has another unreleased draft responds 409: release or delete that draft first. Creating a version from an older, released version is how an owner reverts. # Get Designed Api With Key Source: https://docs.critique-labs.ai/api-reference/agent-apis/get-designed-api-with-key https://api.critique-labs.ai/openapi.json get /v1/design-api/{api_id} # List every version of an endpoint Source: https://docs.critique-labs.ai/api-reference/agent-apis/list-every-version-of-an-endpoint https://api.critique-labs.ai/openapi.json get /v1/design-api/{api_id}/versions Returns the whole version lineage the endpoint belongs to, ascending by version. Each entry carries `frozen_at` (set means released, null means draft), `is_latest` (highest version number) and `is_live` (the version the unversioned URL runs). # Release a version Source: https://docs.critique-labs.ai/api-reference/agent-apis/release-a-version https://api.critique-labs.ai/openapi.json post /v1/design-api/{api_id}/release Releases a draft version: it becomes immutable (further edits respond 409) and, being the newest released version, it becomes the live version that the unversioned URL runs. Releasing an already-released version changes nothing and still responds 200. Publishing a version to the marketplace and creating the next version from it release it the same way. # Update Designed Api With Key Source: https://docs.critique-labs.ai/api-reference/agent-apis/update-designed-api-with-key https://api.critique-labs.ai/openapi.json patch /v1/design-api/{api_id} # Contents Source: https://docs.critique-labs.ai/api-reference/contents https://api.critique-labs.ai/openapi.json post /v1/contents This endpoint is used to retrieve the post-processed contents of a web page in the format that the agentic search engine processes. # Delete Api With Key Source: https://docs.critique-labs.ai/api-reference/delete-api-with-key https://api.critique-labs.ai/openapi.json delete /v1/design-api/{api_id} # Design Api With Key Source: https://docs.critique-labs.ai/api-reference/design-api-with-key https://api.critique-labs.ai/openapi.json post /v1/design-api # List Designed Apis With Key Source: https://docs.critique-labs.ai/api-reference/list-designed-apis-with-key https://api.critique-labs.ai/openapi.json get /v1/design-api # Produce Public Service Source: https://docs.critique-labs.ai/api-reference/produce-public-service https://api.critique-labs.ai/openapi.json post /v1/published-service/{api_stub} # Produce User Defined Service Source: https://docs.critique-labs.ai/api-reference/produce-user-defined-service https://api.critique-labs.ai/openapi.json post /v1/user-defined-service/{api_stub} # Rate limits Source: https://docs.critique-labs.ai/api-reference/rate-limits Request rate limits by plan for the Critique Flow API ## Overview Rate limits apply per API key and depend on your plan. Limits are enforced across Critique Flow API endpoints (including `POST /v1/search` and `GET /v1/ws/search`). These limits are not currently defined in the published OpenAPI document. They are documented here and on the [pricing page](https://critique-labs.ai/en/pricing). When limits are added to the OpenAPI spec, this page will stay in sync with `info.description` and endpoint `429` responses. ## Limits by plan | Plan | Rate limit | | ------------------ | ------------------------------------ | | **Free (Starter)** | *10 API calls per minute* | | **Pro** | 100 API calls per minute | | **Enterprise** | 5,000+ API calls per minute (custom) | ## Free tier during peak demand The free tier may be **throttled below the stated limit** during peak usage so we can prioritize paid tier traffic. This is temporary and depends on overall platform load; you may see slower responses or stricter rate limiting even when you are under 10 requests per minute. We reserve the right to throttle the free tier when needed to support paid tier usage, paid tier usage itself however will never be subject to throttling. ## Billing and tier behavior * **Free tier:** Applies when you are on the Starter plan (no paid usage). The **10 requests per minute** limit applies. * **Pro tier:** **100 requests per minute** when you have an active Pro plan or paid usage as described on [pricing](https://critique-labs.ai/en/pricing). * **Token usage:** There is no token cap on the free tier; large queries may take longer to process. ## Fair use and abuse prevention Creating **multiple accounts** (or otherwise splitting traffic across identities) to **circumvent rate limits** is prohibited. If we determine that accounts are being used to bypass limits, we reserve the right to **suspend or permanently ban** those accounts, with or without prior notice. ## When you are rate limited If you exceed your limit, the API may return an error such as: ``` Rate limited, please try again in a minute ``` Implement exponential backoff, respect `Retry-After` when present, and cache responses where possible. See [Search](/api-reference/search) for endpoint details. ## Related * [Pricing](https://critique-labs.ai/en/pricing) — current plan limits * [API Keys](https://critique-labs.ai/en/billing) — manage your key and plan # Run a pinned version of a marketplace API Source: https://docs.critique-labs.ai/api-reference/run-a-pinned-version-of-a-marketplace-api https://api.critique-labs.ai/openapi.json post /v1/published-service/{api_stub}/v{version} Call a specific published version of a marketplace API. Every published version is an immutable snapshot; the unversioned path runs the newest published version, so pin a version here to keep the inputs and output schema you tested against after the owner publishes a newer one. Responds 404 when that version does not exist. # Run a pinned version of your own API Source: https://docs.critique-labs.ai/api-reference/run-a-pinned-version-of-your-own-api https://api.critique-labs.ai/openapi.json post /v1/user-defined-service/{api_stub}/v{version} Call a specific version of the endpoint. The unversioned path runs the LIVE version: the released version with the highest number, or — when the endpoint has never released a version, as with a single never-released v1 — its newest version. An unreleased draft therefore runs only here, at its pinned URL, until it is released or published. Pinning a version also keeps the inputs and output schema you tested against even after the owner releases a newer version. Responds 404 when that version does not exist. # Search Source: https://docs.critique-labs.ai/api-reference/search https://api.critique-labs.ai/openapi.json post /v1/search # Streaming Search Source: https://docs.critique-labs.ai/api-reference/streaming-search https://api.critique-labs.ai/openapi.json get /v1/ws/search > **⚠️ Important Note**: The auto-generated code samples in the playground will not work for this WebSocket endpoint, with the exception of the Python and JS(WebSocket) examples shown. Please use these provided examples only, and not the auto-generated ones. This endpoint provides a WebSocket connection for streaming search results in real-time. #### Connection Connect to: `wss://api.critique-labs.ai/v1/ws/search` #### Headers - **X-API-Key**: (Required) Your unique API key for authentication. #### Message Format After connecting, send a JSON message with the following structure: ```json { "prompt": "your search query", "image": "optional base64 image or URL", "source_blacklist": ["optional list of domains to exclude"], "output_format": { // Optional structured output format } } ``` #### Streaming Responses The server will stream responses as JSON messages with the following structure: ```json { "type": "response" | "context" | "error", "content": "the actual content" } ``` - `type: "response"` - Contains generated response content - `type: "context"` - Contains source context information - `type: "error"` - Contains error messages if any occur # Chat with Tabs Source: https://docs.critique-labs.ai/browser-extension/chat-with-tabs Use your open browser tabs as context for AI conversations ## Overview Chat with Tabs allows you to have intelligent conversations with Critique AI using your open browser tabs as context, enabling: * Cross-reference information across multiple sources * Get comprehensive answers based on current research * Verify claims against multiple sources * Generate insights from combined contexts Chat with Tabs ### Tab Selection * Choose specific tabs for context * Automatically include relevant tabs * Filter by domain or content type * Prioritize tabs by relevance ### Conversation Capabilities * Ask questions about content across tabs * Compare information between sources * Generate summaries of multiple articles * Find contradictions or confirmations ### Context Management * Save important conversations * Export citations and sources * Share insights with collaborators * Bookmark relevant sections ## Use Cases Synthesize information from multiple sources Cross-reference claims across sources Get comprehensive understanding of topics Generate insights from multiple sources # Autonomous Fact-Checking Source: https://docs.critique-labs.ai/browser-extension/fact-checking Get real-time verification across major platforms ## How It Works Critique AI automatically analyzes content as you browse, providing: * Credibility scores * Source verification * Claim analysis * Citation links ## Supported Platforms * Reddit comments * X (Twitter) * LinkedIn comments * Bluesky * Threads * YouTube Comments Automatic analysis of news articles with source credibility Right-click to fact-check any text on any website ## Features ### Automatic Detection Content is analyzed in real-time as you scroll, with visual indicators showing: * Verified claims (green) * Disputed claims (yellow) * Misleading content (red) Verified Unverifiable Unreliable ### Detailed Analysis Hover over any indicator to see: * Supporting evidence * Contradicting evidence * Related context * Original sources ### Custom Verification Highlight any text, right-click, and select "Critique This" to manually trigger fact-checking for: * Specific claims * Quotes * Statistics * Historical information # Welcome to Critique Source: https://docs.critique-labs.ai/browser-extension/getting-started Get started using our superpowered browser extension. ### Quick Setup after Installation 1. Pin Critique to your browser. 2. Open the extension popup and log in. 3. Refresh any open tabs and you're ready to go! Pin Critique ### Key Features #### 1. Critique Images or Text Right-click any image or text to get instant, cited web search responses. Critique Example #### 2. Critique Flow (Command-Shift-K (Mac) or Ctrl-Shift-K (Windows/Linux)) Access powerful search with your browser context: * Press `Command+Shift+K` (Mac) or `Ctrl+Shift+K` (Windows/Linux) * Search with your current browser tabs as context * Get comprehensive, verified responses Critique Side Panel in action #### 3. Social Media Fact-Checking Critique automatically detects and verifies information across platforms: * Real-time tooltips on Reddit, Bluesky, YouTube, LinkedIn, Threads, and X. * Instant fact verification as you scroll * Source credibility assessment Critique Example #### 4. Article Breakdown When you visit a news outlet, Critique will automatically analyze the article and provide a summary of the main points, sources, and credibility score. Critique Article Breakdown # Image Analysis Source: https://docs.critique-labs.ai/browser-extension/image-analysis Get detailed insights about any image on the web ## Using Image Analysis Right-click any image on the web Select "Critique This" from the context menu View detailed analysis by hovering over the tooltip. ## Analysis Features ### Content Verification * Source identification * Manipulation detection * Date verification * Context analysis ### Visual Understanding * Object recognition * Scene description * Text extraction * Brand identification ### Source Tracking * Original publication * Image history * Usage context * Similar images ## Use Cases Verify the authenticity and context of news images Check viral images for manipulation or miscontextualization Find original sources and related content Verify usage rights and attribution # Installing the Browser Extension Source: https://docs.critique-labs.ai/browser-extension/installation Get started with Critique AI in your browser ## Installation Steps * For Chrome, download the [Chrome Extension](https://chromewebstore.google.com/detail/critique-autonomous-searc/dilehbkmjigbpdjlpaglemebmheoilnm) on the Chrome Web Store. * For Edge, download the [Edge Extension](https://microsoftedge.microsoft.com/addons/detail/critique-autonomous-searc/npkalapdljfkockjgholncmogpiphfle) on the Edge Add-ons page. * For Firefox, download the [Firefox Extension](https://addons.mozilla.org/en-US/firefox/addon/critique-autonomous-search/) on the Firefox Add-ons page. Click Install or Add to Browser and confirm the installation Click the puzzle piece icon in your browser toolbar, then pin Critique AI for easy access ## Troubleshooting If you encounter any issues during installation: 1. Make sure your browser is up to date 2. Try disabling other extensions that might conflict 3. Clear your browser cache and cookies 4. Contact our [support team](mailto:support@critique-labs.ai) for assistance ## Now head to the next step to find out how to get started! # Browser Extension Privacy Policy Source: https://docs.critique-labs.ai/browser-extension/privacy-policy Privacy policy for the Critique AI browser extension This Privacy Policy describes how we collect, use, and handle your information when you use our browser extension. By installing and using our extension, you agree to the collection and use of information in accordance with this policy. ## Designed with Privacy in Mind ### Information We Collect When you use our browser extension, we collect anonymous performance data: 1. Selected Text: Content you specifically highlight or select for fact-checking 2. Page Context: URLs and relevant page content necessary for analysis 3. Images: Visual content you specifically select for verification 4. Extension Settings: Your preferences and configuration choices 5. Performance Data: Anonymous usage statistics and error reports ### Technical Data We automatically collect: 1. Browser type and version 2. Extension installation status 3. Feature interaction metrics 4. Error logs and debugging information 5. API communication logs ## Data Usage ### Core Functionality We use collected information to: 1. Provide fact-checking and verification services 2. Process your specific analysis requests 3. Generate accurate and relevant responses 4. Maintain and improve extension functionality 5. Debug and optimize performance ### Service Improvement We collect anonymous performance data to: 1. Enhance extension reliability 2. Improve response accuracy 3. Optimize user experience 4. Identify and fix technical issues 5. Develop new features ## Data Protection ### Security Measures We implement robust security measures including: 1. Industry-standard encryption for all data transmission 2. Secure storage protocols for any retained data 3. Regular security audits and updates 4. Access controls and authentication 5. Automated threat detection ### Data Minimization We follow strict data minimization principles: 1. We only collect information necessary for service operation 2. We process data only for stated purposes 3. We retain data only for the minimum necessary period 4. We automatically delete unnecessary data 5. We anonymize data used for analytics ## Your Rights and Controls ### User Rights You have the right to: 1. Access your personal data 2. Request data deletion 3. Opt out of non-essential data collection 4. Export your data 5. Modify extension permissions ### Privacy Controls The extension provides: 1. Configurable privacy settings 2. Data collection toggles 3. Permission management 4. History clearing options 5. Usage control features ## Data Sharing ### Third-Party Services We do not sell your data. We may share data with: 1. Service providers necessary for operation 2. Analytics tools (anonymized data only) 3. Cloud infrastructure providers 4. Security monitoring services ### Legal Requirements We may disclose information: 1. In response to valid legal requests 2. To protect our rights or property 3. To prevent illegal activities 4. To comply with applicable laws 5. With your explicit consent ## Data Retention ### Retention Periods 1. Active session data: Duration of analysis 2. Error logs: 30 days 3. Anonymous analytics: 90 days 4. User preferences: Until account deletion 5. Extension settings: Until uninstallation ### Data Deletion Upon extension uninstallation: 1. Local data is immediately removed 2. Server data is deleted within 30 days 3. Anonymized analytics may be retained 4. Backup data is purged within 90 days ## Anonymous Analytics We collect anonymous performance metrics that: 1. Contain no personally identifiable information 2. Are used solely for service improvement 3. Are aggregated before analysis 4. Are never sold or shared for marketing 5. Can be opted out of through extension settings ## Changes to This Policy We may update this Privacy Policy periodically. We will notify you of any changes by: 1. Posting updates in the extension 2. Updating our website 3. Providing in-app notifications 4. Obtaining consent where required ## Contact Us For privacy-related inquiries: * Email: [support@critique-labs.ai](mailto:support@critique-labs.ai) ## Updates Last Updated: 2/10/2025 # Browser Extension Terms of Service Source: https://docs.critique-labs.ai/browser-extension/terms-of-service Terms of service for the Critique AI browser extension These Terms of Service ("Terms") govern your use of our browser extension ("Extension"). By installing and using the Extension, you agree to be bound by these Terms. If you do not agree to these Terms, you must uninstall the Extension and discontinue its use. ## Acceptable Use ### Permitted Use You may use the Extension for: 1. Personal fact-checking and research 2. Content analysis for legitimate purposes 3. Image verification and validation 4. Tab-based research activities 5. Personal educational purposes ### Prohibited Activities You may not use the Extension to: 1. Engage in automated scraping or data collection 2. Reverse engineer or modify the Extension 3. Gain unauthorized access to systems 4. Distribute or sell Extension code 5. Manipulate or falsify results 6. Conduct malicious activities 7. Violate any applicable laws ## User Responsibilities ### Account Security You are responsible for: 1. Maintaining account confidentiality 2. Protecting your credentials 3. Reporting unauthorized access 4. Keeping contact information current 5. Securing API keys and tokens ### Content Guidelines You agree to: 1. Submit accurate information 2. Respect intellectual property rights 3. Use appropriate content 4. Follow platform guidelines 5. Comply with applicable laws ## Service Terms ### Availability 1. Service is provided "as is" 2. We do not guarantee uninterrupted service 3. Maintenance may occur without notice 4. Features may change over time 5. Support is provided on a best-effort basis ### Updates 1. Extension may update automatically 2. Security patches are mandatory 3. Feature updates may be optional 4. Compatibility changes may occur 5. Legacy versions may be deprecated ## Service Protection ### Our Rights We maintain sole discretion to: 1. Deny service to any user 2. Remove or disable features 3. Block malicious activity 4. Terminate accounts without notice 5. Report violations to authorities ### Monitoring We may monitor usage to: 1. Prevent abuse 2. Protect our services 3. Improve functionality 4. Ensure compliance 5. Maintain security ## Termination ### Account Termination 1. You may terminate use at any time 2. We may terminate for violations 3. No refunds upon termination 4. Data may be retained as required 5. Some Terms survive termination ### Service Changes We reserve the right to: 1. Modify features 2. Change API availability 3. Adjust pricing 4. Update requirements 5. Discontinue service ## Intellectual Property ### Ownership 1. Extension remains our property 2. You retain rights to your content 3. Feedback becomes our property 4. Trademarks are protected 5. Open source licenses apply ### License Grant We grant you a license that is: 1. Limited and personal 2. Non-transferable 3. Non-exclusive 4. Revocable 5. Subject to these Terms ## Liability ### Limitation of Liability 1. We are not liable for indirect damages 2. Maximum liability is limited to fees paid 3. No warranty for accuracy 4. No guarantee of results 5. Force majeure applies ### Indemnification You agree to indemnify us against: 1. Claims from your use 2. Violations of Terms 3. Legal compliance issues 4. Third-party claims 5. Related legal fees ## Changes to Terms 1. Terms may be updated at any time 2. Notice will be provided for material changes 3. Continued use accepts changes 4. Previous versions will be archived 5. Changes may require re-acceptance ## Governing Law 1. Terms governed by \[Jurisdiction] law 2. Disputes resolved in \[Jurisdiction] 3. Class action waiver applies 4. Arbitration may be required 5. Invalid terms are severable ## Contact Information For legal inquiries: * Email: legal@\[your-domain].com * Address: \[Your Company Address] * Support: \[Support URL] ## Updates Last Updated: \[Current Date] # check-ride.ai Community Forum Guidelines Source: https://docs.critique-labs.ai/check-ride.ai/forum-guidelines Fair use, conduct, and moderation policy for the check-ride.ai community forum # Community Forum Guidelines & Fair Use Policy **Effective Date:** June 24, 2026 **Last Updated:** June 24, 2026 The check-ride.ai community forum (the "Forum") is a place for pilots, students, and instructors to share checkride experiences, study tips, and aviation knowledge. These Guidelines are part of, and incorporated into, the [check-ride.ai Terms of Service](/check-ride.ai/terms-of-service). By posting, commenting, voting, or otherwise participating in the Forum, you agree to these Guidelines. If you do not agree, do not use the Forum. ## 1. The Spirit of the Forum Aviation has a strong safety culture built on professionalism and mutual respect. We expect the same here. In short: **be respectful, be helpful, and be kind to one another.** Disagree with ideas, not people. Assume good faith. Help newer pilots the way you'd want to be helped. ## 2. Fair Use The Forum is provided for **personal, non-commercial** use by members of the aviation community. You agree to: * Use the Forum at a reasonable, human pace and volume. * Use only the official interface to access the Forum. You agree **not** to: * Use bots, scripts, scrapers, crawlers, or other automated means to read, post, vote, or collect data from the Forum, except for well-behaved search-engine indexing that respects our `robots.txt`. * Post spam, advertising, solicitations, referral/affiliate schemes, or repetitive content. * Artificially manipulate votes, rankings, or visibility (including vote brigading, sock-puppet or duplicate accounts, or coordinated inauthentic activity). * Resell, redistribute, or commercially exploit Forum content or access. * Place an unreasonable load on our infrastructure. ## 3. Prohibited Content & Conduct You may not post, link to, or transmit content that: * Is hateful, harassing, threatening, abusive, defamatory, or discriminatory, including content that attacks or demeans others based on race, ethnicity, national origin, religion, sex, gender identity, sexual orientation, age, disability, or veteran status. * Is intentionally inflammatory, incendiary, or designed to provoke, troll, or disrupt ("flaming," "flame wars," or deliberate antagonism). * Harasses, bullies, stalks, intimidates, or threatens any person. * Reveals another person's private or identifying information ("doxxing"). * Impersonates any person or organization, including check-ride.ai staff, the FAA, a DPE, or another member. * Is obscene, sexually explicit, or otherwise inappropriate for a professional community. * Is illegal, promotes illegal activity (including operations contrary to the Federal Aviation Regulations), or facilitates harm. * Infringes anyone's intellectual property, confidentiality, or other rights. * Contains malware, phishing links, or other harmful code. ## 4. Technical Abuse & Platform Security To protect the service and our community, the following are strictly prohibited: * Denial-of-service (DoS/DDoS) attacks, traffic floods, or any attempt to disrupt, degrade, or overload the Forum or its infrastructure. * Automated scraping, harvesting, or bulk downloading of Forum content or member data. * Probing, scanning, penetration testing, or attempting to discover or exploit vulnerabilities without our prior written authorization. * Circumventing, disabling, or interfering with rate limits, authentication, moderation, bans, or other security or access controls. * Uploading or transmitting malware or any code intended to disrupt or gain unauthorized access. We employ technical measures to detect and mitigate abuse — including rate limiting, IP and network-level filtering, bot and anomaly detection, and traffic-shaping — and we may add, change, or remove such measures at any time. We reserve the right to block, throttle, or deny access to any user, IP address, or network, and to **pursue all available legal remedies** (including civil and criminal action) against those who attack or attempt to compromise the service. ## 5. User-Generated Content — Disclaimer & Your Responsibility Forum posts and comments are **user-generated content**. They reflect the views of the individuals who post them, **not** check-ride.ai. * We do **not** pre-screen, verify, endorse, or guarantee the accuracy of any Forum content. * Forum content — including "gouge," study tips, and checkride recollections — is **informal, may be inaccurate or out of date, and is not official guidance.** * Nothing on the Forum is a substitute for the Federal Aviation Regulations (FARs), the Aeronautical Information Manual (AIM), the applicable Airman Certification Standards (ACS), official FAA guidance, or the instruction of a certificated flight instructor or examiner. * **You rely on Forum content at your own risk.** Always verify against authoritative sources and consult your CFI/DPE. You are solely responsible for your own decisions and conduct as a pilot or applicant. You are solely responsible for content you post and represent that you have the right to post it. To the maximum extent permitted by law, check-ride.ai disclaims all liability arising from Forum content or from your use of or reliance on it. ## 6. Moderation Rights **We reserve the right to moderate all discussions on the Forum.** At our sole discretion, with or without notice, and for any reason or no reason, we may: * Monitor, review, edit, hide, label, lock, or remove any post, comment, username, or other content. * Restrict, suspend, or remove any account's ability to post, comment, vote, or read. * Take any action we deem appropriate to protect the community, the service, or any person. We are under no obligation to host, display, or retain any content, and removal of content does not waive any of our rights. ## 7. Enforcement, Bans & No Refunds Violations of these Guidelines may result in actions up to and including, at our sole discretion: * A warning; * Removal or editing of content; * Temporary suspension of Forum or account access; and/or * **Permanent termination ("ban") of your check-ride.ai account.** If your account is suspended or permanently banned for violating these Guidelines or the Terms of Service, you are **not entitled to any refund** of credits, subscriptions, or any other purchases made on check-ride.ai, and any remaining credits or balances are **forfeited**. This is an exception to, and overrides, any general refund policy in our Terms of Service. We may also report unlawful activity to, and cooperate with, law enforcement. We are not required to provide a reason for, or advance notice of, any enforcement action. ## 8. Reporting Violations If you see content or behavior that violates these Guidelines, please report it to [support@critique-labs.ai](mailto:support@critique-labs.ai). Do not engage with or retaliate against bad actors — let the moderators handle it. ## 9. Intellectual Property & Content License You retain ownership of the content you post. By posting, you grant check-ride.ai a worldwide, non-exclusive, royalty-free, sublicensable license to host, store, display, reproduce, and distribute that content in connection with operating and promoting the service (including allowing it to be indexed by search engines). Respect others' intellectual property. If you believe content on the Forum infringes your copyright, contact [support@critique-labs.ai](mailto:support@critique-labs.ai) with a description of the work, the location of the allegedly infringing content, and your contact information, and we will respond appropriately. ## 10. Privacy & Your Identity Your forum profile lets you control how you appear — from fully anonymous ("Pilot") to your chosen username with your location and ratings. Manage this anytime under **Settings → Forum Profile**. See the [Privacy Policy](/check-ride.ai/privacy-policy) for how we handle your data. Do not post other people's private or personal information, and do not post anything you are not comfortable being publicly visible and indexed. ## 11. Changes to These Guidelines We may update these Guidelines at any time. Material changes will be reflected by the "Last Updated" date above. Your continued use of the Forum after changes take effect constitutes acceptance of the updated Guidelines. ## 12. Contact Questions about these Guidelines? Reach us at [support@critique-labs.ai](mailto:support@critique-labs.ai). # check-ride.ai Source: https://docs.critique-labs.ai/check-ride.ai/overview Aviation proficiency made intelligent check us out at: [https://check-ride.ai](https://check-ride.ai) # check-ride.ai Privacy policy Source: https://docs.critique-labs.ai/check-ride.ai/privacy-policy Privacy policy for users of check-ride.ai # Privacy Policy **Effective Date:** July 27, 2025\ **Last Updated:** September 18, 2026 ## Overview check-ride.ai is operated by Starman LLC ("we," "us," or "our") and powered by Critique AI. This Privacy Policy explains how we collect, use, protect, and handle your personal information when you use our aviation training platform. ## Information We Collect ### Information You Provide * **Account Information:** Email address, name, and account credentials * **Training Parameters:** Aircraft type, operating location, endorsements/ratings sought * **Payment Information:** Billing details and transaction history (processed securely through third-party payment processors) ### Information We Collect Automatically * **Voice Data:** Live microphone audio and spoken answers used during practice sessions with our AI examiner * **Session Data:** Training session transcripts, responses, session configuration, and performance metrics * **Usage Information:** How you interact with our platform, session duration, and feature usage * **Technical Information:** IP address, browser type, device information, and access logs ## How We Use Your Information We use your information to: * Provide and improve our AI-powered checkride simulation service * Generate personalized feedback and performance assessments * Maintain your training history and progress tracking * Process payments and manage your account * Provide customer support * Improve our AI models through anonymized and aggregated data analysis * Ensure platform security and prevent fraud ## Voice and AI Processing Before the iOS app prepares your first practice session or connects a voice session, we ask for permission to send session data for the processing described below. The app remembers your permission for the current disclosure; you do not need to approve each session. You can decline, in which case session preparation and voice connection will not proceed, or withdraw permission in the app's Privacy settings. iOS microphone permission is requested separately before audio capture and can also be withdrawn in iOS settings. Practice sessions use remote processing: microphone audio, spoken answers, session setup, and relevant training context are sent to check-ride.ai. We use these named providers for the following purposes: * **OpenAI:** Receives session setup and relevant training context to prepare practice scenarios and organize the ACS topics covered by the session. It also receives relevant transcript and assessment context to evaluate answers and credit demonstrated knowledge across ACS topics. * **Deepgram:** Receives microphone audio to transcribe your spoken answers. * **Google:** Receives transcripts, session setup, and relevant conversation and assessment context to generate examiner responses and assessments. It also receives examiner response text to generate spoken audio. * **Tavily:** When source research uses this provider, receives relevant questions and session details, such as the aircraft description or selected airport, to find supporting sources. This does not require sending your microphone audio. Our own Critique AI service, also operated by Starman LLC, uses relevant session assessments and training context to generate study guidance and research supporting sources. Only data relevant to a provider's role is sent to that provider; not every provider receives every type of session data. We do not send your account password or payment-card information to AI providers. If we change the providers or data uses covered by the iOS disclosure, we update the disclosure and ask for permission again before using the changed processing. Any provider acting for us is permitted to process the data only to provide the contracted service and must maintain privacy and security protections at least as protective as those described in this policy and required by applicable law. ## Data Protection and Security We implement industry-standard security measures to protect your information: * **Encryption:** All data is encrypted in transit and at rest * **Access Controls:** Strict access limitations to authorized personnel only * **Secure Infrastructure:** Cloud-based infrastructure with robust security protocols * **Regular Audits:** Ongoing security assessments and updates ## Data Sharing and Disclosure **We do not and will never share your personal information with:** * Advertisers or marketing companies * Flight schools or training organizations * The Federal Aviation Administration (FAA) or other regulatory bodies * Third-party analytics services (beyond anonymized, aggregated data) **We may share information only in these limited circumstances:** * With service providers that operate parts of the service for us, including AI processing as described above, authentication, hosting, customer support, and payment processing * With your explicit consent for other uses * To comply with legal obligations or court orders * To protect our rights, safety, or property * In connection with a business transfer (with continued privacy protections) ## AI Model Improvement We may use your session data to improve our AI models, but only after: * Removing all personally identifiable information * Anonymizing voice patterns and speech characteristics * Aggregating data to prevent individual identification * Implementing additional privacy safeguards ## Data Retention * **Active Accounts:** Training data retained while your account is active * **Inactive Accounts:** Data automatically deleted after 2 years of inactivity * **Deletion Requests:** We honor all user deletion requests within 30 days * **Legal Requirements:** Some data may be retained longer to comply with legal obligations ## Your Rights You have the right to: * Access your personal information and training data * Correct inaccurate information * Delete your account and associated data * Export your training history and performance data * Opt out of AI model improvement programs * Withdraw consent for data processing ## Children's Privacy check-ride.ai is not intended for users under 13 years of age. We do not knowingly collect personal information from children under 13. ## International Users If you access check-ride.ai from outside the United States, your information may be transferred to and processed in the United States. By using our service, you consent to this transfer. ## Changes to This Policy We may update this Privacy Policy periodically. We will notify you of significant changes via email or platform notification. Your continued use constitutes acceptance of the updated policy. ## Contact Us For privacy-related questions or requests: * **Support:** [support@check-ride.ai](mailto:support@check-ride.ai) For data subject requests or privacy concerns, please include "Privacy Request" in your email subject line. # check-ride.ai Terms of Service Source: https://docs.critique-labs.ai/check-ride.ai/terms-of-service Terms of service for users of check-ride.ai # Terms of Service **Effective Date:** July 27, 2025\ **Last Updated:** July 27, 2025 ## Acceptance of Terms By accessing or using check-ride.ai, you agree to be bound by these Terms of Service and our Privacy Policy. If you do not agree, please do not use our service. ## Service Description check-ride.ai is an AI-powered aviation training platform that simulates oral checkride examinations. Our service provides: * Voice-based interactions with AI examiners * Personalized feedback based on FAA Airman Certification Standards (ACS) * Performance tracking and progress monitoring * Practice sessions for various pilot ratings and endorsements ## User Accounts and Credits ### Account Creation * You must provide accurate and complete information * You are responsible for maintaining account security * One account per person; sharing accounts is prohibited ### Credit System * Services are accessed using a credit-based system * Credits are purchased in advance and never expire * Unused credits are fully refundable upon request * Each practice session consumes one credit * Credits are non-transferable between accounts ## Appropriate Use ### Permitted Uses * Personal aviation training and exam preparation * Educational purposes related to pilot certification * Skill assessment and improvement ### Prohibited Uses * Sharing account credentials or credits * Using the service for commercial training without permission * Attempting to reverse engineer or copy our AI technology * Violating any applicable laws or regulations * Harassment or inappropriate conduct during sessions ## Important Aviation Disclaimers ### Training Supplement Only * check-ride.ai is a **training supplement**, not a replacement for: * Certified flight instruction * Official ground school * Actual flight training * Official FAA examinations ### No Guarantee of Passage * Our service does not guarantee success on actual checkrides * Real checkride performance depends on many factors beyond our training * Always consult with certified flight instructors and current FAA materials ### Regulatory Compliance * Users remain responsible for meeting all FAA requirements * Our assessments are educational and not official evaluations * Always verify information with current FAA publications and regulations ## Intellectual Property ### Our Content * All AI models, algorithms, and training content are proprietary to Starman LLC * You may not copy, modify, or distribute our technology * Feedback and suggestions become our property ### Your Content * You retain ownership of your voice data and training inputs * You grant us a license to use anonymized data for service improvement * You may delete your content at any time ## Payment and Refunds ### Purchases * All purchases are processed securely through third-party providers * Prices are subject to change with notice * Payment constitutes acceptance of current pricing ### Refund Policy * Unused credits are fully refundable upon request * Refunds for used credits are at our discretion * Refund requests must be submitted to [support@check-ride.ai](mailto:support@check-ride.ai) ## Service Availability ### Platform Access * We strive for 99% uptime but cannot guarantee continuous availability * Scheduled maintenance will be announced in advance * Technical issues will be addressed promptly ### Service Modifications * We may update features, pricing, or terms with reasonable notice * Continued use constitutes acceptance of modifications ## Privacy and Data * Your privacy is governed by our Privacy Policy * We do not share personal information with the FAA, flight schools, or advertisers * All data is securely encrypted and protected ## Limitation of Liability ### Educational Service check-ride.ai is provided "as is" for educational purposes. We make no warranties about: * Accuracy of AI assessments * Completeness of training coverage * Fitness for any particular purpose ### Liability Limits * Our liability is limited to the amount you paid for credits * We are not liable for any indirect, consequential, or punitive damages * These limitations apply to the fullest extent permitted by law ### Aviation-Specific Disclaimers * We are not responsible for checkride outcomes * Our assessments do not constitute official aviation training records * Users must independently verify all information and procedures ## Indemnification You agree to indemnify and hold harmless Starman LLC from any claims arising from: * Your use of the service * Violation of these terms * Infringement of third-party rights ## Termination ### By You * You may terminate your account at any time * Unused credits will be refunded upon request * Your data will be deleted per our Privacy Policy ### By Us We may terminate accounts for: * Violation of these terms * Fraudulent activity * Extended inactivity (with notice) ## Governing Law These terms are governed by the laws of California, United States. Disputes will be resolved through binding arbitration in California. ## Contact Information For legal notices: * contact [support@check-ride.ai](mailto:support@check-ride.ai) ## Changes to Terms We may update these terms periodically. Significant changes will be communicated via email or platform notification. Continued use constitutes acceptance of updated terms. *** **Company Information:**\ Starman LLC (Doing Business as Critique AI) Mountain View, CA, USA\ Powered by Critique AI # Critique Chat Indemnification Terms Source: https://docs.critique-labs.ai/critique-chat/indemnification Indemnification terms for Critique Chat users, enterprise customers, and government customers **Effective date:** August 7, 2026\ **Last updated:** August 7, 2026 These Critique Chat Indemnification Terms ("Indemnification Terms") are incorporated into the [Critique Chat Terms of Service](/critique-chat/terms-of-service). Capitalized terms not defined here have the meanings given in those Terms. ## 1. Contract priority and scope A signed Customer Agreement controls to the extent it states different indemnification obligations, procedures, remedies, exclusions, or liability limits. A written proposal is governed by its own terms and any resulting award or Customer Agreement; these Indemnification Terms do not withdraw, narrow, or alter a written commitment made to a named recipient. Sections 3 and 4 below apply to a paid organizational deployment only if its Customer Agreement incorporates these Indemnification Terms or otherwise states that Critique provides indemnification. Section 2 applies to general and organizational use, subject to the public-entity exception in Section 6. ## 2. User and customer indemnity To the extent permitted by law, you will defend, indemnify, and hold harmless Starman LLC, its affiliates, and their officers, directors, employees, and agents from third-party claims, damages, judgments, settlements, penalties, costs, and reasonable attorneys' fees arising from: 1. Customer Content submitted, published, or made available by you; 2. your public/private designation, access grant, sensitivity declaration, or publication decision; 3. your use of the Service in violation of the Terms, a Customer Agreement, or law; 4. your infringement, misappropriation, or violation of a third party's rights; or 5. your material misrepresentation or willful misconduct. You have no obligation under this section to the extent a claim was caused by Critique's negligence, willful misconduct, breach of confidentiality or security obligations, or infringement by the unmodified Service. ## 3. Critique indemnity for paid organizational deployments Subject to the applicable Customer Agreement, Critique will defend and indemnify the customer and its officers, officials, and employees from third-party claims to the extent caused by: 1. Critique's negligence or willful misconduct in providing the Service; 2. Critique's breach of its confidentiality or security obligations; or 3. an allegation that the unmodified Critique Chat platform software infringes a United States patent, copyright, or trademark, or misappropriates a United States trade secret. This section does not create an indemnity for the content of an AI-generated response except to the extent the claim is independently caused by conduct listed in items 1 or 2 above. ## 4. Critique indemnity exclusions Critique has no indemnity obligation to the extent a claim arises from: * Customer Content, source-system data, or instructions supplied by or for the customer; * a public/private designation, publication, access grant, sensitivity declaration, or disclosure decision made by the customer or its users; * combining the Service with a product, system, model, content, or process not provided by Critique, when the claim would not otherwise have arisen; * use of the Service in violation of the Terms, the Customer Agreement, or documentation; * a modification not made or authorized by Critique; * continued use of an allegedly infringing component after Critique provides a non-infringing replacement or directs the customer to stop using it; or * the content of, or reliance on, an AI-generated output, including alleged inaccuracy, defamation, or infringement within a generated response, or the customer's review, adoption, publication, or action on an output. The last exclusion is limited to the generated output and reliance on it. It does not exclude a claim arising from Critique's operation of the Service, negligence, willful misconduct, confidentiality or security breach, or infringement by the unmodified platform software itself. ## 5. Indemnification procedure The indemnified party must: 1. give the indemnifying party prompt written notice of the claim, except that delay relieves the indemnifying party only to the extent materially prejudiced; 2. provide reasonable information, authority, and cooperation at the indemnifying party's expense; and 3. allow the indemnifying party to control the defense and settlement. The indemnified party may participate with counsel at its own expense. The indemnifying party may not settle a claim in a way that admits fault by, imposes non-monetary obligations on, or fails to fully release the indemnified party without that party's prior written consent, which will not be unreasonably withheld. ## 6. Public entities A federal, state, municipal, tribal, or other public entity has no indemnification obligation under Section 2 to the extent the obligation is prohibited by its constitution, statutes, regulations, procurement rules, appropriation limits, or public policy. Nothing in these Indemnification Terms waives sovereign or governmental immunity. Government indemnities, governing law, venue, defense control, settlement authority, appropriations, and mandatory non-waivable terms will be reconciled in the executed Customer Agreement. ## 7. Intellectual-property remedies If the Service becomes, or Critique reasonably believes it is likely to become, subject to an intellectual-property claim, Critique may, at its expense and option: 1. procure the right for the customer to continue using the affected Service; 2. modify or replace the affected component with a materially equivalent, non-infringing alternative; or 3. terminate the affected Service and refund prepaid fees allocable to the unused portion of the terminated Service. To the extent permitted by law, this section and Critique's applicable indemnity are the customer's exclusive remedies for an intellectual-property infringement claim. ## 8. Relationship to liability limits The liability exclusions and limits in the Terms or applicable Customer Agreement apply to these Indemnification Terms. A Customer Agreement may establish different or enhanced caps. For a paid government or enterprise deployment that incorporates these Indemnification Terms without stating different caps: * aggregate liability is capped at two times the annual subscription fee; * the cap for confidentiality or security-breach liability and Critique's intellectual-property indemnity is three times the annual subscription fee; and * payment obligations, willful misconduct, and liabilities that cannot lawfully be limited are not subject to those caps. ## 9. Contact Indemnification notices must be sent to: **Starman LLC (Critique Labs)**\ 110 Constitution Dr, Apt 621\ Menlo Park, CA 94025\ [support@critique-labs.ai](mailto:support@critique-labs.ai) # Critique Chat Privacy Policy Source: https://docs.critique-labs.ai/critique-chat/privacy-policy How Critique Chat collects, uses, discloses, retains, and protects information **Effective date:** August 7, 2026\ **Last updated:** August 7, 2026 This Privacy Policy explains how Starman LLC, doing business as Critique Labs and Critique Labs AI ("Critique," "we," "us," or "our"), collects, uses, discloses, retains, and protects information in connection with Critique Chat, including [chat.critique-labs.ai](https://chat.critique-labs.ai), the public demo, authenticated workspaces, and contracted deployments (collectively, the "Service"). This policy applies only to Critique Chat. Other Critique products have separate notices in this documentation. ## 1. Our role For account, website, support, security, and business-administration information, Critique generally determines why and how the information is processed. For documents, prompts, outputs, user directories, and other content submitted to an organizational workspace ("Customer Content"), Critique generally acts on the organization's instructions. The organization controls its users, source systems, public/private designations, retention instructions, and use of outputs. If you use an employer, school, government, or other organization's workspace, direct requests about Customer Content to that organization first. A signed customer agreement, order, statement of work, or data processing addendum (a "Customer Agreement") may provide additional or different privacy, security, residency, and retention terms. The Customer Agreement controls for that deployment. ## 2. Information we collect ### Information you provide * **Account information:** name, email address, profile image, organization, authentication identifier, and account preferences. * **Customer Content:** uploaded documents, extracted text, filenames, prompts, chat messages, outputs, citations, source metadata, folders, public/private designations, and sensitivity declarations. * **Support and sales information:** messages, contact details, meeting requests, implementation requirements, and other information you provide when contacting us or scheduling a meeting. * **Commercial information:** contract, billing, transaction, and tax records for paid customers. Payment-card details, if required, are processed by a payment provider and are not stored in Critique Chat's application database. ### Information collected automatically * **Usage information:** feature interactions, request timestamps, workspace or assistant mode, document and answer size, estimated token usage, rate-limit events, ingestion status, feedback, and administrative activity. * **Device and network information:** IP address, browser and device type, operating system, referring page, and server or security logs. * **Authentication information:** session cookies, sign-in status, and identity-provider tokens needed to authenticate and secure an account. * **Analytics information:** page views and general site interaction data collected through Vercel Analytics. We do not use Critique Chat analytics for targeted advertising. We may derive aggregate or de-identified statistics that do not reasonably identify an individual, organization, or confidential content. ## 3. How we collect information We collect information: 1. directly from you when you upload a file, ask a question, create an account, contact us, or configure a workspace; 2. from your organization and its authorized administrators or connected source systems; 3. automatically from browsers, devices, application servers, and security systems; and 4. from service providers that support authentication, hosting, AI processing, analytics, scheduling, and support. ## 4. How we use information We use information to: * provide, operate, authenticate, and support the Service; * extract, index, retrieve, and cite Customer Content; * generate and verify responses requested by users; * enforce public/private access rules and document permissions; * administer accounts, source connections, usage, billing, and contracts; * monitor reliability, diagnose errors, prevent abuse, and protect security; * respond to support, sales, privacy, and legal requests; * evaluate and improve Service performance using aggregate, de-identified, or authorized information; * comply with law, court orders, government obligations, and enforceable Customer Agreements; and * establish, exercise, or defend legal rights. ## 5. AI model use Customer Content may be sent to AI and infrastructure providers only as needed to provide the requested Service. Critique does not sell Customer Content and does not use it to train shared or public AI models. For contracted deployments, provider settings and agreements prohibit providers from using inputs and outputs to train shared models. Depending on the deployment and selected features, AI providers may include Anthropic and OpenAI. Public-web research can be disabled, and retrieval can be limited to customer-approved content, as specified in the applicable Customer Agreement. We may use de-identified operational telemetry to evaluate reliability only when it cannot reasonably identify a customer, user, or confidential content. Any materially different model-improvement use requires separate authorization where required by a Customer Agreement or law. ## 6. The public demo The public landing-page demo is designed for non-sensitive evaluation: * anonymous uploads are processed in server memory rather than a persistent document library; * an uploaded document remains in memory until the demo service restarts or the bounded demo cache evicts it; * document text and the question are transmitted to the Service and applicable AI providers to generate an answer; * the application records limited usage metadata, such as IP address, mode, character counts, estimated tokens, and timestamps, but does not store the full anonymous conversation in its usage table; and * rate limits are applied by IP address, or by account identifier and IP address after sign-in. Do not upload confidential, personal, personnel, financial, health, minors', export-controlled, or otherwise restricted information to the public demo. Use a contracted, configured workspace for sensitive organizational content. ## 7. Public and private collections Private documents are available only to authorized workspace users according to configured access controls. Public documents may be retrieved, quoted, and displayed to anonymous users. Where publishing controls are enabled, a document is private by default and publication is a separate action reserved for authorized roles. Users must review content and make any required sensitivity declaration before publishing. Documents marked sensitive cannot be placed in the public collection. These safeguards reduce risk but do not replace the customer's responsibility to classify records and authorize publication. For public-sector customers, records may be subject to applicable freedom-of-information, public-records, legal-hold, and records-retention laws. The public body, not Critique, decides whether a record is subject to disclosure. Critique will assist as required by the Customer Agreement. ## 8. How we disclose information We disclose information only as reasonably necessary: * **To your organization:** workspace administrators may access account details, content, permissions, activity, and usage associated with their workspace. * **To service providers and subprocessors:** providers support cloud hosting, storage, authentication, AI inference, analytics, scheduling, communications, monitoring, and support. Current or planned Critique Chat providers include Microsoft Azure, Vercel, Auth0, Anthropic, OpenAI, and Calendly, depending on the feature and deployment. * **For integrations you enable:** if an authorized user connects a repository or other service, information is exchanged as needed to provide that integration. * **For legal and safety reasons:** we may disclose information to comply with law or valid process; protect users, Critique, or others; investigate fraud or abuse; or establish and defend legal claims. * **For a business transaction:** information may be transferred in a merger, financing, acquisition, reorganization, bankruptcy, or sale of assets, subject to appropriate confidentiality and continued legal protections. * **With consent or direction:** we disclose information when you or the controlling organization directs or authorizes us to do so. We do not sell personal information. We do not share personal information for cross-context behavioral advertising, and we do not use Customer Content for advertising. ## 9. Cookies, analytics, and third-party pages Critique Chat uses necessary cookies and similar technologies for authentication, security, preferences, and session continuity. Vercel Analytics collects site-usage information. We do not use advertising cookies on Critique Chat. Calendly assets load when you choose to open the scheduling widget, and Calendly may collect information under its own privacy notice. Links to external sites and source integrations are governed by those sites' notices. Because there is no uniform standard for browser "Do Not Track" signals, the Service does not currently respond to them. We honor legally recognized opt-out preference signals where applicable. Since we do not sell personal information or share it for cross-context behavioral advertising, there is no Critique Chat sale or targeted-advertising opt-out to apply. ## 10. Retention and deletion We retain information only for as long as reasonably necessary for the purposes described above, subject to a Customer Agreement, legal hold, security need, or legal requirement. Our standard practices are: * **Public demo uploads:** held in volatile server memory until restart or bounded-cache eviction, as described above. * **Customer Content in an active workspace:** retained while the account or Customer Agreement is active, unless the customer deletes it or instructs us otherwise. * **Authentication, administration, ingestion, security, and relevant query-event logs:** generally retained for up to 12 months. * **Documents and conversations in a contracted deployment:** retained for the term of the Customer Agreement plus 30 days, unless the Customer Agreement or lawful retention instruction requires a different period. * **After contract termination:** a standard export is available on timely request; remaining Customer Content is deleted within 60 days, except backups that are protected from routine access and age out under the applicable backup schedule. * **Account, support, billing, and legal records:** retained as needed to administer the relationship, comply with law, resolve disputes, and enforce agreements. * **De-identified information:** may be retained when it cannot reasonably be linked back to a person, customer, or confidential content. Deletion from active systems may not immediately remove information from security logs or backups. We may retain information when legally required or subject to a documented legal hold. ## 11. Security and incidents We use administrative, technical, and organizational measures designed to protect information. Depending on the deployment, these include access controls, role-based permissions, multi-factor authentication, pre-retrieval permission filtering, separate public/private collections, encryption, logging, backups, vulnerability management, and negative-permission testing. Contracted deployments use TLS 1.2 or later in transit and AES-256 or provider-equivalent encryption at rest for databases, object storage, and backups. Backup and recovery commitments, when applicable, are stated in the Customer Agreement. No method of transmission or storage is completely secure. If we confirm a material incident affecting Customer Content, we will notify the controlling customer without unreasonable delay and within any period required by law or the Customer Agreement. ## 12. Data location and international transfers Critique is based in the United States, and information may be processed in the United States and other locations where approved providers operate. Contracted production deployments are hosted in the United States unless the Customer Agreement states otherwise. A Customer Agreement may restrict processing to a named provider or region. Where required for an international transfer, we use an appropriate legal mechanism and contractual safeguards. ## 13. Your privacy choices and rights Depending on where you live and subject to legal exceptions, you may have rights to: * know whether we process your personal information and access a copy; * correct inaccurate personal information; * request deletion; * receive portable information you provided; * object to or restrict certain processing; * withdraw consent where processing is based on consent; and * appeal a decision on a privacy request where applicable. To make a request, email [support@critique-labs.ai](mailto:support@critique-labs.ai) with the subject "Critique Chat Privacy Request." We may verify your identity and authority before acting. Authorized agents may submit requests where permitted by law, subject to verification. If your information is controlled by an organization using Critique Chat, contact that organization first. We will assist it with verified requests as required by its Customer Agreement and law. We will not discriminate against you for exercising a privacy right. You may also complain to the privacy or data-protection regulator where you live. ## 14. Children's privacy Critique Chat is not directed to children under 13, and the public demo should not be used to submit children's personal information. We do not knowingly collect personal information directly from children under 13. If you believe a child has provided personal information, contact us so we can investigate and delete it as appropriate. An organization using Critique Chat in an educational or public-service setting is responsible for obtaining required authorization and configuring appropriate access and content controls. ## 15. Changes to this policy We may update this policy to reflect changes in the Service, law, or our practices. We will post the revised policy and update the date above. We will provide additional notice of material changes when required by law or a Customer Agreement. Changes apply prospectively and do not amend a Customer Agreement unless that agreement allows it. ## 16. Contact us For privacy questions or requests: **Starman LLC (Critique Labs)**\ 110 Constitution Dr, Apt 621\ Menlo Park, CA 94025\ [support@critique-labs.ai](mailto:support@critique-labs.ai) For general service terms, see the [Critique Chat Terms of Service](/critique-chat/terms-of-service). # Critique Chat Terms of Service Source: https://docs.critique-labs.ai/critique-chat/terms-of-service Terms governing the Critique Chat website, demo, and hosted document research service **Effective date:** August 7, 2026\ **Last updated:** August 7, 2026 These Terms of Service ("Terms") govern access to and use of Critique Chat, including the website at [chat.critique-labs.ai](https://chat.critique-labs.ai), its public demo, authenticated workspaces, and related hosted services (collectively, the "Service"). The Service is operated by Starman LLC, a Delaware limited liability company doing business as Critique Labs and Critique Labs AI ("Critique," "we," "us," or "our"). By accessing or using the Service, you agree to these Terms. If you use the Service for an organization, you represent that you have authority to bind that organization, and "you" includes the organization. If you do not agree, do not use the Service. ## 1. Contract hierarchy These Terms govern the public website, free demo, and any use not covered by a separate written agreement. If you or your organization has a signed order, statement of work, SaaS services agreement, data processing addendum, government purchase order, or other written agreement with Critique (each, a "Customer Agreement"), that Customer Agreement controls to the extent it conflicts with these Terms. Service levels, data residency, retention schedules, security obligations, pricing, indemnities, liability limits, governing law, and public-sector requirements stated in a Customer Agreement are not reduced or replaced by these Terms. Written proposal commitments are governed by the proposal and any resulting award or Customer Agreement. These Terms do not withdraw, narrow, or alter a written commitment made to a named recipient. ## 2. The Service Critique Chat is an AI-assisted document research and drafting service. Depending on the workspace and configuration, the Service may: * extract and index text from uploaded or connected documents; * answer questions using designated document collections; * provide citations, quoted evidence, summaries, comparisons, and draft material; * maintain separate public and private document collections and access rules; * support optional public-web research; and * provide administrative, ingestion, usage, and audit features. Features vary by deployment. Public-web research may be unavailable or disabled. A Customer Agreement may require the Service to use only customer-approved sources. ## 3. AI outputs and human review AI outputs are probabilistic and may be incomplete, inaccurate, outdated, offensive, or unsupported even when citations or verification features are shown. Citation checks reduce risk but do not eliminate it. You must review source material and use qualified professional judgment before relying on an output. The Service is a research and drafting aid. It does not provide legal, engineering, zoning, planning, permitting, code-compliance, medical, financial, or other professional advice, and it does not make official or legally binding determinations. Authorized professionals and public officials remain responsible for final decisions and communications. ## 4. Accounts and access Some features require an account. You agree to: * provide accurate account information; * protect passwords, single sign-on credentials, and access tokens; * use only accounts and document collections you are authorized to access; * promptly notify us at [support@critique-labs.ai](mailto:support@critique-labs.ai) of suspected unauthorized access; and * remain responsible for activity under your account except to the extent caused by our breach of these Terms or a Customer Agreement. An organization may administer its workspace, control user access, review usage, and manage content. Your organization, not Critique, determines your authority to use its workspace. ## 5. Customer content and document controls "Customer Content" means documents, files, prompts, messages, metadata, configurations, and other content submitted to the Service by or for you. As between you and Critique, you retain ownership of Customer Content. You grant Critique and its subprocessors a limited, nonexclusive right to host, copy, transmit, extract, index, display, and otherwise process Customer Content only as needed to provide, secure, and support the Service, comply with law, and fulfill a Customer Agreement. You represent that you have the rights and lawful authority needed to submit Customer Content and direct its processing. Do not upload confidential, personal, regulated, export-controlled, or otherwise sensitive information to the public demo. The demo is intended for public or non-sensitive evaluation material. Where the Service offers public and private collections: * content is private unless it is placed in or published to a public collection through an authorized workflow; * you are responsible for the accuracy of public/private designations and access grants; * you must not mark content as non-sensitive or publish it unless you are authorized and have reviewed it for confidential and personal information; and * content designated public may be accessed and quoted by anonymous users. Critique will not sell Customer Content or use it to train shared or public AI models. Additional limits may appear in a Customer Agreement. ## 6. Acceptable use You may not use the Service to: 1. violate law, regulation, court order, or another person's rights; 2. submit content you do not have the right to process; 3. expose confidential, personal, or restricted information through a public collection without authorization; 4. generate or distribute malware, spam, unlawful surveillance, or content intended to facilitate harm; 5. probe, scan, disrupt, overload, or bypass security, access controls, rate limits, or usage restrictions; 6. access another user's account or private content; 7. reverse engineer or attempt to extract non-public source code, model weights, or system instructions except where applicable law does not permit that restriction; 8. misrepresent AI output as an official determination or as human-authored where disclosure is required; or 9. use the Service to make a decision that produces legal or similarly significant effects about a person without legally required notice, review, and safeguards. We may investigate suspected misuse and suspend or restrict access when reasonably necessary to protect users, the Service, or third parties; comply with law; or address a material breach. When practical, we will provide notice and an opportunity to cure. ## 7. Privacy, security, and subprocessors Our [Critique Chat Privacy Policy](/critique-chat/privacy-policy) explains how we handle personal information and Customer Content. We maintain reasonable administrative, technical, and organizational safeguards appropriate to the Service. No system is completely secure, and the free demo is not a substitute for a configured production deployment. Contracted security controls, incident-notice periods, data residency, retention, backup, recovery, identity, and subprocessor requirements are governed by the applicable Customer Agreement. ## 8. Public-sector and public-records use Public bodies remain responsible for records classification, disclosure decisions, legal holds, retention instructions, and responses to public-records requests. Critique will reasonably assist as required by an applicable Customer Agreement. A public body retains authority to decide whether a record is subject to disclosure. Nothing in these Terms requires a government entity to indemnify Critique, waive sovereign or governmental immunity, agree to arbitration, pay attorneys' fees, or accept a governing-law or venue provision when doing so is prohibited by law. Enforceable mandatory government terms and the applicable Customer Agreement control. ## 9. Intellectual property Critique and its licensors retain all rights in the Service, software, models, methods, designs, documentation, and pre-existing materials. Subject to these Terms, Critique grants you a limited, nonexclusive, nontransferable, revocable right to use the Service during the applicable term. You may use outputs as permitted by law and your Customer Agreement. Critique does not promise that an output is eligible for intellectual-property protection or that the same or similar output will not be generated for another user. If you provide feedback, you grant Critique a perpetual, worldwide, royalty-free right to use it without identifying you or disclosing your confidential information. ## 10. Third-party services The Service may interoperate with identity providers, document repositories, AI providers, scheduling tools, hosting providers, and other third-party services. Your use of a third-party service may be governed by that provider's terms. Critique is not responsible for third-party services outside its reasonable control, but remains responsible for subprocessors to the extent stated in a Customer Agreement or required by law. ## 11. Fees and service levels Fees, usage allotments, implementation charges, taxes, payment milestones, renewal terms, and service levels are stated in the applicable Customer Agreement or ordering page. Unless a Customer Agreement states otherwise, fees are non-refundable except as required by law, and you are responsible for applicable taxes other than taxes on Critique's net income. Except where a written proposal or Customer Agreement states otherwise, the free demo is provided without a service-level commitment. Rate limits and feature limits may apply. Critique will not impose paid overages on a government customer unless the applicable Customer Agreement and required written authorization permit them. ## 12. Confidentiality Each party may receive non-public information that a reasonable person would understand to be confidential. The receiving party will use reasonable care to protect it and will use it only to perform or exercise rights under these Terms or a Customer Agreement. Confidential information does not include information that the receiving party can document was lawfully known without restriction, independently developed, received lawfully from another source, or made public without breach. If disclosure is required by law, the receiving party may disclose the required information and, when legally permitted, will give prompt notice so the other party may seek protection. Public-records laws and disclosure authority applicable to a government customer are not limited by this section. ## 13. Indemnification The [Critique Chat Indemnification Terms](/critique-chat/indemnification) are incorporated into these Terms. They distinguish between general users, paid organizational customers, and public entities, and defer to any different indemnity negotiated in a Customer Agreement. ## 14. Warranties and disclaimers For a paid deployment, Critique warrants that it will perform professional services in a professional and workmanlike manner and that the Service will materially conform to the accepted specifications in the applicable Customer Agreement. Critique's obligation to correct a verified material nonconformity is subject to that Customer Agreement. Except for an express warranty in these Terms or a Customer Agreement, and to the fullest extent permitted by law, the Service and all outputs are provided "as is" and "as available." Critique disclaims implied warranties of merchantability, fitness for a particular purpose, title, non-infringement, and any warranty arising from course of dealing or usage of trade. Critique does not warrant that the free demo will be uninterrupted, error-free, or completely secure, or that an output will be accurate or appropriate for your use. Some jurisdictions do not allow certain disclaimers, so those disclaimers apply only to the extent permitted by law. ## 15. Limitation of liability To the fullest extent permitted by law, neither party will be liable under these Terms for indirect, incidental, special, exemplary, punitive, or consequential damages, or for lost profits, revenues, goodwill, or data, even if advised of their possibility. For use not governed by a paid Customer Agreement, Critique's total liability arising out of the Service will not exceed the greater of the amount you paid Critique for Critique Chat during the 12 months before the event giving rise to liability or \$100. A Customer Agreement may provide different limits, exclusions, and enhanced caps, including separate treatment for confidentiality, security-breach, and intellectual-property indemnity obligations. Those negotiated provisions control and are not reduced by this section. The limitations in these Terms do not apply to payment obligations, willful misconduct, or liability that cannot lawfully be limited. The limitations apply to the fullest extent permitted by applicable law. ## 16. Term, suspension, and termination These Terms begin when you first access the Service and continue while you use it. You may stop using the Service at any time. You may request account closure by emailing [support@critique-labs.ai](mailto:support@critique-labs.ai). We may suspend or terminate access for a material breach, security risk, unlawful use, nonpayment, or as required by law. When practical, we will provide notice and a reasonable opportunity to cure. Termination does not affect accrued payment obligations or provisions that by their nature should survive, including ownership, confidentiality, disclaimers, liability limits, indemnification, and dispute terms. Data return and deletion follow the [Critique Chat Privacy Policy](/critique-chat/privacy-policy) and any Customer Agreement. ## 17. Changes to the Service or these Terms We may update the Service and these Terms. We will post the revised Terms and update the date above. For material changes, we will provide reasonable additional notice, such as an account notice or email, when required by law. Changes will apply prospectively. If you do not agree to revised Terms, stop using the Service before they take effect. No online update changes a then-current Customer Agreement unless that agreement expressly permits the change. ## 18. Governing law and disputes Unless a Customer Agreement or mandatory law states otherwise, California law governs these Terms without regard to conflict-of-law rules, and state and federal courts in San Mateo County, California have exclusive jurisdiction. Each party consents to personal jurisdiction and venue there. Government customers are governed by the law, venue, procurement rules, and dispute procedures stated in their Customer Agreement or required by law. These Terms do not impose binding arbitration or a class-action waiver on a public entity. Before filing a claim, the parties will attempt in good faith for 30 days to resolve it through written notice, unless immediate relief is reasonably necessary. ## 19. General terms Neither party is liable for delay caused by events beyond its reasonable control, except payment obligations. Neither party may assign these Terms without the other's consent, except that Critique may assign them in connection with a merger, reorganization, sale of substantially all assets, or to an affiliate that assumes the obligations. If part of these Terms is unenforceable, it will be enforced to the maximum extent permitted and the remainder will remain effective. A waiver must be in writing. These Terms, the documents incorporated by reference, and any Customer Agreement are the complete agreement for the Service. ## 20. Contact Questions and legal notices may be sent to: **Starman LLC (Critique Labs)**\ 110 Constitution Dr, Apt 621\ Menlo Park, CA 94025\ [support@critique-labs.ai](mailto:support@critique-labs.ai) # Critique DB: Agentic Search on your Database Source: https://docs.critique-labs.ai/critique-db/overview Ask questions, extract intelligent insights. check us out at: [https://db.critique-labs.ai](https://db.critique-labs.ai) # Critique DB Privacy Policy Source: https://docs.critique-labs.ai/critique-db/privacy-policy Privacy policy for the Critique Data Analytics Suite ## Introduction Critique DB, a product of Critique AI, is committed to protecting the privacy and security of our users. This Privacy Policy outlines how we handle, store, and protect your database connection information and associated data. ## Data Collection & Storage * Critique DB allows users to connect their databases for querying through our agentic search engine. * We securely store database connection information using industry-standard encryption methods. * Query results, including tables, graphs, and internet search results, may be temporarily cached for performance optimization but do not persist beyond the current session, and are not stored permanently in any way. ## Data Security & Governance * All database connection credentials are encrypted and stored securely. * Access to stored credentials is strictly controlled and limited to essential system processes. * We will **never** share, sell, or provide access to your database connection information to any third party. * Critique DB operates in compliance with data protection regulations, ensuring user data is handled responsibly and securely. ## User Control & Transparency * Users can manage and revoke database connections at any time. * No persistent storage of query results beyond temporary processing needs. * Users have the right to request deletion of any stored information related to their account. * No actual data from your database is stored by Critique DB. ## Compliance & Legal Considerations * Critique DB adheres to GDPR, CCPA, and other applicable data protection laws. * In the event of a data breach, users will be promptly notified in accordance with legal requirements. For any questions regarding this Privacy Policy, please contact our support team at [support@critique-labs.ai](mailto:support@critique-labs.ai). ## Updates Last Updated: 3/29/2025 # Critique DB Terms of Service Source: https://docs.critique-labs.ai/critique-db/terms-of-service Terms of service for the Critique data analytics Suite ## Introduction Welcome to Critique DB, a product of Critique AI. By accessing and using Critique DB, you agree to abide by these Terms of Service. If you do not agree, please discontinue use immediately. ## Experimental Nature of the Service Critique DB utilizes an agentic search engine that applies AI-driven reasoning to user databases. While we make every effort to ground responses in accurate data, the technology is experimental, and we **do not guarantee the accuracy, reliability, or completeness of any output.** **Users acknowledge that reliance on Critique DB’s responses is at their own risk.** ## Data Governance & Liability * **Database Integrity:** We do not and will not make any write operations to your database, the application is incapable of doing so. However, it is your responsibility to ensure that the data connection details you provide are scoped correctly for the extent of access you wish to grant to Critique DB. * **User Data Responsibility:** You retain full ownership and responsibility for any data you provide to Critique DB. We do not assume liability for the correctness or appropriateness of database queries or results. * **Sharing of Generated Information:** If you choose to share, publish, or act upon information generated by Critique DB, you do so at your own discretion. We are not responsible for any consequences, including regulatory compliance, data governance, or business decisions made based on the output. * **Third-Party Data Regulations:** Users must ensure that their use of Critique DB complies with all relevant data protection laws and contractual obligations tied to their database content. ## Limitations of Liability * **No Warranty:** Critique DB is provided "as is" without warranties of any kind, express or implied. * **No Indirect Damages:** We are not liable for indirect, incidental, or consequential damages resulting from the use of Critique DB, including but not limited to financial losses, reputational harm, or regulatory penalties. * **Service Availability:** We do not guarantee uninterrupted or error-free access to Critique DB and may modify or discontinue the service at any time. ## User Conduct & Restrictions Users agree **not** to: * Use Critique DB for illegal or unauthorized purposes. * Attempt to reverse engineer, tamper with, or misuse the service. * Input sensitive personal data (e.g., protected health information, financial details) where unauthorized. ## Modifications to These Terms We reserve the right to update these Terms of Service at any time. Continued use of Critique DB after changes constitute acceptance of the revised terms. ## Contact For any questions or concerns about these Terms, contact [support@critique-labs.ai](mailto:support@critique-labs.ai). For legal notices: * Email: [support@critique-labs.ai](mailto:support@critique-labs.ai) ## Updates Last Updated: 3/29/2025 # Introduction to Critique AI Source: https://docs.critique-labs.ai/introduction we have built what we're terming an agentic search engine and an ecosystem of products atop it. ## Critique AI The founding motivation was that the large language models themselves are growing in sophistication, but it is only when coupled with agency that they are able to exercise their synthesis and reasoning capabilities towards actions. As such, it stands to reason that making these systems more performant necessitates the methods of coupling agency to grow in sophistication at the same rate that the underlying models are. To that end, we set about to build an engine; one that tackles the most generic and versatile of tasks: search. It's utility and performance has enabled us to build the two main vectors that we currently offer: 1. An API platform that allows users to create, deploy, and monetize AI-powered APIs to more than just the basic CRUD operations that most demos for leading agentic software builders offer. 2. A browser extension that offer autonomous fact-checking and interactivity with all web content you browse. (itself built using API's from the API platform) ## The Foundational Technology: Agentic Search Engine Unlike traditional retrieval-augmented generation (RAG) systems, which rely on static indexed data, Critique AI's agentic search engine dynamically searches the web, follows links, and recursively explores related topics to provide the most up-to-date and comprehensive responses. Our approach to information retrieval mirrors human research, making it especially valuable for complex queries requiring nuanced understanding. To learn more about **agentic search**, check out our blog post: [Understanding Agentic Search](https://critiquebrowser.app/en/blog/What-Is-Agentic-Search). Get instant, cited fact-checking and AI-powered analysis across the web Create, deploy, and monetize AI-powered APIs with natural language # Privacy Policy Source: https://docs.critique-labs.ai/privacy-policy Privacy Policy for Critique AI services operated by Starman LLC # Privacy Policy **Effective Date:** August 5, 2026\ **Last Updated:** August 5, 2026 This Privacy Policy describes how Starman LLC, doing business as Critique AI ("Critique," "we," "us," or "our"), collects, uses, and protects information when you use the Critique AI document-grounded assistant and related services at critique-labs.ai and chat.critique-labs.ai (the "Services"). By using the Services, you agree to this Policy. For terms governing use of the Services, see our [Terms of Service](/terms-of-service). Product-specific privacy notices may supplement this Policy for other Critique products; they do not authorize training of shared or public models on customer content, sale of personal data, or advertising use of customer content. We are based in Menlo Park, California. ## Information We Collect ### Account data When you create an account, we collect information such as email address and name. Authentication and identity are handled via Auth0. ### Documents, prompts, and responses We process documents you upload, prompts and queries you submit, and the responses generated by the Services, in order to provide the Services to you. ### Usage telemetry We collect operational metrics such as token counts, timings, feature usage, and related technical logs needed to operate, secure, and support the Services. ### Payment data Paid plans are processed by Stripe. We do not store card numbers on our systems. ### Technical data We may collect IP address, browser or client information, and similar technical data necessary for security, fraud prevention, and service operation. ## Demo and Anonymous Sessions Anonymous demo uploads on chat.critique-labs.ai are session-only and are deleted at session end. Demo uploads are never used to train shared or public models. ## How We Use Information We use the information we collect only to: 1. Provide, maintain, secure, and support the Services 2. Process transactions and manage accounts 3. Detect, prevent, and investigate abuse, fraud, and security incidents 4. Comply with legal obligations 5. Communicate with you about service-related matters De-identified operational telemetry may be used only where it cannot reasonably identify the customer, users, or confidential content. ### What we do not do 1. We do not train shared or public models on customer content — ever 2. We do not sell personal data 3. We do not use customer content for advertising ## Subprocessors We use the following subprocessors to operate the Services. We maintain this published, current list and update it when our subprocessors change: | Subprocessor | Purpose | Notes | | --------------- | --------------------------- | ---------------------------------------------------------------------------------- | | Microsoft Azure | Hosting and infrastructure | United States | | Anthropic | Model inference | Enterprise API terms; API inputs/outputs are not used to train their shared models | | OpenAI | Model inference | Enterprise API terms; API inputs/outputs are not used to train their shared models | | Stripe | Payment processing | We do not store card numbers | | Auth0 | Identity and authentication | | We may update this list as our infrastructure evolves. Material changes will be reflected on this page. ## Retention | Data type | Retention | | ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ | | Audit and query event logs | 12 months | | Documents and conversations (self-serve) | Life of the account | | Documents and conversations (enterprise) | Contract term plus 30 days, unless otherwise agreed | | After account closure | Deletion of remaining customer data within 60 days, except backups that age out under policy and records retained as required by law | Anonymous demo session uploads are deleted at session end, as described above. ## Security We implement technical and organizational measures designed to protect customer data, including: 1. TLS 1.2 or higher in transit 2. AES-256 encryption (or provider-equivalent encryption) at rest across database, object storage, and backups 3. Multi-factor authentication (MFA) availability 4. Role-based access control (RBAC) for team and enterprise deployments 5. United States data residency for government deployments, where contracted ### Incident notification If we confirm a material security incident affecting customer data, we will notify affected customers without unreasonable delay and within seventy-two (72) hours of confirmation. ### Certifications posture Our controls are aligned to SOC 2 Type II criteria. Critique does not currently hold a formal SOC 2 certification. Underlying Microsoft Azure infrastructure is independently audited by Microsoft. ## Government Deployments Content processed for government customers may be subject to that jurisdiction's public-records and similar disclosure laws. Critique will reasonably assist with search, export, and legal holds as required by the applicable agreement and law. ## Your Rights Depending on your location and applicable law, you may have the right to: 1. Access personal data we hold about you 2. Correct inaccurate personal data 3. Request deletion of personal data 4. Export your data in a portable format 5. Object to or restrict certain processing 6. Withdraw consent where processing is based on consent To exercise these rights, contact [support@critique-labs.ai](mailto:support@critique-labs.ai). We may need to verify your identity before fulfilling a request. ### California (CCPA/CPRA) If you are a California resident, you may have additional rights under the California Consumer Privacy Act, as amended by the California Privacy Rights Act, including the right to know, delete, and correct personal information, and the right to opt out of the "sale" or "sharing" of personal information. **We do not sell or share personal information** as those terms are defined under CCPA/CPRA, and we do not use personal information for cross-context behavioral advertising. We will not discriminate against you for exercising your privacy rights. Authorized agents may submit requests as permitted by law; we may require proof of authorization and identity verification. ## Children's Privacy The Services are not directed to children under 13 (or the applicable age of digital consent in your jurisdiction). We do not knowingly collect personal information from children. If you believe a child has provided us personal information, contact us and we will take appropriate steps to delete it. ## International Users The Services are operated from the United States. If you access the Services from outside the United States, you understand that your information may be processed in the United States and other jurisdictions where our subprocessors operate. ## Changes to This Policy We may update this Privacy Policy from time to time. We will post the updated Policy and revise the "Last Updated" date. Material changes may also be communicated by email or in-product notice. Continued use of the Services after the effective date constitutes acceptance of the updated Policy. ## Contact Starman LLC (d/b/a Critique AI)\ Menlo Park, California Privacy and support: [support@critique-labs.ai](mailto:support@critique-labs.ai) # Critique AI for Google Sheets - Documentation Source: https://docs.critique-labs.ai/sheets-addon/overview Learn how to use the Critique AI Google Sheets add-on to perform agentic search queries within your spreadsheets. # Critique AI for Google Sheets Critique AI brings **agentic search** directly into Google Sheets, allowing you to perform **LLM-powered, in-line cited** queries within your spreadsheet using the `CRITIQUE` function. [Add to Google Sheets](https://workspace.google.com/marketplace/app/critique_ai_agentic_search_api/864851643051?flow_type=2) ## **Getting Started** ### **Installation** 1. Install the Critique AI Google Sheets add-on from the Google Workspace Marketplace. 2. Open Google Sheets and navigate to `Extensions > Critique API > Set API Key`. 3. Enter your **Critique AI API Key** (available at [Critique Labs Dashboard](https://critique-labs.ai/en/dashboard)). ### **Basic Usage** The `CRITIQUE` function fetches deeply researched, in-line cited responses based on a search term. #### **Function Syntax** ```excel theme={null} =CRITIQUE(searchTerm, [image_url], [exclude_domains], [show_sources]) ``` #### **Parameters** | Parameter | Required | Type | Description | | ----------------- | -------- | ------- | ------------------------------------------------------ | | `searchTerm` | Yes | String | The query you want to search. | | `image_url` | No | String | URL of an image to analyze. | | `exclude_domains` | No | String | Comma-separated websites you don't want the AI to use. | | `show_sources` | No | Boolean | `TRUE` (default) to include citations. | #### **Example Queries** ```excel theme={null} =CRITIQUE("What is quantum computing?") =CRITIQUE("Latest AI research", , "cnn.com,foxnews.com", TRUE) =CRITIQUE("what is the latest stock price of the company in the image? ", "https://example.com/image.jpg") =CRITIQUE(CONCATENATE("Find some information for the following company: ",A2)) ``` ## **Limitations** * **Rate Limits:** Free tier users can make up to *10 API calls per minute*. See [API rate limits](/api-reference/rate-limits) for peak throttling, fair use, and all tiers. * **Token Limits:** No token limit, but large queries may take longer to process. * **Dependency on API Key:** Users must set an API key before using the function. * **Excessive Requests:** Overuse may result in rate-limiting errors (`Rate limited, please try again in a minute`). ## **Privacy Policy** Critique AI does not share your search queries. **Users must not share their API key** or embed it in shared Google Sheets. Google Workspace APIs themselves are not used to develop, improve, or train AI and/or ML models. However, we may use the search query information as training data to improve our internal non generalized models, this data will be stored securely and will never be shared or otherwise distributed to third parties. Critique AI does not access or store any other data from your Google Sheets, except the values you provide in the search query. The contents of your spreadsheets will never be used for training or improving any of our models, except when explicitly provided by the user in the search query and never to train generalized models. If you wish to opt out of your data being used in any capacity, please contact us at [support@critique-labs.ai](mailto:support@critique-labs.ai). ### **Data Handling** * Queries are **processed in real-time** and returned to the user, Information supplied in the search query by the user may stored securely in our database, but it will never be shared or otherwised distributed to third parties. * API keys are stored **locally within the user's Google Sheets** and are not transmitted elsewhere. * We do not use the **Google Workspace APIs** to develop, improve, or train generalized AI and/or ML models. ## **Terms of Service** By using the Critique AI Google Sheets add-on, you agree to the following terms: * **No Warranty:** The service is provided "as is" without guarantees of uptime or accuracy. * **Liability Disclaimer:** Critique AI is not responsible for any **financial, legal, or reputational damages** from incorrect or misinterpreted search results. * **API Key Security:** Users are responsible for keeping their API key private. **DO NOT SHARE API KEYS** or publish sheets containing them. * **Prohibited Use:** Users must not use the API for illegal activities or misinformation. For support, visit the [Critique AI Help Center](https://discord.gg/DCpxerTKHm). *** Start using **Critique AI in Google Sheets today** and streamline your research workflow! # Terms of Service Source: https://docs.critique-labs.ai/terms-of-service Terms of Service for Critique AI services operated by Starman LLC # Terms of Service **Effective Date:** August 5, 2026\ **Last Updated:** August 5, 2026 These Terms of Service ("Terms") govern your access to and use of the Critique AI document-grounded assistant and related services available at critique-labs.ai and chat.critique-labs.ai (the "Services"), operated by Starman LLC, doing business as Critique AI ("Critique," "we," "us," or "our"). By accessing or using the Services, you agree to these Terms and our [Privacy Policy](/privacy-policy). If you do not agree, do not use the Services. Enterprise and government customers may be subject to a separately negotiated agreement. Where such an agreement conflicts with these Terms, the negotiated agreement controls for that customer. Product-specific terms (for example, for the API Platform or other Critique products) may supplement these Terms for that product; they do not expand free or self-serve uptime warranties, promise 24/7 support, or authorize training of shared or public models on customer content. ## Service Description and AI Disclaimer The Services provide a document-grounded AI assistant and related tools. Outputs are generated by probabilistic models and may contain errors, omissions, or inaccuracies. Features such as citations, quote verification, and abstention reduce but do not eliminate that risk. You must review outputs before relying on them for any purpose. Outputs are not professional advice of any kind, including legal, engineering, zoning, medical, or financial advice. All decisions remain yours. Material decisions require human review. For additional detail, see our [AI Disclosure](/ai-disclosure). ## Accounts You must provide accurate account information and keep credentials secure. You are responsible for all activity under your account. Notify us promptly of any unauthorized use. We may suspend or terminate accounts that violate these Terms or pose risk to the Services or other users. ## Content Ownership and Responsibility You retain ownership of your documents, prompts, and other content you submit to the Services ("User Content"). Critique retains all rights in the platform, models, software, methods, documentation, and related intellectual property. You are solely responsible for: 1. Having all rights necessary to upload and process your User Content 2. The accuracy and legality of your User Content 3. Your sharing, publication, and sensitivity-declaration decisions when making content available to a public or shared audience A disclosure that results from your own publication or sensitivity-declaration decisions is not a Critique security breach. By submitting User Content, you grant Critique a limited license to host, process, and display that content solely as needed to provide and support the Services. ## Acceptable Use You may not use the Services to: 1. Upload or process unlawful content, or content you lack rights to use 2. Attempt to access other users' documents, accounts, or data 3. Scrape, crawl, or automate abuse of anonymous or public endpoints 4. Circumvent rate limits, authentication, or usage controls 5. Interfere with or degrade the Services 6. Reverse engineer, decompile, or attempt to extract model weights or proprietary methods, except to the extent such restriction is prohibited by law 7. Violate applicable law Rate limits apply and may be enforced technically. We may remove content, throttle access, or suspend accounts to protect the Services and other users. ## Availability and Support Free and self-serve tiers are provided without an uptime warranty. Service level agreements — including uptime targets, support response times, and service credits — exist only in paid enterprise or government agreements. We do not promise 24/7 staffing or assistance under these public Terms. ## Fees and Payment Paid plans are billed as described at purchase or in your order form. Payment processing is handled by Stripe; we do not store card numbers. Fees are non-refundable except as required by law or as expressly stated in a separate agreement. We may change self-serve pricing with reasonable notice. Unpaid accounts may be suspended. ## Indemnification ### Your Indemnification of Critique You will indemnify, defend, and hold harmless Critique and its officers, directors, employees, and agents from and against third-party claims, damages, losses, and expenses (including reasonable attorneys' fees) arising from: 1. User Content you upload without having the rights to do so 2. Unlawful data in your User Content 3. Infringement of third-party rights within your documents or other User Content 4. Your publication, sharing, or sensitivity-declaration decisions ### AI-Output Exclusion AI-generated outputs are probabilistic and may contain errors. Critique is not responsible for, and does not indemnify against, third-party claims arising from the content of or reliance on AI-generated outputs — including alleged inaccuracy, defamation, or infringement within a generated response, or your adoption, publication of, or action upon an output. You must review outputs before relying on or republishing them. This exclusion is distinct from claims arising from Critique's operating failures (such as negligence or a security breach affecting customer data) and from platform-software intellectual property claims, which — where offered — follow the enterprise indemnity structure described below. ### No Vendor Indemnity for Free or Self-Serve Users Critique does not offer indemnity to free or self-serve users under these Terms. Vendor indemnity for negligence, security breach, and platform intellectual property infringement is available only in negotiated enterprise or government agreements. Where provided, that indemnity typically includes: 1. Proportional fault ("to the extent caused by" Critique) 2. Exclusions for customer content, combinations with non-Critique materials, misuse, and third-party modifications 3. For intellectual property claims, an exclusive remedy of procuring rights, modifying or replacing the allegedly infringing portion, or terminating the affected services and refunding prepaid unused fees ## Limitation of Liability To the maximum extent permitted by law: 1. Neither party is liable for indirect, special, incidental, consequential, punitive, or exemplary damages, or for lost profits, lost revenue, or lost data, regardless of the theory of liability 2. For free and self-serve users, Critique's aggregate liability arising out of or related to the Services is limited to the greater of (a) the fees you paid to Critique for the Services in the twelve (12) months preceding the claim, or (b) one hundred U.S. dollars (US \$100) 3. Enterprise and government liability caps are set in the applicable negotiated agreement. Public self-serve Terms do not expand those caps Some jurisdictions do not allow certain limitations; in those jurisdictions, our liability is limited to the fullest extent permitted by law. ## Termination and Data Return You may close your account at any time by contacting [support@critique-labs.ai](mailto:support@critique-labs.ai). We may suspend or terminate access for Terms violations, non-payment, or risk to the Services. You may request an export of your data at any time, including upon account closure. Remaining customer data will be deleted within sixty (60) days of account closure, except for backups that age out under our backup retention policy, and records we must retain for legal or accounting purposes. See our [Privacy Policy](/privacy-policy) for retention details. ## Privacy Our collection and use of personal information is described in our [Privacy Policy](/privacy-policy). ## Changes to These Terms We may update these Terms from time to time. We will post the updated Terms and revise the "Last Updated" date. Material changes may also be communicated by email or in-product notice. Continued use of the Services after the effective date of changes constitutes acceptance. If you do not agree, stop using the Services and close your account. ## Governing Law These Terms are governed by the laws of the State of California, United States, without regard to conflict-of-law principles. Exclusive venue for disputes arising under these Terms lies in the state or federal courts located in California, except where applicable law requires otherwise or a negotiated enterprise/government agreement specifies a different governing law or venue. ## Contact Starman LLC (d/b/a Critique AI)\ Menlo Park, California Legal and support: [support@critique-labs.ai](mailto:support@critique-labs.ai)