Vector Search to Grounded Context: Animate the Write and Query Paths
Trace ingestion, embeddings, metadata filtering and retrieval with an interactive lab and runnable Python example.
Articles
Working notes on enterprise agent architecture, governance and the engineering underneath.
From Agentic AI to the Contextual Agentic Enterprise: How the Components Work Together
A research article on how business ownership, identity, knowledge, context assembly, agents, orchestration, policy, operational systems, evidence and improvement interact, followed through one fictional claim, the Commit Boundary, an uncertain response and a governed improvement loop. CAE is the author's proposed synthesis, distinct from Agentic Context Engineering (ACE).
AI Agents, Agentic AI and Enterprise Context: Follow the Decision
An animated architecture guide to bounded agents, orchestration, context and accountable action.
Who Does What in a Contextual Agentic Enterprise?
When AI agents join real workflows, accountability does not move to the model. Who owns the outcome, the limits, the system checks and the recovery, with one worked example and a 30-day start.
When Custom Software Gets Cheaper, the Work Moves to Trust
AI is making bespoke enterprise software cheaper to build. Building is only the first bill: integrating, securing, governing and operating it are where the work moves, and where CA proposes to help.
The Contextualised Enterprise: Connecting Agentic Reasoning to Governed Execution
A dual-lens architecture: contextual reasoning proposes, deterministic systems of record decide and commit, and evidence links the two. Includes a fictional procurement walkthrough, a policy gate tested in OPA, and a truthful treatment of evidence and transparency logs.
Choosing a Lakehouse for a Contextual Agentic Enterprise
A vendor-neutral way to compare Databricks, Snowflake, Google BigQuery and Microsoft Fabric for agentic workflows: the workload, governed context, access paths, cost, recovery, exit, and the service that commits an action.
Contextual Agentic Memory: What an Enterprise Agent Should Remember, Retrieve and Recheck
Agent memory is more than a bigger prompt or a vector store. Keep remembered evidence apart from business state, instructions and permission, control its lifecycle, and recheck before acting.
Beyond the Prompt Window: Contextual Thinking in Human Cognition and Autonomous AI Systems
Contextual thinking connects evidence, memory, constraints and feedback. A research essay on human cognition, agent architecture and the limits of autonomous action.
A Typed AI Decision Is Still a Model Judgment
Models that return a label from a fixed set, with probabilities, are easier to route, test and afford than free text. They are still model judgments. Calibration, abstention and routing are your design work, and the authority check sits outside the model.
Reactive or Agentic: Choose the Smallest Loop That Does the Job
A single model call, a fixed workflow and an agent loop are three different designs with three different cost profiles. Choose by whether the path can be known in advance, and keep authority outside all three.
Agentic Flow Mining: Discovering How Agents Actually Work
Traces show that each step succeeded. They don't show whether the steps formed an acceptable process. Mining agent runs against invariants does.
The Contextual Agentic Graph: Context Is Not Authority
A graph can connect enterprise meaning, source evidence and agent history. The harder design is deciding what an agent may read, what may become shared memory, and what may cause an effect. This article introduces the Contextual Agentic Graph (CAG), a proposed CAE design pattern, and shows where its boundaries sit.
Owning the Weights Is Not Owning the System: What Open-Weight Models Give an Enterprise
Open-weight models give an enterprise real and specific control: where inference happens, what the model is adapted on, what the unit economics look like, and whether the system still runs when the network does not. They do not transfer the supply chain, the regulatory obligation, the evidence or the contestability of knowledge. Those remain the enterprise's work.
Continuity Is Not Permission: The Engineering of Durable Agent Execution
Durable execution keeps a workflow alive across interruption. It does not keep it authorised. Four engineering objections to the architecture, and what actually answers them.
Better Models Won't Fix the Enterprise: Why Context Must Come Before Autonomy
Most enterprise AI programmes begin with a model question. The question that decides whether the initiative becomes useful and trusted is what the system is allowed to know, decide and do — and how anyone will prove it acted appropriately.
Six Frameworks Answer the Question. None of Them Ask Yours.
TOGAF, COBIT, ITIL, SAFe, programme management and enterprise risk each answer a real question about the enterprise. So do the AI management standards, and so do the vendor agent platforms. None of them answers the one that decides whether an agent should have acted.
Evaluation Is Not a Test Phase
Most agentic programmes pick a model, write a prompt, add retrieval, and write the evaluations last — by which point the evaluations can no longer change the design. Reversing the order gives an architect something better than an opinion: gates that show whether a model swap, a prompt change or a new retrieval strategy measurably improved the system.
The Arithmetic of Agent Cost
Agent cost is mostly input re-read on every turn. Multi-agent designs may read more tokens yet cost less per result, so budget each task and measure cost per successful task.
What Happens on the GPU When Your Agent Thinks
Prefill is compute-bound, decode is bandwidth-bound and the KV cache fills scarce GPU memory. That is why cached prefixes, small windows and short outputs make agents faster and cheaper.
What an A/B Test Cannot Tell You About an Agent
A/B tests assume a stable treatment, independent units and an observable outcome. Agents break all three, and the failures you fear are too rare to test for.
Compliance Is Not a Model Question: Constraints at the Integration Layer
Enterprise AI assurance is argued at the model boundary. The real control point is the integration layer, where the system asks to change something real.
Six Trust Boundaries for Multi-Agent Systems
An agent that reads untrusted content will one day be fooled. Security comes from six boundaries enforced in code, so a persuaded model still cannot do harm.
The Contextual Agentic Enterprise: A Formally Governed Architecture for Bounded Multi-Agent Systems in Mission-Critical Systems of Record
A formal account of how CAE separates probabilistic deliberation from deterministic commitment: definitions of the Context Contract, the Minimum Action-Evidence Bundle and the Deterministic Shell, the properties that hold under stated assumptions, an entropy-based admission criterion for autonomy, and a 14-case conformance run of a reference policy.
Beyond the Autonomous Sandbox: The Contextual Agentic Enterprise (CAE) and the Future of Corporate AI Governance
An autonomous agent demo has a token trace. A production security review needs evidence. This article sets out how CAE separates thinking from committing, using a fictional gas-turbine incident, and what an executive roadmap for governed agency could look like.
One Architecture, Four Platforms
A multi-agent design is portable; product names are not. Map categories first, then ask of every control feature whether it enforces or only records.
The Agentic Stack in Three Planes: Where Authority Actually Lives
The popular AI tool maps list a hundred products in two planes: what the agent knows and what it can do. The plane that decides what it may do is usually missing.
The Ten Layers Behind Every Multi-Agent System
A multi-agent demo has three boxes. Production has ten layers, each owning one job and failing in one familiar way. Most incidents start in a layer nobody owned.
Productivity Is Not Headcount Reduction: Designing the Human-Agent Enterprise
Minutes saved on a task are not roles removed from an organisation. Measure outcomes with quality, then redesign human work around authority, exceptions and evaluation.
The Agentic AI Playbook: Five Rungs from Model to Governed Enterprise
LLM, RAG, agent, agentic system: every popular diagram stops at four rungs. The enterprise needs a fifth, where authority is checked before anything changes.
Zero Trust for AI Agents: Identity, Authority and Continuous Verification
An agent is neither a user nor a service account. Zero Trust still applies, but it has to verify the agent, the principal and each action, and treat content as influence, never authority.
The Model Is an Engine, Not the Database
Enterprises know how to run a shared engine in front of valuable data: attributed connections, filtering by who is asking, audit, pinned versions and a named operator. Many estates quietly gave the model the database's job instead, and a model holds nothing addressable and enforces nothing. Keep knowledge and rules where they can be enforced.
Route the Question Before You Retrieve: Cypher, BM25 and Vectors
Relationship questions, exact-token questions and paraphrase questions need three different retrievers. A small router, entitlement filters inside the query and a fusion step do more than a bigger model.
Closing the Governance-to-Action Gap with Runtime Mediation
Policies, approval screens and audit logs describe governance. Only a control on the execution path enforces it, and every consequential action must pass through one.
The Review Is Too Late: Block the Diff Before It Exists
Dependency checks, secret scans and static rules usually run in CI, after a pull request exists. That placement was built for diffs written at human speed. An agent can be wrong and already be on its next task before the queue starts. Move the same rules to the point before the change is proposed.
The AI-Native SDLC: What Moves When Agents Write the Code
When agents produce most of the code, the bottleneck moves from typing to context and verification. Five things shift: the artifact, the review, the tests, the roles and the bottleneck, and the evidence for each is thinner than the slogans suggest.
A2A Federation Boundary: Where the Protocol Ends and Your Authority Begins
The Agent2Agent protocol standardises how agents find each other and exchange tasks. It does not decide whom you trust or what a remote agent may cause. That decision belongs at a boundary you own.
Evidence-First Decision Records: Reconstructing What the Agent Knew
A model's explanation is not an audit record, and logs are not a reconstruction. An Evidence-First Decision Record keeps claims, evidence and versions retrievable long after everything has changed.
Why Enterprise AI Needs a Deterministic Shell
Don't try to make the model deterministic or simply trust it. Let it propose, and put identity, authority, schema, state and commitment in a shell that decides at the Commit Boundary.
Context Is Not a Prompt: Introducing the Context Contract
Most context failures are not retrieval misses. They are correct material given to the wrong purpose. A Context Contract declares, versions and tests what an agent may know.
The One-to-Five Trap: Why Multi-Agent Systems Become Distributed Systems
Splitting one agent into five does not add a team. It adds a distributed system. Each boundary has to earn its coordination cost, or it should be a function.
A Model Can Recommend an Action. It Does Not Acquire Authority to Perform It
Directors ask whether their AI is safe. The better question is on whose authority it acts, because accuracy, confidence and technical access are not a delegation.
From Assistance to Agency: Why Enterprise AI Creates a New Architectural Problem
Letting a service desk assistant reset MFA is not phase two of the same programme. Once an agent can change state, the question becomes what it may change, and on whose authority.