Core Concepts

Understand the building blocks of Aguardic — policies, rules, evaluations, violations, and more.

Policy

A policy is a named collection of rules that define what to check and how to enforce it. Policies have lifecycle states: Draft, Active, and Deprecated.

Each policy specifies an enforcement mode:

BLOCKPrevent the action from proceeding

APPROVAL_REQUIREDHold the action for manual review before proceeding

WARNAllow but flag for review

MONITOR_ONLYLog silently for audit purposes

Rule

A rule is a single check within a policy. Each rule has:

TypeEither DETERMINISTIC or SEMANTIC (see below)

SeverityLOW, MEDIUM, HIGH, or CRITICAL

MessageOptional message shown when the rule is violated

Rules are evaluated in order. You can configure policies to stop on the first violation or evaluate all rules.

Deterministic Rules

Deterministic rules use field-level conditions with operators. They evaluate in milliseconds with no external calls.

Each rule contains one or more conditions — a field, an operator, and a value to compare against. All conditions in a rule must match for the rule to fire.

Semantic Rules

Semantic rules use an LLM to evaluate content against a natural language prompt (e.g., "Does this message contain manipulative language?"). They can optionally reference a knowledge base via knowledgeBaseId to ground the evaluation in your organization's documents using RAG.

Semantic rules handle nuanced checks that field-level operators can't express — tone, intent, context, and domain-specific reasoning.

Condition

A condition defines a single field-level check within a deterministic rule. It has three parts:

FieldThe data field to inspect, using dot notation (e.g., content, user.email, file.size)

OperatorHow to compare (see full list below)

ValueThe value to compare against

Supported operators:

Field	Type	Description
`CONTAINS / NOT_CONTAINS`	`operator`	Substring match
`EQUALS / NOT_EQUALS`	`operator`	Exact match
`MATCHES / NOT_MATCHES`	`operator`	Regular expression
`IN / NOT_IN`	`operator`	Value in a set
`GT, GTE, LT, LTE`	`operator`	Numeric comparison
`EXISTS / NOT_EXISTS`	`operator`	Field presence check

Knowledge Base

A knowledge base is a collection of documents that power the RAG evaluation layer. Upload your compliance docs, internal policies, or customer contracts, and the engine will evaluate content against them using vector search.

Knowledge bases are referenced by semantic rules to ground LLM evaluation in your organization's own context.

Policy Set

A policy set is a named bundle of policies that can be managed and bound as a single unit. Instead of binding policies to integrations one by one, create a policy set, add the policies to it, and bind the set.

Grouped bindingBind an entire set to an integration or AI system in one action

OrderingControl the evaluation order of policies within the set

Per-policy toggleEnable or disable individual policies within a set without removing them

TagsCategorize sets for easier filtering and organization

When a policy set is bound to an integration, all enabled policies in the set are evaluated in sort order during each evaluation.

Policy Binding

A policy binding links a policy or policy set to a specific integration or AI system. When an evaluation request comes in via that integration's API key, all bound policies (including those inside bound policy sets) are automatically evaluated. This lets you control exactly which policies apply to which endpoints.

Integration Type

An integration type categorizes the source of content being evaluated. Aguardic supports:

vcsVersion control (PRs, commits)

aiLLM requests and responses

storageFile content

emailEmail content

messagingChat messages

apiGeneric API content

Evaluation

An evaluation is a single run of one or more policies against a piece of content or an event. The result is one of:

ALLOWNo violations found

WARNViolations found but enforcement mode allows continuation

BLOCKViolations found and the action is blocked

APPROVAL_REQUIREDViolations found and the action is held for manual review

Violation

A violation is a record of a rule that was triggered during an evaluation. Each violation includes:

Field	Type	Description
`ruleId`	`string`	The ID of the rule that fired
`ruleName`	`string`	The name of the rule
`severity`	`enum`	LOW, MEDIUM, HIGH, or CRITICAL
`resolvedAction`	`enum`	The enforcement action taken (BLOCK, APPROVAL_REQUIRED, WARN, or LOG)
`explanation`	`string`	Why the rule was triggered
`field`	`string`	The data field that matched
`snippet`	`string`	The matched content excerpt

Violations follow a lifecycle: NEW (just created) -> ACKNOWLEDGED (reviewed by a team member) -> RESOLVED (addressed) or DISMISSED (determined to be a false positive).

Session

A session groups related evaluations together. For example, an AI agent conversation might create a session that contains multiple evaluations — one for each message or tool call. Sessions provide context for investigation and audit.

Sessions track:

Field	Type	Description
`actionCount`	`number`	Total number of actions evaluated
`dataTags`	`string[]`	Tags extracted from evaluated content
`toolsUsed`	`string[]`	List of tools the agent invoked
`Action chain`	`object[]`	Ordered sequence of all actions in the session

Session statuses: ACTIVE (in progress), COMPLETED (finished normally), EXPIRED (past expiresAt timestamp), TERMINATED (ended due to policy violation or manual stop).

AI System

An AI system represents a registered AI-powered application — such as a chatbot, code assistant, or autonomous agent. Each AI system tracks:

Risk classificationMINIMAL, LIMITED, HIGH_RISK, UNACCEPTABLE, or UNCLASSIFIED

Data categoriesWhat data it processes (PII, PHI, FINANCIAL, etc.)

Affected subjectsWho is impacted (CUSTOMERS, PATIENTS, EMPLOYEES, etc.)

Deployment statusDEVELOPMENT, STAGING, PRODUCTION, or DEPRECATED

Linked integrationsWhich integrations this system uses

System ownerThe person accountable

Aguardic can auto-suggest a risk classification based on data categories and affected subjects. See the AI Systems guide for details.

Marketplace Policy

A marketplace policy is a pre-built governance policy published to the Aguardic Marketplace. The catalog includes policies across categories like security, compliance, data governance, and AI safety. You can install marketplace policies in two ways:

SubscribeCreates a managed, read-only policy that auto-syncs when the publisher releases updates

ForkCreates a one-time copy that you own and can edit freely (no future updates)

Subscribed policies are tagged [Managed] and forked policies are tagged [Template] in your policies list. See the Marketplace guide for details.

Network Policy

A network policy is a compliance policy shared between organizations via a network connection. The receiving organization gets a read-only shadow copy that auto-syncs when the source updates.

Key concepts:

Network connectionA bilateral relationship between two orgs (INVITED → ACTIVE or REVOKED)

Shadow policyA read-only copy in the receiving org, bindable to their integrations

Auto-syncWhen enabled, shadow policies update automatically when the source publishes a new version

See the Network Policies guide for setup details.

Quickstart JavaScript / TypeScript