Cortex by Arc

Legal

Terms of Use

Cortex is a Forged by Arc product, made by Arc Intelligence and operated by ArcSoft Pty Ltd. It is proprietary software provided under license. (See the NOTICE Cortex writes to your store, .cortex/NOTICE, for the IP terms on compiled output.)

The spirit, in one breath. Cortex is generous by design: your own work continuity is never gated; you bring your own model and key, so we don't charge for your inference; licensing is about use-rights, not lock-in (free for your own work, licensed only when you serve others or embed it); when authorization lapses we keep your work running and disclose the state rather than break it; and we don't exclude rights the law says can't be excluded. The sections below are the specifics — written to be precise and fair, not to wall you in. (The full covenant: Research Preview Terms.)

0. Research preview — and what a disclaimer can and cannot do

Cortex is offered as a free research preview (full features, time-limited): no guarantee of stability, accuracy, availability, or backward compatibility; features, schema, limits, and future pricing may change (we aim to give notice before a productization change). This is expectation- setting, not a blanket release of liability.

"Free / preview / at your own risk" does NOT clear all liability. Especially under the Australian Consumer Law (ArcSoft Pty Ltd is an Australian entity): consumer guarantees, and liability for misleading or deceptive conduct, privacy/data-security obligations, or intentional or gross fault, cannot be excluded by these terms. Every warranty disclaimer / liability limit below is therefore qualified by "to the maximum extent permitted by law," and nothing here excludes a right or guarantee that applicable law does not allow to be excluded.

The preview commits to engineering boundaries, NOT to correctness of results.

What Cortex does commit to (enforced in code, testable):

  • it reads transcript sources read-only and writes only under .cortex/;
  • model calls are gated (you authorize each billable run), hard-capped (oversized input is refused, not auto-windowed), with no override of that cap;
  • accepted state carries provenance — every anchor is verbatim, source-linked, and trust-verified.

What Cortex does NOT commit to — do not state or imply otherwise:

  • that reconstruction/orientation is accurate or complete;
  • that it will not mislead;
  • that it is fit for production use;
  • that it is suitable for regulated or confidential environments;
  • that it won't miss or misjudge something.

Cortex is an orientation / provenance tool: its state is sourced historical evidence, not a guarantee of current truth. Verify against current reality before relying on it.

1. What Cortex is, and the boundary of what it does

  • Cortex compiles your conversation transcripts into evidence-linked, human-reviewed context state. It reads your transcripts read-only and writes only under .cortex/.
  • Cortex does not act on your behalf in your world — it changes only its own record under .cortex/. Within that record, a change that passes Cortex's deterministic checks is applied by default and recorded (by the compiler, the background daemon cortexd, or the agent on duty); every applied change is inspectable and reversible (/cortex-maintain, cortex patch revert), and a revert is itself recorded — nothing is deleted. Destructive changes to a state a person has confirmed still wait for a person.
  • Quoted conversation content remains the property of its author. The compiled structure is proprietary to Arc Intelligence (see NOTICE).

1a. Data handling — filesystem-constrained is not "stays local"

  • The filesystem boundary is real but narrow. Cortex reads transcript sources read-only and writes only to .cortex/. It does not modify your files or touch anything outside that store.
  • Compilation sends transcript content to a third-party model. When you compile/ingest, the relevant turns are sent to a language model under your subscription/API key — by default Claude via the Claude Agent SDK, or any OpenAI-compatible endpoint you configure (provider = openai). An endpoint you run locally keeps the data on your device; any hosted provider receives it. Data therefore leaves your machine when you compile to a hosted model. You decide what to compile; nothing is sent without your authorization (the cost gate).
  • You are responsible for the content you choose to compile. Transcripts may contain personal information, client/student/patient material, source code, secrets, or API keys. Review before using Cortex on regulated or confidential material; third-party model providers have their own data-handling terms.
  • We will not claim more than the code enforces. Cortex is described as filesystem-constrained with gated, capped, user-authorized model calls — not as "your data stays local" or "no upload." Sensitive-data handling and third-party model use remain the user's responsibility.

2. Cost — model usage is metered, and gated

  • Compiling sessions calls a language model, which may incur cost (under your own subscription / API key — Cortex does not bill you; your model provider does).
  • Cortex's protection against accidental spend is engineering, not just these terms — a deterministic cost-safety gate: estimate → disclose → ask consent → hard cap → model call. In practice: a --dry-run preview, an interactive y/N gate before any billable run, a non-TTY that refuses unless given --yes, cortex daemon announcing it spends in the background and requiring confirmation, and review-backlog backpressure that pauses ingestion.
  • Hard cap, no override. A session over the configured token ceiling is rejected before any model call — Cortex will not auto-split a too-large input into many billable calls (windowing is a quality strategy, never a way around the cost limit). There is no public flag to bypass the cap: you split the input yourself and re-run — a visible, intentional act. --yes means "I approve this run within the safe limits," never "exceed them."
  • You are responsible for costs you incur through your own subscription/API key — including costs from running Cortex unattended (cortex daemon), approving a run with --yes, modified skills/configuration, or repeatedly triggering compilation. Preview with --dry-run if unsure. (This responsibility is paired with the gates above; the gates are the real protection, the terms are the backstop.)

3. User modifications — at your own risk

  • Cortex's skills, CLI, configuration, and store live on your machine; you can edit them.
  • If you modify Cortex's skills, code, or configuration, you do so at your own risk. Such modifications may cause Cortex to malfunction, to ingest or compile in unintended ways, or to incur additional model cost, and you are responsible for those consequences. cortex install-skills will not overwrite a skill you have edited (it detects your changes); the unmodified behaviour described in the docs assumes the shipped versions.

4. No warranty (subject to non-excludable rights)

  • Cortex is provided "as is", without warranties of any kind, to the maximum extent permitted by law. Nothing in these terms excludes, restricts or modifies any consumer guarantee under the Australian Consumer Law that cannot lawfully be excluded. Where the law allows Arc to limit its liability for failing to comply with such a guarantee, that liability is limited, at Arc's option, to supplying the services again or paying the cost of having them supplied again.
  • To the maximum extent permitted by law, Arc Intelligence and ArcSoft Pty Ltd are not liable for indirect or consequential loss, or for model costs you incur.

5. IP / reverse engineering

See the NOTICE bound into signed artifacts: the compiled form is licensed proprietary material; reverse engineering or building a Cortex-compatible runtime from it is prohibited except under license.

6. The license framework — free floor, licensed lease, and "serve others"

Cortex is licensed, not sold. Use is governed by your Arc Account entitlement and by the specific license that applies to how you use Cortex. This umbrella sets the framework; the operative license documents are listed in §7.

  • Arc Account. Using Cortex on your own machine needs no account and no login: each release ships a research-preview entitlement token inside the package (see "Research preview" below). Some capabilities may require an Arc Account (operated by ArcSoft Pty Ltd) — those that exist as a relationship with Arc (coordination, serving others, embedding), or installing an account-held entitlement. Cortex is one product entitlement under that account; the account is the identity/billing/license subject, not a Cortex-only login.
  • Verify-only entitlement (how the license is technically expressed). Your right to use a given capability is carried by a signed entitlement token that Cortex verifies locally (offline, Ed25519). Cortex cannot issue tokens — Arc is the sole issuer. A token states who may use which capabilities until when; it carries no conversation, workspace, or file content.
  • Free floor vs licensed lease. Cortex names three lists of capabilities.
    • Continuity floor: orient · boot · review · revert · frontier · resume · assemble · search · navigate · cite · alias · promote · stale · label (each for one state) · maintain.inspect · bounded compile · bounded ingest. This is reading, resuming and maintaining your own compiled work-state. It is free for one person on one machine and is never gated, with no token, an expired token, or a token that names a smaller floor. Capabilities move only into this list, never out of it.
    • Preview-unlocked capabilities (the lease, unlocked by the preview key that ships with each release): daemon · scale (ingest runs past the bounded size) · maintain.batch (batch labelling, whole-project promote / stale passes) · sync. If the key lapses and is not renewed by upgrading Cortex or logging in, these stop. The floor does not. Arc will give at least 30 days' prior notice before removing any capability from this list or making it paid.
    • Licensed: coordinate (a coordination service you connect to) · serve (serving others) · embed (embedding Cortex in a product). These require a licence from Arc.
  • "Free for your own work; a commercial license is required to serve others." Service Use — using Cortex to provide functionality, automation, agent capability, a hosted service, consulting delivery, or product capability to another person, team, customer, organization, or end user — requires a commercial license (§7). Personal, research, academic, evaluation, and internal- experimentation use on your own machine, for your own work, does not. The boundary is "serving others," not "making money." If you are not sure whether your use needs a license, write to Arc (contact@arcintelligence.ai) and ask — we would rather answer the question than have you guess, and we do not try to list every case in advance.
  • Continuity-preserving lapse (what happens if a license lapses). Consistent with §0, a license lapse does not silently break your continuity. The free floor keeps working; a lapsed lease degrades (a paid single user falls back to the floor; a deployment serving others continues at the floor while a notice discloses the lapsed authorization). There is no remote kill-switch on a running deployment; enforcement is by non-renewal of the short-lived token. The disclosure notice is part of the licensed output and must not be removed or suppressed by a provider operating under a commercial/embedded license.
  • Research preview. Cortex is currently a free research preview: full features, revocable, time-limited, not a perpetual license. The preview entitlement ships with each release as a signed token with an expiry, so no account or login is needed. A newer release ships a fresh token. cortex license status shows which token is active and when it expires. Arc may modify, limit, commercialise, or discontinue preview access with at least 30 days' prior notice before introducing paid plans or materially limiting access. Tokens are verified locally; pinning an old build does not extend a lapsed entitlement (the lapse affects only the preview-unlocked list, never the floor).

7. The document set

These terms are the umbrella. The operative document for a given context is:

Active during the research preview (what governs you today):

  • Research Preview Terms (Research Preview Terms) — what the preview is and isn't (may change/ pause/sunset; no production-grade or correctness promise; not for high-risk use; Service Use needs authorization; local personal use keeps the continuity floor; BYOK costs/provider-terms are yours; non-excludable rights unaffected). This is the primary governing document during the preview.
  • SDK & Local Runtime License Terms (SDK & Local Runtime License) — the license to run the local runtime and integrate via the SDK for your own use (the free floor + the preview lease).
  • Privacy Notice (Privacy Notice) — what data Cortex handles, what leaves your machine (your model provider on compile; a content-free license signal to Arc only if you sign in or refresh an account key), and what Arc does not receive.

Future / by signed order (not active during the preview):

  • Commercial & Embedded License Terms (Commercial & Embedded License Terms) — Service Use: serving others, hosting, team/commercial deployment, embedding. Granted only by a signed order with Arc.
  • Enterprise Agreement (Enterprise Agreement) — negotiated enterprise / FDE / private deployment, customer-managed keys, support, and (exceptional) strategic source licensing.

Where a specific document conflicts with this umbrella, the specific document governs for that use.

Cortex Terms of Use, version 1.0. Questions: contact@arcintelligence.ai.