Glossary

Plain-English definitions for the terms, acronyms, and concepts used across Codifide's projects. If something on the site confused you, it's probably here.

Codifide Language

intent: A required string on every Codifide function that declares why it exists — not what it does. Unlike a comment, it's part of the function's structure and included in the content hash. Two functions with different intents have different identities even if their code is identical.
effects: A declaration of what side effects a function is allowed to produce — for example {io.write} or {http.fetch}. Enforced transitively: a function that calls another function inherits its effects. A pure function (effects {}) cannot call an impure one without declaring the effect.
contracts (pre / post): Preconditions and postconditions attached to a function that the runtime actually evaluates at call time — not documentation. A precondition must be true before the function runs; a postcondition must be true after. Contracts run with an empty effect budget, meaning they can only read state, not change it.
confidence / conf(): A numeric score between 0.0 and 1.0 attached to a value indicating how certain the system is about it. conf(label) retrieves the score. Confidence is a first-class value in Codifide — you can dispatch on it, gate on it, and refuse when it's too low.
believe / belief dispatch: A Codifide keyword that routes program flow based on the confidence score of a value. believe label ge(conf(label), 0.85) => label else => bottom means "if confidence is at least 85%, return the label; otherwise refuse." This is belief dispatch — making decisions based on probability, not just value.
bottom: A Codifide value — not an exception — meaning "I don't know enough to answer." A function returns bottom instead of guessing. As of v3.0, it can carry a reason: bottom "confidence below threshold". The runtime propagates bottom and raises a RefusalError if it escapes unhandled.
sig: Short for "signature." Declares a function's input and output types, e.g. sig (message: String) -> Label. As of v4.0, these are enforced at runtime — passing the wrong type raises a TypeViolation.
cand: Short for "candidates." The body of a Codifide function — a list of expressions the runtime evaluates in order to produce a result. Each candidate can have a when guard that controls whether it runs.
content-addressed / content addressing: A system where code is identified by the cryptographic hash of its contents, not by a name or version number. If the code changes, the hash changes — so the hash is the identity. Two agents with the same hash are looking at the same code, subject to the strength of the hash function.
canonical form: The single, deterministic byte representation of a Codifide function. The same function always serializes to the same bytes, which always produce the same SHA-256 hash. This is what gets stored in the registry and verified on every fetch.
pure function: A function with no side effects — it only reads its inputs and returns a value. Declared with effects {}. Codifide enforces this: a pure function cannot call an impure one without declaring the effect.
call graph: The map of which functions call which other functions. Codifide enforces effect declarations transitively across the entire call graph — you can't hide an effect by burying it in a helper function.
RPC / RPC API: Remote Procedure Call. A way to call functions over a network as if they were local. The Codifide server exposes an RPC API so agents can publish and fetch symbols over HTTP using standard POST and GET requests.
capability manifest: A machine-readable JSON document (capability.json) describing what the Codifide runtime can do — its primitives, effects, error types, and links to human-readable docs. Agents fetch this to understand the runtime without reading source code.

Data & Formats

CBOR: RFC 8949 — Concise Binary Object Representation. A compact binary data format — think of it as a binary version of JSON that's smaller and faster to parse. Codifide uses CBOR to serialize functions for storage and transmission. The same data that JSON represents in ~200 bytes, CBOR often represents in ~80 bytes. RFC 8949 ↗
SHA-256: A cryptographic hash function that produces a 256-bit (64 hex character) fingerprint of any data. Used as the identity of every Codifide symbol. The same input always produces the same hash; any change to the input produces a completely different hash. Appears throughout the registry as sha256:<64 hex chars>.
JSON: JavaScript Object Notation. A human-readable text format for structured data. The Codifide registry returns CBOR by default but JSON on request (Accept: application/json). Most developers are already familiar with JSON.
Bearer token: An HTTP authorization mechanism: Authorization: Bearer <token>. Required to publish symbols to the Codifide registry. Anyone can read; only holders of the write token can publish.
TLS: Transport Layer Security. The protocol behind HTTPS — it encrypts data in transit so it can't be read or tampered with between client and server. When you see https://, TLS is running underneath.
CDN: Content Delivery Network. A distributed network of servers around the world that caches content close to users. The Codifide registry does not currently use a CDN for symbols: they are served by the site’s own API with caching turned off.
AST: Abstract Syntax Tree. The internal tree structure a parser builds from source code. When Codifide parses a .cod file, it produces an AST before executing or serializing the code.
OAuth: Open Authorization. An industry-standard protocol for delegated access — letting one application access resources on behalf of a user without sharing passwords. Commonly used in healthcare data platforms for SMART on FHIR integrations.

Healthcare terms

HIPAA: Health Insurance Portability and Accountability Act. U.S. federal law governing the privacy and security of patient health data. Any system that stores or processes protected health information (PHI) must comply. Non-compliance carries significant fines.
FHIR: Fast Healthcare Interoperability Resources (pronounced "fire"). The modern standard for exchanging healthcare data between systems — EHRs, apps, payers, and analytics platforms. "FHIR-native" means the platform speaks this standard natively rather than requiring translation layers.
EHR: Electronic Health Record. A digital version of a patient's medical chart — diagnoses, medications, lab results, visit notes, and more. The major EHR vendors are Epic, Cerner, athenahealth, and eClinicalWorks.
MIPS: Merit-based Incentive Payment System. A U.S. Medicare program that adjusts physician payments up or down based on performance on quality, cost, and improvement measures. Providers must report MIPS data annually.
HEDIS: Healthcare Effectiveness Data and Information Set. Standardized performance measures used by health plans to evaluate care quality — for example, "what percentage of diabetic patients had an A1C test this year?" Used by nearly every major U.S. health plan.
fail-closed: A safety design principle: when something is uncertain or missing, deny access rather than allow it. The opposite is "fail-open" (allow by default). "No implicit tenant fallbacks" means if a user's organization can't be determined, they get nothing — not a default view.

Technology

OCR: Optical Character Recognition. Technology that converts images of text into machine-readable text.

AI Governance

Codifide Harness: Codifide's framework for governing AI-native software development, and the name of its free open-source harness. It is based on Robert G. Cooper's Stage-Gate® model. The human still makes the decisions. Codifide Swarm is a separate commercial product for governing a swarm of agents.
Codifide Swarm: A private commercial product, in development and not generally available, that governs a coordinated swarm of agents. The free Codifide Harness governs an agent, or several concurrent sessions each in its own git worktree, working one codebase. Codifide Swarm is for coordinated lanes across many codebases or entities. About Codifide Swarm
Stage-Gate® framework: A product development process (Stage-Gate®, created by Robert G. Cooper; a registered trademark of Stage-Gate International and R.G. Cooper & Associates) that divides a project into stages separated by "gates" — explicit go/kill decision points where a project must demonstrate evidence before proceeding. The Codifide Harness project adapts this for software built by AI agents.
agentic AI / agent era: AI systems that autonomously take sequences of actions to complete goals — writing code, running tests, deploying software — rather than just answering single questions. "The agent era" refers to the period we're entering where AI agents are active participants in software development, not just assistants.
adversarial review: A review conducted by a party whose explicit job is to find problems, not validate the work. In Codifide Harness, the B-Team reviewer uses a different AI model with a hostile persona — its job is to break the work, not approve it.
Zero-Context auditor: A reviewer who reads the work with no prior context about the project — simulating how a regulator, external auditor, or new team member would approach it. If the work can't be understood cold, it fails the gate.
gate pass: Approval to proceed from one stage to the next. Requires concrete evidence — test coverage reports, security sign-offs, accessibility audits. "We think it's fine" is not a gate pass.

General

idempotent: An operation that produces the same result whether you do it once or many times. Publishing the same symbol to the Codifide registry twice is idempotent — the second publish returns the same identity as the first, with no duplicates or errors.
hash-verified: After fetching a symbol from the registry, the client recomputes the SHA-256 hash of the received bytes and confirms it matches the requested hash. If they don't match, the bytes are rejected. This means the registry cannot serve tampered code — any change to the bytes changes the hash.
footgun: Developer slang for a feature or behavior that makes it easy to accidentally cause a hard-to-debug error. "Shooting yourself in the foot." The bind-before-when pattern in Codifide was a footgun — fixed in v2.0 by making it a parse error with a clear fix message.
liveness check: A simple health endpoint (/health) that returns {"status":"ok"} to confirm a server is running and reachable. Used by monitoring systems to detect outages.
audit trail: An immutable log of who accessed or changed what, and when. Audit logging is among the controls commonly used to support HIPAA obligations; this entry is not compliance advice. If a clinician views a patient record, that access is logged and cannot be altered retroactively.

Long-form definitions

Longer explanations: Agentic SDLC · Intent integrity · Loop engineering · Domain expert persona · Independent verifier