Read-Only Glass Vault A transparent cube containing source-citation marks, with cyan attribution rays leaving the vault while no signals enter, and a lime READ-ONLY badge clipped to the side. " " " AUDIT LOG · APPEND-ONLY · TIMESTAMPED 14:02:11 read contracts/A0291 ok 14:02:14 read shipments/9342 ok 14:02:18 read inventory/H100 ok READ-ONLY NO WRITES Trust Center

Built for the operator who can't afford a leak, or a hallucination.

For your security team. Architecture, data handling, certifications status, and the contractual protections we extend to design partners. The wording for each item makes the distinction between what ships today, what's on the roadmap, and what we haven't yet earned: no fudging.

A note on stage

Design-partner stage, October 2026. SOC 2 Type I and an independent penetration test are budgeted, not yet initiated; Type II follows, once the Type I observation window it depends on is open. ISO 27001 is architected against, not yet certified. Aspirational claims on this page are labeled as such.

Stage honesty

Two things that aren't yet true, and our answer for each

OpsATC.AI™ is at design-partner stage, October 2026. Pretending otherwise insults sophisticated buyers and erodes the trust the platform is built to earn. The honest acknowledgments below are not concessions: they're the foundation of the architectural commitments that follow on this page.

Complete on staging, not yet on live data

The design-partner MVP is complete on staging. It has not yet run against live customer data.

The pilot is built on a greenfield architecture: a lightweight agent runtime powering The Captain, read-only connectors, scheduled jobs, and a multi-tenant database, with the Trusted Advisor doctrine and data-quality detection designed in. It connects a focused set of systems (SAP, Salesforce, Business Central), read-only, against vendor sandboxes. Six of the eleven cross-system detection rules fire today; the remaining five switch on once live customer data is connected, which is the next step. Design partners receive current architecture detail under NDA.

SOC 2 planned, not earned

SOC 2 Type I and a penetration test are budgeted; Type II is the next step after it.

We architect against SOC 2 and ISO 27001 controls, but no audit is booked. We will not claim certifications we have not earned, and we will publish each one on this page the moment it is awarded (see Section 01 below).

Your data is dirty · operational reality

Every operation's data is dirty when we start. The Captain doesn't pretend otherwise.

Stale records. Missing identifiers. Duplicate keys. Two source-of-truth systems disagreeing about the same SKU. Schema drift from a vendor update no one announced. Reference-data gaps the prior tool quietly worked around. The legacy answer is a six-month data-cleanup project before useful output. We took a different path.

The Captain's data-quality detection is designed to flag these issues as they surface, through a baseline scan at connection, inline checks on every read, scheduled background sweeps per record type, and operator-triggered deep dives. On-demand checks run today; the continuous modes are on the roadmap. Findings surface through the Trusted Advisor card alongside the answer they affect, severity-graded so operators are not trained to ignore them. The platform produces value on day one. The cleanup happens in parallel, prioritized by operational impact, owned by the operators who already know the records best. Full Data Governance architecture →

The pattern is the same in every case: the gap between the claim and the proof is acknowledged, measured, and on a calendar. Each acknowledgment here is a milestone we report against on this page as we close it. Buyers who need every gap closed before signing are not yet our buyers. Buyers who can read an architecture and weigh it against a roadmap are.

Published record

Our claims are on the record

We hold our own public claims to the same discipline we apply to your data: material changes are dated and on the record. We are currently re-baselining this page to the completed design-partner pilot architecture, and we publish changes to what we claim in whichever direction they move. If a figure anywhere on this page disagrees with a document you have been shown, we would like to know.

01 · Certifications & Compliance

A clear runway, not a checklist

OpsATC.AI is architected against SOC 2 and ISO 27001 from day one. SOC 2 Type I and an independent penetration test are budgeted but not yet initiated; Type II is sequenced to follow, since its observation window can only begin once Type I is in place. We will not claim certifications we have not earned, and we will publish current status on this page as each one is awarded.

Compliance frameworks, current audit status, and target completion dates for OpsATC.AI certifications.
FrameworkStatusTarget
SOC 2 Type IBudgeted, not yet initiatedTBD
Independent penetration testBudgeted, not yet initiatedTBD
SOC 2 Type IIPlanned, follows Type IPost Type I
ISO 27001:2022Architected againstN/A
HITRUST CSFOn roadmap2027
GDPRDPA available on requestOngoing
CCPA / CPRADPA available on requestOngoing
FedRAMP / IL4Not in scopeN/A

Industry-specific attestations (CMMC, ITAR, HIPAA where applicable) considered on a per-customer basis during design-partner contracting. Reach out to [email protected] before evaluation if your industry requires a framework not listed above.

Regulatory disclosure

Every first-session interaction with The Captain includes a verbatim disclosure that The Captain is an AI assistant, and every response surface (chat reply, recommendation card, Logbook entry, daily workbench tile) carries a persistent AI-assistant notice. This disclosure is enforced at the component level — the surfaces cannot render without it — and is designed to satisfy applicable AI-transparency requirements (EU AI Act Articles 4 and 50, California SB-1001, and FTC Section 5 anti-deception guidance). The exact disclosure wording is being finalized; procurement and legal teams can verify the implementation under NDA.

02 · Tenant Isolation

Tenant isolation, by design

Per-customer data isolation is enforced in the database (row-level security, forced and fail-closed), the query layer, the model-context builder, the audit log, and per-tenant credential key derivation. We do not operate an embeddings or vector store. No cross-tenant fine-tuning. No "shared learnings" leaking one operator's IP into another's recommendations. Architecturally, one customer's view never crosses another's.

What this means concretely

Pilot scope below describes the controls shipping with the first design-partner deployment. Production hardening lands post-pilot.

  • Logical isolation at the database row level, enforced by tenant ID on every query path; no application-level join can cross tenants. (Implementation complete; deployed with the first design-partner pilot.)
  • Per-tenant credential encryption at rest: customer credentials are encrypted with pgcrypto using per-tenant HKDF-derived data keys today. A refuse-to-boot guard forbids the dev env-key strategy in production. The cryptographic primitive is live; a leak of one tenant's key has no effect on any other tenant, by design. On the roadmap: managed-key encryption with automated key rotation (the pilot currently uses an environment-provided master key, not a managed key service). This hardens with production deployment, post-pilot.
  • Rate limiting posture (honest read): an in-memory, per-(tenant, provider) limiter wraps every outbound call to keep us within the customer's published API limits. Today it is a per-instance bucket, not a cross-instance ceiling. Distributed per-tenant rate limiting that protects against noisy-neighbor behavior is on the roadmap; it lands with production hardening, post-pilot.
  • Model context boundary: The Captain's per-request context window is loaded only with the active tenant's data; tenant ID is enforced at the prompt construction layer, not just at retrieval.
  • Customer-tenant configuration exposed in the Admin Portal so isolation policy is auditable directly by your team during the pilot, not via a screenshot in a sales deck.

Provisioning posture today

  • Tenants currently provisioned on our managed Postgres database: OpsATC.AI's own dogfooded tenant plus demo environments. Pre-revenue, design-partner stage. Production tenant slots open at pilot kickoff.
  • Row-Level Security at the database layer: RLS baseline applied at migration 0017 (enable_rls_baseline); migration 0035 makes RLS fail-closed: a query with no tenant context returns zero rows via an all-zeros sentinel, not every tenant. Logical isolation is database-enforced, not application-enforced.
  • Tenant isolation is tested, not asserted: a dedicated tenant-isolation integration suite boots under a restricted no-BYPASSRLS database role so RLS actually engages, and includes a fail-closed canary that asserts a no-tenant-context query returns zero rows. Isolation is a tested invariant, not a prose promise.
  • JWT in HttpOnly cookie only (T11 migration complete 2026-06-10). Authentication tokens never appear in URL params, never in localStorage. SSO callback drops the legacy ?token= URL pattern. XSS-resistant by construction.

Encryption, transport & egress posture today

A precise read on what is code-enforced on the running stack right now (single US region), what is architected but not yet deployed, and what is on the roadmap. The labels matter: we do not market roadmap as live.

In place today: code-enforced on the running stack

  • Multi-tenant Postgres Row-Level Security
  • Read-only Trusted-Advisor doctrine with two-tier CI enforcement
  • Append-only audit log (UPDATE/DELETE revoked from the application role)
  • Per-tenant egress allow-list
  • A TLS 1.2+ (AEAD) floor with mTLS and per-adapter certificate pinning supported in the egress client. We do not force TLS 1.3, which would break older customer endpoints.
  • Customer credentials encrypted at rest with pgcrypto and per-tenant HKDF-derived data keys
  • A refuse-to-boot guard forbidding the dev env-key strategy in production
  • CAIQ / SIG / VRA pre-fills mapped to specific ADRs
  • GDPR + CCPA architectural controls
  • A read-only-scoped DPA template

Architected but not yet deployed

  • Managed-key encryption with automated key rotation (the pilot currently uses an environment-provided master key)
  • High-availability database failover
  • Static egress IPs for customer allow-listing
  • A managed web application firewall (WAF) in front of the API
  • Distributed per-tenant rate limiting across instances, to protect against noisy-neighbor behavior on the customer-facing path

Roadmap, not running. We will not market these as live until they ship.

On the roadmap, honestly

  • SOC 2 Type I and an independent penetration test are budgeted but not yet initiated; no audit is booked
  • SOC 2 Type II is not yet certified; its observation window begins once Type I is in place, and it is sequenced to follow
  • ISO 27001:2022 control mapping is in progress; certification follows SOC 2
  • HIPAA / BAA and FedRAMP are out of scope at launch
  • Third-party penetration test scoped post-design-partner

We publish only the certifications we hold, the customer counts we have, and the operational metrics we have measured. The discipline is the differentiator.

Vertical configurations: one customer, one vertical

OpsATC.AI serves six supply chain segments. One customer = one vertical configuration, not a forked codebase: each segment configures navigation, KPIs, recommendation prompts, and connector defaults for that supply chain role. The pilot runs one segment (Storage / OEM); the rest are our go-to-market roadmap.

  • Storage / OEM
  • Hub Provider
  • Hybrid Manufacturing + Distribution
  • Contract Manufacturing
  • Distribution
  • Logistics + 3PL

Forking the codebase per customer creates a maintenance nightmare. Pre-tuned vertical configs keep the platform unified while letting each customer's surface match their operating model.

03 · Platform Controls

What the platform enforces, by topic

Skeptical buyers want to see what the platform actually enforces, not just what it markets. The ten domains below are the decisions and controls that govern how OpsATC.AI handles tenant isolation, integration, data quality, security, and privacy. The full technical detail behind each one, including the decision records that document it, is shared with design partners under NDA.

The ten domains we govern

  • Multi-tenant data isolation: Postgres row-level security enforced at every query; tenant boundary is a database-level invariant, not application-level.
  • MCP-native connector architecture: read-only connectors over the Model Context Protocol (MCP); per-connector capability, scope, and write-gate classification.
  • The Captain agent runtime: a thin agent over a bounded tool set with a tool-selection chokepoint and per-operation routing; one defined path per workflow, not free-form agent loops.
  • Trusted Advisor doctrine: The Captain reads systems of record; writes route through a human-gated approval queue; no autonomous writes to customer systems.
  • Data quality detection: layered detection (baseline → inline → scheduled → on-demand) of the six issue classes that erode operator trust: stale records, missing identifiers, duplicate keys, contradictory source-of-truth values, schema drift, and reference-data gaps.
  • Security controls: five control families. Live today: per-tenant egress allow-list (read verbs only); a TLS 1.2+ (AEAD) floor with mTLS and per-connector certificate pinning supported in the egress client (we do not force TLS 1.3, which would break older customer endpoints); secrets management via pgcrypto with per-tenant HKDF-derived data keys. On the roadmap: managed-key encryption, distributed per-tenant rate limiting, static egress IPs, and a managed web application firewall in front of the API.
  • Privacy & PII Protection: four-tier sensitivity taxonomy applied at the connector boundary. The Forbidden tier (SSN, passport, bank account, ICD-10 diagnosis codes linked to identity, GDPR Article 9 special categories, 42 CFR Part 2 substance abuse records, COPPA minors data) is designed to be filtered at the connector boundary before it reaches The Captain, rather than passed through, even with customer consent or admin override. The Identifying tier (names, employee numbers, customer IDs) is default-deny and not accessible in-product today; the four-gate elevation policy (express written customer permission, signed DPA, per-tenant policy flag, two-person admin approval, all audit-logged) is defined and will be enforced when that access path ships.
  • Token governance: per-tenant monthly budgets and per-user daily caps, hard-enforced at the orchestrator with an atomic, race-safe cutoff and an append-only record of every block. A per-operation model router with admin policy knobs ships in the codebase; production traffic exercises a single tier today, and the cheaper and deeper tiers activate as more operation types land. OpsATC runs on an AI provider we manage, with the spend cap checked before every request; because the platform is model-neutral, bringing your own AI provider is on our roadmap.
  • Live-read architecture: connectors integrate without ingesting source data into a central lake; The Captain queries source systems live and uses the returned data only to answer the request in-flight, retaining read metadata (system, operation, record count, latency), never the read payload.
  • Network Federation (a planned capability): a design that would let two adjacent partners in a real-world business relationship share a defined slice of operational data (e.g., ASN status for one customer's orders, demand for one supplier's parts) without either side losing read-only posture, tenant isolation, or audit. Bilateral acknowledgment before any data flows; scope enumerated as canonical entities plus a filter predicate; every cross-tenant read writes an audit event visible to both tenants; either side revokes unilaterally and instantly. Roadmap, not running: this is design intent, not a shipped feature.

Five operating rules we hold ourselves to

The decisions above describe what the platform enforces. Operating rules describe what we hold ourselves to: explicit organizational rules, internally enforced across every conversation, every commit, every dispatch. The five we publish:

  • Honest-stage discipline. Never invent customer counts, quotes, shipped-feature status, or operational data. Pre-revenue framing is explicit. The honest-stage banner above is anchored to a single source-of-truth value in code, not hand-edited copy.
  • Four-tier sensitivity model. Forbidden PII (Social Security numbers, passport numbers, bank account numbers, PHI) is blocked by default and never intentionally surfaced, filtered at the connector boundary by design, regardless of consent. Identifying data (names, employee numbers) requires explicit written per-tenant permission. Operational data is default-allow; public data is unrestricted. This four-tier model is defined doctrine; enforcement is being built into the product in stages and is not yet active in the pilot.
  • Verbatim AI disclosure. Every first-session message with The Captain includes a verbatim disclosure that it is an AI assistant. Designed to satisfy EU AI Act Article 4/50, California SB-1001, and FTC Section 5 anti-deception simultaneously.
  • Single-writer discipline. Only one development conversation modifies a given working tree at a time. Prevents parallel-write corruption and silent commit interleaving. Discovered the hard way; codified after.

These five are a subset of nine operating rules codified internally; four are engineering-discipline rules less relevant to a buyer audience. The full set is shared to design partners under NDA at pilot kickoff.

Full architectural detail, including the decision records behind each control, is shared with design partners under NDA at pilot kickoff. Reach out for architectural deep-dive sessions during contracting.

04 · Audit Trail

Audit trail: structured logging and write-gate enforcement

Every Captain event (every read, query, recommendation, and human decision) is designed to be tied to a user, a role, a source system, and a timestamp. Write-gates are enforced in code; all gate decisions are logged. The design-partner pilot delivers an append-only audit log — updates and deletes are revoked from the application role — plus read-only (write-gate) enforcement. Tamper-evident hash-chaining, persistent forensic-grade retention, and export in formats accepted by regulated-industry auditors are on the roadmap for production hardening, post-pilot.

What the audit trail captures

Capture surface designed for the design-partner pilot. Specific fields are finalized per pilot during onboarding.

  • User action log: every action a human user takes in any portal, with role context and source IP.
  • Agent activity log: every tool call The Captain makes, every system of record she reads from, every query and recommendation, with the prompt and response retained.
  • Approval trail: every human-in-the-loop approval, with approver identity, timestamp, scope authorized, and any limits configured.
  • Source citations: every recommendation includes the systems and records it was derived from, retained alongside the response.
  • Configuration changes: every change to tenant configuration, role assignments, integration settings, or workflow rules.
  • Append-only logs: the audit log, the connector read log, and The Captain's invocation log all have updates and deletes revoked from the application role. Tamper-evident hash-chaining is on the roadmap.

Retention & export

Retention and export terms are set per tenant in the pilot agreement. Export formats planned: JSON, CSV, and SIEM-compatible streams.

Controls: in place vs. planned

"In place" means built and tested in our design-partner pilot environment. It has not yet run against live customer data.

In place

  • Read-only access to your systems
  • Separate data for every customer (forced row-level security)
  • Append-only activity log you can export
  • AI spending limits, checked before every request
  • Approved outbound connections only (deny-by-default egress)
  • Software supply-chain checks in CI

Planned

  • Bring your own AI provider
  • Automatic data-retention controls
  • Tamper-evident (hash-chained) audit log
  • Managed-key encryption and high-availability failover

Supply chain: every software dependency is locked to an exact version, held for a seven-day release-age window, and checked for a verified source and known advisories in CI before it ships.

What this means for a pilot today. The in-place controls are sufficient for a single-tenant design-partner pilot running against a sandbox or staging environment. Production hardening is a precondition for live-data deployment and is reviewed jointly with your security team during pilot scoping; we will not run against production data before it is in place.

05 · Human-in-the-Loop

Read-only by doctrine. The clicks belong to the operator.

The Captain is read-only against every system of record. She reads, reasons, cites, and recommends. She does not issue POs, reroute shipments, or post journals: those clicks belong to the operator. This is doctrinal, not a default: OpsATC.AI is not building write capability against customer systems of record. The clicks are yours, permanently.

How this works in practice

  • Default mode: advisory. The Captain drafts, recommends, and cites. Nothing changes in your systems of record unless a human user clicks approve.
  • OpsATC writes only to its own application data. Notes, scheduled prompts, configuration, draft artifacts (emails, briefs) that you review and send from your own system. Never outbound to your ERP, Kinaxis, Salesforce, or any system of record.
  • Approval audit. Every approval is logged with approver identity, scope, and any limits. Structured logging is captured during the design-partner pilot; SIEM streaming (Splunk HEC, Elastic, Datadog) lands with production hardening, post-pilot.
  • Kill switch. The Admin Portal is designed to expose a per-workflow disable that immediately pauses The Captain from generating recommendations on the affected workflow. Implementation completes during the design-partner pilot.

The read-only doctrine is defense-in-depth across three layers: a default-deny write-gate registry that classifies every write action, The Captain's tool-selector filtering high-risk writes out before any tool list reaches the model, and a CI lint that blocks any pull request adding an unregistered write tool. Most high-risk writes have no executable code path at all. The full write-gate architecture is detailed under Platform controls above and on the integrations page.

06 · Data & Workforce

What we won't do with your data or your team.

Two commitments hold together: your operational IP is never used to train any third-party model, and the team running your operation is never the metric we optimize against.

On your data

  • No foundation-model training on customer data. Our model provider's API terms forbid it; the OpsATC.AI pilot agreement reaffirms it.
  • Your data stays in the United States. You can ask us to export or delete it at any time; deletion is handled manually today, and automatic data-retention controls are on our roadmap.
  • Process improvements stay yours. The Process Intelligence Engine is designed to surface bottleneck patterns and ROI calculations identified inside your tenant; those findings are your operational IP, not platform-level features we resell.
  • De-identified telemetry only. Platform-improvement analytics (latency, error rates, feature usage) is designed to be aggregated and de-identified before it reaches our engineering systems; the telemetry pipeline ships during the design-partner pilot.
  • For cross-tenant isolation specifics (fine-tuning, key management) see Section 02.

On your team

Our objective is to amplify the operators you already have, not to enable their replacement. The outcomes we measure are cycle time, OTIF, exception MTTR, onboarding velocity, and decision compression, never seats eliminated.

07 · Residency & Sub-processors

Where your data lives: regions, retention, third parties.

Hosting is in US regions, with EU and APAC residency on the production roadmap. We set out residency, retention, and sub-processor-change commitments in writing in the pilot agreement.

Regions & status

Data-residency regions, current pilot status, and notes on availability for OpsATC.AI hosting.
RegionStatusNotes
United StatesLive · PilotDatabase in Oregon; application hosting in San Jose and Virginia.
EU (eu-west-1, eu-central-1)RoadmapTargeted Q1 2027 · GDPR-aligned
APAC (ap-southeast-1)RoadmapTargeted Q3 2027

Sub-processors

Every third party that may touch customer data. Additions are communicated to design partners 30 days in advance with an objection window, set out in the pilot agreement. Status reflects current platform integration; design partners receive the as-deployed list before pilot kickoff.

Sub-processors that handle customer data, their purpose, and hosting region.
ProviderPurposeRegion
SupabaseDatabase and authenticationUS (Oregon)
Fly.ioApplication hostingUS (San Jose, Virginia)
AnthropicAI modelUS
OpenAIBackup AI modelUS

All customer data is hosted in the United States. Other tools we rely on, such as our background-job and agent frameworks, are open-source software we run ourselves on our own infrastructure, so no customer data is shared with the companies behind them. The definitive list is set out in the Data Processing Agreement, and additions are communicated to design partners in advance with an objection window.

Last updated: October 2026.

08 · When Something Goes Wrong

Disclosure, response, timing.

Two channels for "something is wrong": researchers and customers reporting a vulnerability they found, and the internal incident path when we detect one ourselves. Both have written commitments below.

Vulnerability disclosure: for researchers and customers

Target acknowledgment within one business day. Target triage status within five business days. No legal action against good-faith researchers who follow this policy. We intend to make these contractual commitments in the pilot agreement.

In scope

  • opsatc.ai and any *.opsatc.ai production subdomains
  • The OpsATC.AI mobile and web applications
  • The MCP connector framework and integration layer
  • Authentication, authorization, tenant isolation, and audit-trail integrity

Out of scope

  • Vulnerabilities in third-party services we use (please report to that vendor; we will coordinate)
  • Issues requiring physical access, social engineering, or denial-of-service testing
  • Best-practice findings without a demonstrable exploit path

How to report

Email [email protected] with a clear technical description, reproduction steps, and the impact you observed. PGP key issued on request once first design-partner contracting begins. Researchers will be credited in security acknowledgments. That page is published as soon as the first valid report is received.

Incident response: when we detect it

Procedures are documented; the first tabletop rehearsal is scheduled before the first design-partner pilot goes live. Customer-notification timelines below are set out in the pilot agreement.

Notification timing (target commitments)

  • Sev-1 (confirmed customer data exposure or loss): notification to affected customers within 24 hours of confirmation, with regulatory authorities notified per applicable jurisdiction (GDPR Article 33, state laws).
  • Sev-2 (security incident with potential customer impact): notification within 72 hours of confirmation.
  • Sev-3 (security event with no customer impact): disclosed in the next monthly security update; included in the public incident log, which is published from the first design-partner pilot onward.

Response capacity

At the design-partner stage, the founder is the on-call line. Response timing is human-paced, not 24/7 SOC-paced, committed in writing in the pilot agreement. Current on-call structure is published on this page as it evolves.

Performance targets: architectural commitments

Design-partner targets, not measured production SLAs: measurement begins with the first paid pilot, and these tighten as the platform runs under real load.

OpsATC.AI performance targets for the design-partner stage.
MetricDesign-partner targetStatus
Recommendation latency (p50)< 8s end-to-endArchitectural target
Recommendation latency (p95)< 30s end-to-endArchitectural target
API availability99.5% best-effortArchitectural target
Audit-log query (p95)< 1s at the per-tenant indexArchitectural target
Adapter health check5-minute cadenceArchitectural target
09 · Change-of-Control

Strategic independence, in writing

OpsATC.AI is built to operate independently of any single distributor, ERP vendor, or supply chain platform. We include explicit change-of-control protections in the pilot agreement so an acquisition cannot leave you stranded.

Design-partner change-of-control terms

  • Perpetual license to the version of the platform you are running at the moment of an OpsATC.AI change-of-control event.
  • Source-code escrow with a recognized third-party escrow agent. The escrow account is established at the first design-partner contract execution; release triggers include change-of-control, business-continuity events, and material breach.
  • Defined transition window: no less than 12 months, during which the platform continues to operate at current pricing and SLA terms regardless of acquirer intent.
  • Right of first refusal on data extracts, configuration exports, and tenant-isolation guarantees during the transition.

These terms are set out in the pilot agreement, available for review under NDA prior to engagement.

10 · Portability & Exit

Built to be replaced, gracefully

Every connector is designed to ship with a documented schema. Every workflow is designed to export as YAML. Every audit log is designed to be portable. We don't trap data, and we don't lock you in. The fastest way to lose a long-term customer is to make them feel imprisoned, so we are building the exits in parallel with the entrances. Export capabilities are available from the first design-partner pilot onward.

What you can take with you

  • All customer data, in JSON or CSV, via the Admin Portal export, target latency in minutes, available from the design-partner pilot onward.
  • Workflow definitions exported as portable YAML, suitable for re-import to a different orchestration platform.
  • Audit logs, complete history, via the same export channel.
  • Connector schemas documented for every integration you connect so you know exactly what each connector reads: the read-only doctrine means no adapter writes to a system of record.
  • Configuration backups on demand, or scheduled to a customer-controlled S3 bucket. The scheduled-S3 path lands with production hardening, post-pilot.
11 · Common Questions

Buyer questions, answered straight

Strategic-objection questions we hear from security teams, data leads, and operations buyers during evaluation. Pilot-scope and architectural-pattern markers are preserved: what ships today versus what lands during the pilot is called out in each answer.

By design, KPIs live in a per-tenant configuration: each metric carries a definition (formula, source systems, refresh cadence, owner, threshold bands). Each vertical ships with a pre-tuned KPI set, with per-tenant values; the demo defaults are a starting template, not a prescription. Self-service editing (hide KPIs you don't use, change a numerator, retune thresholds, or add a custom KPI sourced from your own data) is the architectural pattern and lands during pilot. The configuration surface (Admin Portal → API & Integrations and the Internal Ops / Service Portals → Master Data Domain Health views) shows the direction.
Every KPI is traceable end-to-end by design. The KPI definition registry names the source system, query/field, transform, refresh cadence, and owner for each metric, so the math is auditable, not a black box. The data-quality layer is designed to run schema, freshness, and null/range checks so failed checks surface as data-quality breakpoints rather than silently wrong numbers; today those checks run on demand, with continuous and inline-at-ingest modes on the roadmap. See Internal Ops / Service Portals → Master Data Domain Health and Data Lineage & MDM Health for the lineage and quality surfaces, plus Admin Portal → Data Harmonization for the binding configuration. The visual lineage view in the demo is the architectural pattern; full per-cell drill-to-source UX lands during pilot scope.
Yes, by design. Each tenant has a private knowledge library (PDFs, .docx, .xlsx, .csv, slides, plain text, meeting/call transcripts) that The Captain is designed to retrieve from at query time, the same architectural pattern as a private project workspace, but scoped to your tenant. Files are stored in your per-tenant encrypted bucket (customer-managed keys via your KMS are on the roadmap), never train the underlying model (we do not train models on your data), and are never discoverable to other tenants. Limits: per-file size caps and per-tenant aggregate caps are configurable per tenant in the pilot agreement; file-type whitelist; soft-delete and archival today (cryptographic erasure on the roadmap); versioning preserves audit history when a document is updated. At query time The Captain is designed to use retrieval to pull only the most relevant chunks into the model's context window (the retrieval layer ships during the pilot), so the practical "absorb" limit is the size of your library, not the per-call context. Refresh cadence, access roles (e.g., this folder is Finance-only), and tagging are configurable per folder. The upload UX, chunk-tagging, and retrieval-debug surfaces are the architectural pattern; specific library shape and governance roles are configured during pilot scope.
Common case, and not a blocker. OpsATC.AI is designed to be source-of-record agnostic: a process backed by spreadsheets, a homegrown DB, an on-prem app, or email/PDF can still be orchestrated. The pattern: define the canonical entities and KPIs in the OpsATC schema, then bind whatever source you actually have (file drop, SFTP, scheduled CSV/Excel pull, DB view, API, EDI) to those entities. The Captain operates against the canonical model, so swapping in Kinaxis later doesn't break the workflow. See Admin Portal → API & Integrations and Data Harmonization for the binding surface. Generic ingestion adapters are part of the architecture; specific source-system bindings are scoped per pilot.
Yes. Ingestion paths beyond SaaS connectors include scheduled CSV/Excel pulls over SFTP, DB views over flat-file landings, and drag-and-drop file upload (see Customer Portal → Forecast Upload for the pattern). SharePoint (metadata/preview), OneDrive, S3, and email-attachment intake are on the roadmap. Each source is designed to register in the connector registry with a schema contract so spreadsheet-fed KPIs carry the same lineage signal as SaaS-fed ones; validation rules and freshness SLAs are the architectural pattern. The architectural pattern is in place; specific spreadsheet bindings (which file, which sheet, which columns map to which canonical fields) are configured per workflow during pilot.
Three layers, in order: prevention, in-the-moment correction, learning across time.

1. Prevention via grounding. The Captain doesn't generate from training data; she's retrieval-grounded against your tenant's data: KPI definition registry, knowledge library, system-of-record reads. When she lacks the source to answer a question, she's instructed to say "I don't have that" rather than guess. Hallucination risk drops sharply when the model isn't filling in gaps.

2. In-the-moment course-correction. Every Captain output that touches a system of record is gated behind a human approval queue (per ADR-0020, our Trusted Advisor Doctrine). If she drafts the wrong allocation letter, proposes the wrong reroute, or surfaces a wrong number, the workflow owner edits or rejects in-line. Nothing executes upstream until a human signs off. The cost of a mistake is small because she's read-only by default and write actions are gated. Each correction is captured to a per-tenant feedback ledger: what she said, what was wrong, what the correction was, who corrected it.

3. Learning across mistakes. Two mechanisms operate on the feedback ledger:

(a) Per-tenant prompt + retrieval tuning: your TAM reviews the ledger weekly; recurring corrections become updates to your prompt templates, KPI definitions, and retrieval filters. Same underlying model, sharper steering for your specific business.

(b) Eval-suite expansion: significant errors become regression tests in your tenant's eval suite. Before any prompt or retrieval change ships, the suite re-runs to confirm the prior failure mode is gone and nothing else has regressed.

The Captain does not fine-tune on your data (we do not train models on your data). The "learning" happens at the prompting + retrieval + eval layer, which is the layer you control. The feedback signal is captured and audit-logged today; the governance dashboards (feedback ledger, prompt-version diff history, eval pass/fail) are on the roadmap. The specific feedback UX and weekly TAM review cadence are scoped during pilot.
This is the design. Recommendations carry a priority and a default decision window today; the computed "act-by" deadline below (forward-chain plus buffer math) is on the roadmap.

The pattern (architectural):

1. Forward-chain math. When The Captain identifies an action (e.g., "issue PO to your supplier for capacitors"), she traces forward through the dependent commitments she can see: supplier lead time → inbound logistics → receiving dock slot → quality inspection → clear-to-build → production start. The earliest downstream commit becomes the latest-by date.

2. Buffer subtraction. From latest-by she subtracts known variability: supplier lead-time variance, customs-hold probability for that lane, your contract manufacturer's published build-prep window. The result is the recommended-by date: when the action should be taken to keep downstream commitments intact with reasonable confidence.

3. Two clocks on each action. Recommended-by (the comfortable date) and latest-by (the hard deadline). Each urgent-action card shows both, plus a visible countdown and the specific downstream commit that breaks if missed (e.g., "PO latest-by May 28, 14:00 PT: June 4 build start at risk if missed").

4. Re-computation on change. Deadlines recompute whenever upstream inputs shift: supplier ETA changes, dock slot moves, customs clears earlier than projected, etc. If a deadline crosses from comfortable → at-risk → missed, the urgent-action card escalates severity, pages the owner, and (if configured) escalates upward.

What you control:

• Which downstream commitments count as hard deadlines (build starts, customer SLAs, regulatory windows) vs. soft (preferred internal cadence)
• Buffer policy per workflow (conservative / balanced / aggressive)
• Notification cadence and escalation tiers (owner → manager → exec)

The Internal Ops Portal → Urgent Actions queue surfaces priority-ranked urgent actions today; the act-by countdown, forward-chain math, and per-workflow buffer policy are on the roadmap, configured per workflow during pilot scope.
No. Every operation's data is dirty when we start: stale records, missing identifiers, duplicate keys, two source-of-truth systems disagreeing about the same SKU. The legacy answer is a six-month data-cleanup project before the tool produces its first useful output. The Captain's answer is different: the data-quality detection layer surfaces issues alongside the answer they affect. On-demand checks run today; continuous, scheduled, and inline-on-read modes are on the roadmap. The platform produces value on day one. The cleanup happens in parallel, prioritized by operational impact, owned by the operators who already know the records best. See the full Data Governance architecture on the Approach page.
Six issue classes, detected through four layered modes.

The six classes: (1) Staleness: records past the last-touch window your operators trust for that record type. (2) Missing identifiers: records lacking the linking key needed to join across systems. (3) Duplicate keys: a primary key that appears more than once where the schema declares it unique. (4) Source-of-truth contradiction: two systems that should agree about a record but do not. (5) Schema drift: source-system fields renaming, retyping, or repurposing without notice. (6) Reference-data gaps: lookups missing from the lookup tables.

The four modes (design): Baseline scan at connection (establishes reference cardinality and value distributions); inline checks on every read The Captain performs (catches drift as it happens); scheduled background sweeps per record type (catches what inline missed); operator-triggered deep dives (answers specific reconciliation questions). Today, operator-triggered (on-demand) checks run today; the baseline, scheduled, and inline-on-read modes are on the roadmap. The modes are layered, not alternative: no single mode is sufficient alone.

Severity-graded signal: informational findings stay in the background; threshold-crossing findings surface inline with the answer they affect; material findings escalate to a named owner. The Captain is not the girl who cried wolf. Thresholds are tunable per record type, per portal, per role.
No. The four-tier data sensitivity model puts Social Security numbers, passport numbers, bank account numbers, Protected Health Information, GDPR Article 9 special-category data, 42 CFR Part 2 substance-abuse records, and COPPA minors data in a Forbidden tier. Our connectors are designed not to retrieve this data, and it is filtered at the connector boundary rather than passed to The Captain. No system can stop a person from typing sensitive data directly into a prompt, so this is a strong design control, though no automated control is absolute, and we pair it with customer guidance and access controls.

The Identifying tier (employee names, employee numbers, customer IDs, initials) is DEFAULT DENY and is not accessible in-product today. The elevation policy (express written customer permission per tenant, a signed DPA, a per-tenant policy flag, and two-person admin approval, all audit-logged) is defined and will be enforced when that access path ships. Operational data (SKUs, POs, lead times, inventory levels) is default-allow and unrestricted. Public data is unrestricted. This four-tier model is defined doctrine; enforcement is being built into the product in stages and is not yet active in the pilot. HR, EHR, payroll, and healthcare connector real-implementation elevation is blocked until the field-schema + tenant-policy framework lands. The model + enforcement code paths are available for review under NDA.
Security Contact

How to reach us

At the design-partner stage, every security-related inquiry routes to the founder directly. Mail to [email protected] reaches the same inbox. No ticket queue, no triage layer, no auto-responder.

All security, privacy, vulnerability, and founder-direct correspondence
Security-team questions, DPA requests, vendor security questionnaires: acknowledged within one business day.
Vulnerability reports: PGP key available on request; acknowledged within one business day; credited in security acknowledgments unless you prefer otherwise.
GDPR / CCPA / CPRA subject-of-data requests: acknowledged within five business days, fulfilled within 30 days.
Design-partner conversations, board-level concerns, escalations: direct to the founder, always.

A versioned PDF of this Trust Center, plus the procurement-grade SECURITY_POSTURE one-pager, is available on email request. NDA available before any document leaves our environment.