Compliance and trust posture
Security and compliance in Vectros are not a feature toggle layered on after the fact —
they are design constraints that shaped the data model, the request path, the deployment
topology, and the operational posture from the first commit. Tenant isolation is enforced
structurally at the data layer; credentials are validated at the edge before any
application code runs; every public surface terminates TLS and every storage surface is
encrypted at rest; and the data-plane inference path runs inside the Vectros
perimeter so sensitive content on that path does not cross the boundary to a third-party
model host. This describes the platform-hosted model path. A call you route to your own
model provider (providerAlias, which needs a risk-acceptance waiver on your account) is
processed where your provider processes it, leaves the Vectros perimeter, and is not subject
to your residency settings. Calls you configure to your own endpoints leave the Vectros boundary at your direction; processing there is yours. The same posture applies on every plan tier — the architecture is
identical across tiers.
The sections below are written for regulated and healthcare workloads and state what the platform does and does not do.
This page is the posture-level trust narrative. The operational mechanics of webhooks, usage, and teardown live in the sibling explanation, how-to, and reference pages.
A note on legal scope. This page describes engineering mechanisms and the security posture. It is not a legal representation about specific regulatory coverage. Terms like HIPAA applicability, Business Associate Agreement coverage of any given subprocessor, data-residency obligations, and retention determinations are contractual and counsel-gated; nothing here should be read as a binding statement on those.
The three sensitive-data mechanisms
Vectros handles sensitive fields through three separate, complementary mechanisms. They are often confused with one another, so it is worth being precise: they operate at different points in the data lifecycle and protect against different things. A field marked sensitive on its schema is covered by all three.
1. Redact-at-write — sensitive fields are destroyed before they are persisted to history
When a record or document carrying a sensitive field is written, that field's value is redacted out of the retained version history and the structured change-diff at write time — before anything lands in durable history. This is not reversible masking: the value is not stored-and-hidden, it is destroyed before persist. No scope, no credential, and no later request can recover it from history, because it was never written there. This is what keeps sensitive values out of the retained audit trail. If an object's schema can no longer be loaded, nobody can say which of its fields were sensitive, so every payload value is redacted from the history (the field names are kept), nothing of it is indexed for search, and the object is no longer served.
The same principle protects internal secrets: a webhook's signing secret, for example, is stored on its live configuration row (delivery-time signing needs it) but is replaced with a one-way hash in the retained history, so rotating the secret is still distinguishable from leaving it unchanged without the raw value ever entering the audit record.
2. Read-time masking — sensitive fields are masked on read unless the token reveals them
When a record is read back, sensitive fields are masked in the response unless the calling token carries the explicit reveal scope for sensitive data. A token without that scope sees the record with its sensitive fields obscured; a token that has been deliberately granted reveal authority sees the cleartext. This is the runtime access control on sensitive data still present in live rows.
3. Search-exclusion — sensitive fields are excluded from the search index at index time
Sensitive fields are excluded from the search index at index time. They are never embedded, never tokenized, never written into any search representation. A search query — semantic, keyword, or hybrid — does not match, rank or return a sensitive value, because it is not written to the index.
Why three and not one. Redact-at-write protects history; read-time masking protects live reads; search-exclusion protects retrieval. A single mechanism at any one of these points would leave the other two exposed. Together they mean a sensitive value is destroyed in history, masked on read, and absent from search — three independent mechanisms, not one mechanism restated.
Audit and version history, retained
Versioning and deletion are first-class platform primitives, not features you wire up.
- Every write to an audited model accrues a version record capturing what
changed, who changed it, and the prior content (with sensitive fields already redacted per
the mechanism above). When an agent run made the change through one of its tools, the entry
also names that run (
actingVia), beside the credential whose authority the change used. Deletions leave a tombstone. Audit history is on by default for a typed record or document and can be switched off per schema (capabilities.auditHistory: false); untyped documents carry no version history. - History carries a hash chain. Each retained record includes a SHA-256 hash link to the prior state, a basis for integrity checking. The hashes are stored with the history but are not returned by the API, and Vectros does not ship a verifier for the chain. It is a hash chain, not an immutable store.
- Heavy history is externalized to a retention-locked object store with a
default retention horizon on the order of seven years. Compliance history is dispositioned
only through a policy-aware path, never by silent auto-expiry. The retention lock cannot be
removed by an ordinary delete (which only hides an object): removing a stored payload early
takes a privileged, governance-bypassing erase. Vectros uses it for end-subject
purge, context and tenant teardown, and thedeleteretention disposition.
This data-layer audit trail is distinct from the operational activity log (the recent-API-calls view) — the former is retained compliance history, the latter is an operational debugging surface.
Tenant and context isolation
Isolation in Vectros is structural — shaped by the data model and the data-access API, with automated tests guarding the invariants. Several invariants together form the externally observable behaviour:
- Tenant-scoped data access. Every data lookup is shaped so it cannot be expressed without the tenant boundary; there is no path that returns another tenant's rows by accident.
- A mandatory, fail-closed context partition. Beyond the tenant boundary, each application context is an additional fail-closed partition on records, documents, folders, and schemas — derived from the credential, never defaulting to a wildcard. This is the per-customer / per-application isolation moat that the no-code path and multi-tenant apps build on.
- Uniform "not found" responses. A caller probing with another tenant's id gets exactly the same status and response shape as a caller using an invented id — verifiable from the outside with two requests. The same uniformity applies to out-of-scope rows: an in-tenant row your token may not see returns the same shape as a row that does not exist. Error messages are not a discovery channel.
- Per-tenant search isolation. Hybrid search inherits the same boundary — a query cannot return another tenant's content regardless of any query-time filter, and filter inputs are allow-list validated at the boundary so a crafted filter cannot break out of the tenant clause.
- Pagination cursors are sealed, not merely opaque. A cursor is an opaque token you should not parse, and it is cryptographically sealed rather than just encoded, so a caller cannot decode its contents. A cursor that advances past a row your scope filtered out of the results therefore reveals neither that row's id nor its sort-key value. (The cursor's byte length still varies with the sort-key length of a filtered-out row, which is not something a customer integration needs to account for.)
Per-customer and per-context hard-delete is implemented — decommissioning a customer's context or an entire tenant runs a real owner-filtered cascade, and it removes the audit history of the torn-down scope too, including the audit payloads stored outside the database. Deleting those payloads is asynchronous: a tenant teardown does not report complete until they are gone, while a single-context delete may finish just before its payloads are.
Named residual: the search index. A tenant teardown reports complete once no data of the tenant is accessible: none of its search records is left and every remaining entry in the search index is an orphan that Vectros never returns. It does not wait for the search index to delete the documents physically, because the index applies that deletion only when its stored segments mature. The tenant's search documents can therefore remain in the index storage, typically for about a week and at most 30 days after the teardown reports complete. The Vectros API does not return them, but a direct query of the index storage by someone with operational access to it still would during that window. A daily check flags a tenant whose documents are still in the index more than eight days after its teardown. A context delete and an end-subject erasure leave the same kind of residual for the search documents they erase, with the same bound, and the daily check covers them too. Recovery copies (point-in-time recovery and object versions) are a further bounded residual, see the backups paragraph under the right-to-erasure limits below. See explanation.md for why this is distinct from end-subject right-to-erasure.
Edge security and rate limiting
Every request crosses multiple security layers before it reaches application code: a global content-delivery edge with a web-application firewall, API origins configured to accept traffic only through the edge, and a dedicated authorizer that validates the bearer credential and emits an allow/deny decision. Application-layer enforcement — scope checking, body-size limits, per-tenant rate limiting — layers on top.
- Response-shape versioning never touches this layer. The
Vectros-Versionrequest header (see reference.md) lets a caller pin the shape of the fields and envelope it gets back. It has no effect on any of the enforcement above — authorization, tenant isolation, and quota enforcement are identical regardless of which version is requested, and a security fix ships to every version at once. There is no version of the API in which a scope check answers differently. - Two rate limits, two purposes. A high per-IP ceiling at the firewall edge is DDoS
protection — high enough that a legitimate server-to-server backend sails through, low
enough to cut off a single-source flood before it reaches application code. A separate
per-tenant business rate limit is enforced at the application layer and is selected from
the account's plan tier at request time. The two are independent and tuned for different
threats. Plain
GETreads pass the application limiter unthrottled; writes, deletes, searches,POST-shaped lookups, inference and starting an agent run count against the per-tenant budget. - Body-size and method caps. Request bodies are capped per route at the firewall and
re-checked a second time before any parsing, returning a
413if exceeded — a belt-and-suspenders pattern that also catchesContent-Lengthspoofing. File uploads do not flow through these body limits at all; they go directly to object storage via a presigned-URL handshake, so the request body the application sees is metadata, not bytes.
Webhook SSRF prevention
The webhook system has a registration-time defense-in-depth check plus a delivery-time enforcement gate. At registration, the hostname is resolved and the registration is rejected if any resolved IP is private, loopback, link-local, any-local, multicast, carrier-grade NAT, IPv6 unique-local, or the cloud metadata address. At delivery, the same classification runs again immediately before the POST, so a DNS-rebinding attack that resolves to a public IP at registration and a private IP at delivery is caught — and the offending registration is auto-disabled. The delivery-time check is the real security gate; the registration check exists to give immediate feedback and reject obvious garbage. See reference.md for the exact rejected ranges.
Security review
The customer-facing surfaces went through internal adversarial security review before launch, covering tenant isolation, scope enforcement, key construction, the edge, the authorizer, and the webhook machinery. The key invariants are covered by automated tests in the codebase. Changes to the codebase also go through automated dependency and static-analysis scans, and the pipeline fails on an unaccepted critical or high-severity finding; the same scans are re-run against the main code line on a weekly schedule. These are engineering controls, not a certification and not a third-party assessment (see the SOC 2 and penetration-test note below).
What is NOT covered / reserved
A scope boundary. Evaluate these explicitly for a regulated workload.
-
End-subject right-to-erasure is live, with limits to evaluate.
POST /v1/erasure-requestsstarts an asynchronous erasure of one subject (a user, or an ownership namespace such as an org or client). Data is swept in the contexts you list incontextScope; if you list none, every context in your account is swept, whether or not the subject holds data there.GET /v1/erasure-requests/{id}returns a certificate with per-context deletion counts, the number of shared rows that were skipped (retained, not erased) because they carry another owner, whether the subject's identity was kept (identityRetained), and a count of references to the subject taken before the sweep. It requires the root API key. The subject's solely-owned records, documents, folders and record schemas are erased;auditDispositiongoverns the audit trail (retain-redactedby default, orpurge). Limits:- The identity is account-wide, so only a request that covers every context deletes it.
The subject's identity (its user or entity record) is deleted when you omit
contextScopeor list every context of your account. The one exception is an entity that belongs to a single context (a context-owned namespace): its record is data of that context, so listing that context deletes it, andidentityRetainedis not set. Otherwise, a request that lists only some contexts erases exactly those contexts (including the subject's access grants in them), keeps the identity and every unlisted context, and setsidentityRetained: trueon the certificate. The subject still resolves, so you can send further requests; send one withoutcontextScopeto finish. Two partial requests never delete an account-wide identity. - Shared rows are retained. A row that also carries another owner is kept and counted, not erased; for a user subject, any row that carries an additional owner scope is kept.
purgeis supported for user, org and client subjects only; a request for any other subject type is rejected with400before anything is erased. It removes the audit records of the rows the request erased (never the history of a row that was retained because another owner shares it), the audit payloads stored outside the database for those rows, and, when the identity is deleted, the subject's own identity history. Deleting the stored payloads is asynchronous: the request completes once the audit records are gone, and the payloads follow shortly after. A payload delete that fails is retried and, if it still cannot complete, raised to Vectros operations, socompleteddoes not by itself prove every payload is already gone.purgedoes not consult your compliance-retention setting. Becausepurgeremoves the subject's own deletion records, the erasure request itself is the record of that erasure.purgefinds history through the owner each version carried when it was written, so it is a primitive, not a completeness guarantee: versions written while the row belonged to a different owner are not found, and the history of an already-deleted row that another owner shared is removed together with the erased owner's.- The reference count is taken before the sweep and only sees references held in a schema
referencefield that has a reverse index, in schemas of the contexts swept. A count of 0 does not prove nothing references the subject. - A job can end as
failed. A failure before the identity is deleted (the data sweeps, or removing the audit history of the swept contexts) leaves the subject in place, so you can resubmit the request (it is idempotent). Removing the subject's own identity history is the last step and runs after the identity is deleted: it is retried a few times automatically, and if it still fails the job is markedfailedwith the identity already gone, so the request can no longer be resubmitted; contact Vectros support.
Backups and recovery copies: an erased subject can remain in access-controlled recovery stores (point-in-time recovery, backups and object versions) for a bounded window whose contractual ceiling is set out in the Business Associate Agreement. Where Vectros restores data from a recovery store, it re-applies every erasure recorded in the erasure records available at the time of the restore before the restored data serves production traffic, uses commercially reasonable efforts, taking into account the circumstances of the incident, to identify and re-apply any other erasure, and notifies you if a restore may not have re-applied every erasure; this is performed as a documented manual procedure. Requests are asynchronous: poll the request until it reports
completedorfailed. Per-customer and per-context hard-delete is a separate, also implemented, operation. A data export endpoint (POST /v1/admin/export) is reserved and returns501today. - The identity is account-wide, so only a request that covers every context deletes it.
The subject's identity (its user or entity record) is deleted when you omit
-
Read-access logging / accounting-of-disclosures is available, but off by default. The mechanism to record and report who read a given subject's PHI is implemented: when enabled, per-subject reads are logged (metadata only — caller, time, subject, record, and whether any sensitive value was returned unmasked; no PHI payload), and the recorded accounting is queryable via the admin accounting endpoint. A read an agent run made through one of its tools also names that run (
actingVia), beside the caller whose authority it used. A disclosure into a model call that you route to your own provider also names the provider config's alias and the host of its endpoint (destinationAliasanddestinationHost). It is opt-in per context or per schema and off by default (a schema setting wins over the context default) — enable it for any workload that needs a §164.528-style read accounting. It records reads, lists, lookups, search results and RAG or document-ask disclosures, and reads of version history (GET .../versionson records, documents, entities, users and folders, logged as areadof the current record, against its current ownership), single reads and listings of folders (GET /v1/folders/{id}andGET /v1/folders), and aPOSTon records, documents, entities, users or folders that returns a resource which already existed, logged as aread. Exactly two such responses are covered: the idempotent return of an existing resource, and an?upsert=truecall whose content matched, so nothing was changed. Not covered: a create that creates, or an?upsert=truecall that changes the resource (both are writes); an item ofPOST /v1/records/batch, whose result carries only the record's id; and re-initiating a document upload, which returns no document content. The schema'sreadAccessLogsetting governs reads of entities and users as it does records and documents. An entity that belongs to an app context is logged in that context, whatever credential read it. Before 0.50.0, a read by a credential not confined to a single app context (a root API key, or a token or key whose context is*) was logged in thedefaultcontext, and entries written then stay there. A user has no context of its own and is logged in the reading credential's context. The version history of a deleted user is gated by the context default only, because the user's schema can no longer be read. It does not record reads of the deletion tombstone (GET /v1/records/{id}/tombstone), which returns no subject data (who deleted the record, when and why). One limit to evaluate: logging is best-effort — a failed log write is recorded in Vectros operations logs and does not fail the read, so a logged accounting is a primitive, not a completeness guarantee. Storage for these logs is billed at 5 credits per 100 MB per month, the same rate every other structured surface uses — this only affects accounts that turn the feature on. Each logged read adds a small row to that storage, including each page of a version-history read, so a client that pages through long histories adds billed log storage. -
Per-tenant data residency for data at rest is reserved. Where your records, documents, and search index physically live is bounded to the single deployment region per environment; an EU or other non-US residency option for stored data is not available today. (Inference serving region is a separate control — see the inference-region note below.)
-
Customer-managed encryption keys (BYOK / CMK) are reserved. All keys are platform-managed; bring-your-own-key is not available on any tier today.
-
Retention is controller-configurable, set through the developer portal. Account owners can set a compliance-retention duration and disposition (delete, retain, or retain-redacted) per tenant, with an optional per-context override; either level left unset falls back to the platform default of roughly seven years / retain-redacted. The control is available in the developer portal only — it is not exposed on the Vectros
/v1/*API. Disposition is applied by the same orchestrated, policy-aware purge path described above, never by raw TTL expiry, and retention is anchored as of write: shortening the window later does not retroactively shorten the retention already in force for rows written under the prior setting — with one exception: a row written while retention was set to indefinite carries no anchor at all, so if the tenant later moves off indefinite to any finite duration, that row falls back to the platform floor (whichever is longer of the new setting or ~seven years) rather than keeping its original "never expires" promise. When adeletedisposition removes an expired history row, the heavy payload stored outside the database for that row is removed too, at the controller's window — even if that window is shorter than the object store's default lock. That removal is asynchronous and follows the row delete shortly after. Expired history rows are dispositioned by a periodic background pass (weekly); a failed pass is retried on the next one. -
No SOC 2 report and no third-party penetration test. Vectros does not hold a SOC 2 report and has not had a third-party external penetration test, and does not represent that it holds either.
-
Inference region serving: US by default, global by opt-in, within bounds. Inference is served from a US region by default for every tenant, resolved fail-closed. A tenant entitled by a signed global-processing waiver may opt an individual request into a lower-cost global region via
allowGlobalRegion; the flag is rejected for tenants without that entitlement. This governs only where the model runs for a given request — not where your data is stored or indexed (see the data-residency note above), and it is not a per-region data isolation guarantee. -
Address geocoding. Address geocoding runs on Amazon Location Service under our AWS BAA; the location provider may process the address outside the US. Geocoding a record sends only its address to Amazon Location Service; nothing else about the record is sent. Addresses in Japan are not geocoded.
-
The in-perimeter / no-egress description is scoped to the data plane only. Sensitive content on the data-plane inference path stays inside the Vectros perimeter. This describes the platform-hosted model path. A call you route to your own model provider (
providerAlias, which needs a risk-acceptance waiver on your account) is processed where your provider processes it and leaves the Vectros perimeter. Your provider is engaged by you, not by Vectros, and what it does with a request is governed by your agreement with it. On an account that has accepted the Business Associate Agreement with Vectros in the developer portal, a routed call is a disclosure you direct, and Vectros makes it only through a provider config that an owner has attested (see the Search & RAG reference); that attestation is a record of your statement, not a representation by Vectros that the disclosure complies with any law. The API key you enter for your provider is stored encrypted under a platform-managed key when you create or update the config from release 0.48.0 on; a key stored earlier is read as it was stored and becomes encrypted the next time you enter it. If a stored encrypted key cannot be opened, the call is refused with503and nothing is sent to your provider. The agent-facing tool surface exposes Vectros data-plane tools only — the server itself makes no call to the web; a stored agent you run through it can fetch a public web page when its definition lists the web fetch tool, which also needs the tenant's owner to switch it on. Fetching a public web page sends only the page address to our fetch provider and to the website; you are responsible for any personal information included in an address that an agent you define requests. The in-perimeter boundary should be understood as a property of the data plane, not a whole-platform legal representation. Calls you configure to your own endpoints leave the Vectros boundary at your direction; processing there is yours. -
Your application's security is your responsibility. Vectros covers the platform boundary — the API, the data layer, the inference path, the developer portal, and everything inside the Vectros perimeter. Your own application's auth system, frontend and backend code, deployment posture, logging, and incident response are out of scope. The platform gives you building blocks for a regulated workload (isolation, redaction, audit history); it does not make your application compliant on its own.
-
The conversation state of the app's agent is set to expire. The stored conversation state of the agent in the Vectros app (message text and tool results), and the larger payloads kept outside the database, are configured to expire 30 days after each is written. This is the configured behaviour, not a promise about when a given item is physically removed, and an expired item cannot be restored. It is separate from the audit history and the
/v1/*data plane described above. -
Multi-region disaster recovery is not in scope today. Deployment is single-region per environment; point-in-time recovery and retained backups provide in-region recovery, but cross-region failover is not configured.
Where to go next
- explanation.md — the operational mental model: webhooks, the two-axis usage model, and the teardown-versus-erasure distinction.
- how-to.md — runnable recipes, including verifying a signed webhook delivery.
- reference.md — the exhaustive field, envelope, limit, and error catalog.
- The generated API reference (OpenAPI/Scalar) — the authoritative wire-level endpoint and schema listing.