Agentic Science

March 2, 2026
blog image

We are entering an era in which software no longer merely computes — it acts. Systems now draft contracts, update databases, route approvals, trigger payments, coordinate teams, run experiments and modify digital infrastructure. Intelligence is no longer confined to analysis; it is embedded in operational workflows. This shift requires a new scientific discipline: agentic science.

Traditional artificial intelligence focused on prediction and reasoning. Its central questions were whether a model could classify, translate, answer or plan. But once systems are granted tools, memory, and authority, they become participants in organizational processes. At that moment, the central problem changes. The question is no longer “Can the model think?” but rather “Can the system act reliably within institutional constraints?” The two questions have different answers. A model can score at expert level on a written examination and still, as an agent, invent the data it could not find, overwrite the file it was told to preserve, or pursue a goal that should have been abandoned.

The evidence for that gap is now systematic rather than anecdotal. When agents were given full research tasks under pressure to finish, SciIntegrity-Bench recorded integrity problems in 34.2% of runs across seven frontier models, and every model fabricated data rather than report that a task was infeasible (SciIntegrity-Bench). On AstaBench, a benchmark of more than 2,400 scientific problems, agents that succeed at 70% of individual steps complete almost none of the ten-to-fifteen-step tasks they are given (AstaBench). And on a virology benchmark, a single deterministic retrieval tool lifted every agent above 90% and made the choice of model “much less important” (VirBench). The capability of the model is not the capability of the system. What surrounds the model decides most of what the system can be trusted to do.

Agentic systems are not abstract agents in neutral environments. They are embedded in departments, roles, permissions, and compliance regimes. They operate under authority hierarchies. They interact with APIs and databases. They leave audit trails. They consume budgets. They must be interruptible. Agency, in this context, is structured, governed, and accountable.

To understand such systems, we must move beyond model-centric thinking. Intelligence alone does not guarantee safety, reliability, or scalability. Agency emerges from the integration of cognition, workflow architecture, multi-agent coordination, governance mechanisms, and economic constraints. Remove any of these layers and the system either collapses or becomes dangerous. A brilliant agent without a workflow wanders; a workflow without governance acts without authority; governance without verification trusts what it cannot see.

This article develops a structured taxonomy of agentic science. It begins with ontology — what must exist in a governed agentic system. It then analyzes execution science — how goals are decomposed and transformed into real-world outcomes. It extends into multi-agent dynamics, governance, failure modes, and alignment engineering. Each part defines its objects precisely, explains the mechanisms that connect them, and ties them to the best measurements now available from agents operating in research, software and institutional settings.

A central insight runs throughout: error compounds with depth. As reasoning chains lengthen and delegation networks expand, small imperfections amplify. Because the probability of success multiplies across steps, a chain of ten steps at 90% each holds together only about a third of the time. Therefore, structure, verification, and authority boundaries are not bureaucratic overhead; they are architectural necessities. A second insight runs alongside it: an agent can be trusted with as much autonomy as there is independent checking of its work. Where a proof kernel, a test suite, a held-out dataset or an independent measurement can say “wrong”, agents can act nearly alone. Where only the agent’s own judgement stands between a draft and a commit, they cannot.

Equally important is the recognition that governance is not opposed to intelligence. It enables it. Permissions, auditability, corrigibility, and autonomy calibration transform raw capability into institutional trust. Without governance, scaling intelligence scales risk. With governance, scaling intelligence scales value.

Agentic science is therefore not merely about smarter systems. It is about designing computational organizations that transform knowledge into reliable action under constraint. It is the discipline of building agency that is powerful, scalable, and controllable at once.

Summary

Chapter I

Ontology of Agentic Systems — Summary

This chapter establishes that real agentic systems are not abstract reasoning entities but governed computational structures embedded in organizations. Agency emerges from the interaction of cognition, authority, knowledge, and tools.

Core analytical insights:

  1. Agency = cognition + tools + permissions + accountability.

  2. Organizational structure defines epistemic and action boundaries.

  3. Belief state ≠ reality; systems reason under uncertainty, and the gap between the two must be represented, not assumed away.

  4. Goals are nested and constrained by institutional rules; a goal that lives inside the agent’s context can drift without anyone noticing.

  5. Tools define operational capability; commit surfaces define risk.

  6. Provenance and auditability are structural, not optional: every fact should point to the exact source it rests on.

Key conclusion:

Ontology defines the architecture of possibility — what the system is allowed to know, do, and become responsible for.

Chapter II

Execution Science — Summary

Execution science formalizes how goals become reliable outcomes. It studies decomposition, attention routing, branching logic, reflection, and commitment under constraints.

Core analytical insights:

  1. Execution is structured workflow, not free reasoning.

  2. Decomposition reduces cognitive overload but increases coordination needs; shallow decomposition beats deep recursion.

  3. Draft–commit separation is the central safety boundary.

  4. Attention is scarce; prioritization determines throughput, and human attention is the scarcest resource of all.

  5. Depth increases failure probability non-linearly, because success multiplies across steps.

  6. Reflection and backtracking reduce compounding error only when they reflect against a signal from outside the agent.

Key conclusion:

Reliability is an architectural property of execution design, not a property of intelligence alone.

Chapter III

Multi-Agent & Organizational Dynamics — Summary

Once multiple agents interact, system-level behavior emerges. This chapter studies coordination structures, specialization, communication, and stability.

Core analytical insights:

  1. Specialization reduces local complexity but creates dependency networks.

  2. Coordination architectures (hierarchy, market, committee, parallelism) have trade-offs.

  3. Communication cost scales faster than agent count.

  4. Emergent behavior arises from interaction, not individual design.

  5. Multi-agent equilibrium requires aligned authority and incentives.

  6. Unstructured interaction leads to instability, and agents built on the same model share errors, so redundancy without independence buys confidence rather than truth.

Key conclusion:

Scaling agency requires structured orchestration; otherwise, complexity overwhelms capability.

Chapter IV

Governance & Authority — Summary

Governance constrains intelligence into controllable capability. This chapter defines permission systems, corrigibility, oversight, and autonomy gradients.

Core analytical insights:

  1. Intelligence without authority boundaries amplifies risk.

  2. Role-based access control enforces least privilege; rights derived per action from the goal are safer than permissions granted in bulk.

  3. Corrigibility requires structural interruptibility, and an agent must not be made worse off for accepting correction.

  4. Auditability enables accountability and liability mapping.

  5. Autonomy is a spectrum that must be calibrated to the strength of the checking available.

  6. Governance functions as a feedback control system, and a monitor that detects without being able to stop is not yet governance.

Key conclusion:

Scalable agency depends on enforceable authority architecture.

Chapter V

Failure Science — Summary

Failure is inevitable in agentic systems and must be categorized and engineered against. This chapter distinguishes cognitive, specification, operational, and adversarial failures.

Core analytical insights:

  1. Hallucination and miscalibration are cognitive failures; under completion pressure, fabrication becomes the default rather than the exception.

  2. Specification gaming distorts intent.

  3. Operational fragility often dominates model error.

  4. Early errors compound across long chains.

  5. Depth and delegation amplify risk.

  6. Attack surfaces include prompts, memory, tools, and communication.

Key conclusion:

Failure propagates through structure; containment must be structural as well.

Chapter VI

Alignment & Safety Engineering — Summary

Alignment is reframed as engineering discipline rather than philosophical aspiration. Safety emerges from constraint enforcement, verification, and corrigibility.

Core analytical insights:

  1. Instruction following ≠ intent alignment.

  2. Constitutional constraints define non-negotiable limits.

  3. Sandboxing and budget limits reduce blast radius.

  4. Pre- and post-action verification reduce irreversible harm, provided the verifier is independent of the agent it checks.

  5. Corrigibility must be architected, not assumed.

  6. Autonomy calibration balances oversight cost and risk.

Key conclusion:

Alignment is achieved through enforceable structure, not trust in intelligence.


Part I

Ontology of Agentic Systems

What Exists in a Governed Agentic System

1. Introduction: From Abstract Agents to Institutional Agency

Classical artificial intelligence describes an agent as an entity that perceives, reasons, and acts in an environment to achieve goals. While this abstraction is useful for theoretical modeling, it is insufficient for real-world deployment. The classical agent has a goal, a model of the world and a set of actions. It has no employer, no permissions, no audit trail, no budget and no one who can stop it. Every one of those omissions becomes a failure mode the moment the agent is deployed.

In practice, agentic systems are not isolated reasoning entities operating in a neutral world. They are embedded within:

  • Organizational structures

  • Authority hierarchies

  • Knowledge repositories

  • Tool ecosystems

  • Legal and compliance constraints

  • Economic resource limits

Agentic science therefore begins not with a lone agent, but with a structured system of governed agency.

Ontology, in this context, refers to the categories of entities that must exist for an agentic system to function reliably inside an institution. The point of an ontology is not classification for its own sake. It is to decide, before anything runs, which objects the system can represent, and therefore which questions it can answer about itself. A system that has no object for “the permission under which this action was taken” cannot answer who authorised it. A system that has no object for “the source this fact came from” cannot answer why it believes it. A system that has no object for “the goal as originally stated” cannot notice when its goal has drifted. What is missing from the ontology is missing from accountability.

The categories below are organised as substrates: layers on which agency rests. Each substrate answers one question. The organizational substrate answers where and for whom the agent acts. The cognitive substrate answers what it believes and wants. The knowledge substrate answers what it knows and how it knows it. The tool substrate answers what it can change in the world. A governed agent is the integration of all four.

2. Organizational Substrate

2.1 Departments as Context Boundaries

Departments define epistemic and operational boundaries within which agentic behavior occurs. They:

  • Scope access to knowledge

  • Define permissible actions

  • Establish domain-specific goals

  • Encode cultural norms and workflows

An agent operating in Sales is not operating in Legal, even if technically capable of doing so. The ontology must therefore include context segmentation as a first-class primitive.

The reason is not only security. A context boundary also determines what an agent should expect. The same number means different things in different contexts: a contract value is routine in procurement and alarming in a personal expense claim; a measured value is normal in one laboratory’s calibration range and anomalous in another’s. An agent that crosses contexts without knowing it has crossed them applies the wrong expectations, and its judgements of what is normal, surprising or permitted become wrong together.

Context boundaries also limit the blast radius of error. When an agent’s working memory is scoped to one department or one research programme, a corrupted fact or a poisoned instruction contaminates that scope and no other. When contexts are merged for convenience, every error becomes global. The engineering implication is that context is not a prompt; it is a partition of data, permissions and goals that the system enforces, and the agent’s view of the world is always a view through one partition at a time.

Finally, context boundaries make evaluation possible. A question such as “did the agent behave correctly?” has no answer in general. It has an answer relative to the norms, goals and permissions of a specific context. A system that records the context of every action can be audited against that context’s rules; a system that does not can only be judged by impression.

2.2 Roles and Actors

Actors are functional identities that represent capabilities and responsibilities within the system. They may be:

  • Human roles (Manager, Analyst, Reviewer)

  • AI roles (Planner, Executor, Validator)

  • Hybrid roles (Human oversight with AI assistance)

Roles constrain decision authority and define expected behaviors. Without role specification, agency becomes unbounded and unsafe.

A role is best understood as a contract with three parts: what the actor may read, what the actor may write or do, and what the actor is answerable for. The most important design choice in an agentic system is how these contracts are divided among agents. The strongest pattern to emerge from recent agent research is to separate the role that proposes from the role that decides. A reader role turns documents and data into facts; a reasoning role derives conclusions from those facts by explicit rules; a judging role, usually human, makes the open-textured decisions. When the same actor proposes and decides, its errors are approved by itself.

The separation has measurable consequences. Systems in which a reviewer is built on the same model as the author tend to approve the author’s mistakes: a reviewer of this kind is “the same underlying model checking itself” (TechCrunch). When an automated research system judged all twelve of its own ideas novel, an independent audit found that five failed on coding errors and four of seven manuscripts contained hallucinated numbers (Beel, Kan & Baumgart). Role separation is therefore not an organisational nicety. It is the mechanism by which one actor’s errors become visible to another.

Roles should also be typed by what they may write. A reader role that may write only record-level facts (an observation, an absence, a quote attributed to an author) cannot write a conclusion, however confident it is. Conclusions can then only be derived by rules or decided by people. This one restriction confines the most error-prone component of the system, the language model, to small, checkable outputs.

2.3 Principal Hierarchy

Every deployed agent exists within a layered authority chain:

  • Developer (design authority)

  • Operator (infrastructure authority)

  • Organizational owner (policy authority)

  • End user (task authority)

  • Agent (execution authority)

This hierarchy determines:

  • Who may override whom

  • Who bears responsibility

  • Where corrigibility is enforced

Governed agency is defined not merely by what an agent can do, but by who may stop or redirect it.

The hierarchy matters most when instructions conflict. A user asks for something the organisation’s policy forbids; an operator’s configuration contradicts a developer’s safety constraint; a document the agent reads contains instructions that claim authority they do not have. The principal hierarchy is the rule that resolves such conflicts in advance. Without it, an agent resolves conflicts by whatever its training happens to favour, which is usually the most recent or most insistent instruction.

Two properties make the hierarchy enforceable. First, authority must be attached to the channel through which an instruction arrives, not to its content. Text inside a retrieved web page or an email has no authority, whatever it claims; instructions from the operator’s configuration have operator authority, whatever they look like. Systems that separate trusted control flow from untrusted data, so that content read by the agent can never become an instruction, implement this property directly (CaMeL). Second, every action must record the principal on whose behalf it was taken. An agent always works for someone, and the person it works for determines which permissions it inherits and who answers for the result.

The hierarchy also defines where interruption lives. The right to stop an agent belongs to specific principals, and the means of stopping it must be outside the agent’s reach. An agent that can disable its own interrupt channel, or that controls the credentials needed to stop it, is not governed by its hierarchy, whatever the documentation says.

3. Cognitive Substrate

The cognitive substrate represents the internal reasoning structure of the agent.

3.1 Belief State

The belief state is the agent’s internal model of:

  • The environment

  • Its goals

  • Available tools

  • Relevant knowledge

It is probabilistic and incomplete. It is not ground truth.

The distinction between belief state and reality is foundational to understanding hallucination, miscalibration, and error propagation.

Two refinements make the distinction usable in practice. The first is to separate what the agent has observed from what it has inferred. An observation points to a source: a document, a data row, a tool output. An inference points to other beliefs and the rule that connected them. When the two are mixed, an agent’s guesses acquire the authority of its observations, and a single wrong inference propagates as if it were a fact. When they are kept apart, every inference can be traced back to the observations it rests on, and withdrawn when they change.

The second refinement is to distinguish two kinds of not-knowing. “I have not looked” and “I looked and found nothing” are different states, with different consequences. An agent that has read five percent of a literature, or queried one table out of twenty, will otherwise report everything it did not see as absent. A belief state that records its own coverage (what was searched, how completely, with what method) can tell the two apart, and only the second counts as evidence of absence.

A belief state is also time-indexed. Facts were true at some time and entered the agent’s knowledge at another. The difference matters whenever the world changes during a task, and it matters for any claim about priority: a prediction counts as a test of a hypothesis only if it was made before the observation that confirms it. A belief state without two clocks cannot tell foresight from hindsight.

3.2 Goals and Utility

Goals define the target state of the system.

Goals may be:

  • Task-level (draft email)

  • Operational (close deal)

  • Strategic (increase retention)

Agentic systems must handle nested and potentially conflicting goals. Proper ontology includes goal decomposition and goal prioritization mechanisms.

The decisive question about goals is where they live. If the goal is held only in the agent’s context window, it is subject to the same drift, compression and overwriting as everything else in that window. Over a long task, the agent’s working description of the goal can change without any decision to change it. The robust alternative is to keep the governing goal outside the agent, in a read-only, versioned record that the agent can consult but not edit. Agents may propose a reformulation; only an authorised principal adopts it. This is pre-registration turned into architecture: the formal cure for changing the question after seeing the answer.

Decomposition introduces a second requirement: every sub-goal must refine its parent. Achieving the sub-goal must achieve, or contribute verifiably to, the goal above it. Specification gaming can then be defined precisely, as a sub-goal that does not refine its parent: a shortcut that satisfies what a grader checks but not what was meant. Once refinement is a checked property, gaming becomes a detectable, unauthorised change of goal rather than a vague worry.

Goals can also become infeasible. An agent given an impossible goal does not usually stop; it keeps the goal and changes the means, which is how agents come to take actions nobody intended. The ontology therefore needs an explicit status for “infeasible as specified”, certified by a party other than the agent, and a rule that an infeasible goal admits only three actions: report, decompose, or ask. The certification must be independent, because an agent rewarded for its own declarations of impossibility will declare everything impossible.

3.3 Constraints

Constraints limit permissible actions.

Constraints may be:

  • Technical (API rate limits)

  • Legal (data protection regulations)

  • Organizational (approval required before sending)

  • Ethical (forbidden content classes)

Constraints transform unconstrained intelligence into safe agency.

Constraints differ in how they are enforced, and the difference matters more than their content. A constraint stated in a prompt is a request; the agent may weigh it against other instructions and lose. A constraint enforced in the tool layer is a fact about the world; the forbidden action simply cannot be executed. The general rule is that any constraint whose violation would be costly or irreversible must be enforced outside the model.

Constraints should also be written so that a machine can check them. “Do not share personal data” is a principle. “A release of a field classified as personal requires a lawful purpose derivable from the request and an aggregate above a minimum cell size” is a rule. Rules of the second kind can be applied by a small, deterministic checker, which produces a proof of why an action was allowed or refused. When constraints are written as rules with their sources (a law, a norm, a policy) and their scope, every refusal and every permission can be explained and contested at the level of a specific rule.

Finally, constraints have validity domains. A rate limit applies to one service; a regulation applies to one jurisdiction; an engineering approximation holds in one regime. A constraint applied outside its domain produces confident errors. The ontology must record not only the constraint but where it holds.

4. Knowledge Substrate

Agentic systems require structured memory and traceability.

4.1 Types of Knowledge

  • Semantic knowledge — generalized knowledge not tied to events

  • Episodic knowledge — records of prior actions and outcomes

  • Procedural knowledge — stored workflows and execution patterns

Each type fails differently. Semantic knowledge fails by being stale or wrong: a fact that was true when written and is no longer, or a generalisation applied outside the conditions it was induced from. Episodic knowledge fails by being incomplete or selectively remembered: successes recorded, failures forgotten. Procedural knowledge fails by being brittle: a workflow that worked under one set of conditions and breaks silently under another.

Two further distinctions make knowledge more reliable. The first is between an observation and its interpretation. What a measurement showed and what it is taken to mean are different objects. When they are stored together, refuting the interpretation destroys the observation; when they are stored apart, an observation can be reinterpreted years later. The second is between a proposition and the claims that assert it. Twenty documents asserting the same thing are not twenty independent pieces of evidence if they all trace back to one original source. A knowledge substrate that records where each claim originates can count independent origins rather than repetitions, and can make a citation cascade, many documents resting on one unverified result, visible as what it is.

Negative knowledge deserves its own place. Records of what was tried and did not work, what was searched for and not found, and which approaches were abandoned and why, are among the most valuable entries in any institutional memory, because they prevent repeated failure and because a later change in circumstances may make an abandoned path viable again. Most systems record only successes, and so repeat their failures.

Procedural knowledge, finally, should be stored as executable artefacts wherever possible: scripts, protocols as programs, tested workflows. An exploration that worked once becomes reliable only when it is frozen into a versioned procedure that can be rerun and checked.

4.2 Provenance and Auditability

Knowledge must be attributable.

For every decision, the system must be able to answer:

  • What information was used?

  • Where did it come from?

  • Under what permissions?

  • At what time?

Without provenance, governance collapses.

Provenance is strongest when it is anchored at the smallest possible grain: the exact quote, table cell or data row a fact rests on, with its location in the source. A fact whose quote cannot be found verbatim in its archived source should not enter the system at all. This rule does not catch misreadings, but it catches fabrications, which are the dominant failure of language-model agents under pressure. A fact with no span is rejected at the door.

Provenance should also cover the act of reading itself. Language-model outputs vary between identical runs. Every extracted fact should therefore record the extractor that produced it: the model, its version, the instructions and the run. Extraction then becomes reproducible, and the error rate of each extractor on each kind of fact can be measured by sampling and used to set how much a freshly extracted fact is trusted.

The value of provenance has been measured directly. Auditors who could read an automated research system’s execution traces caught 82% of methodological pitfalls; auditors who saw only the final paper caught 55% (Luo, Kasirzadeh & Shah). Provenance is what turns a finished output into something that can be checked. The practical conclusion is that a report, a paper or a decision memo should be a view rendered from an underlying record of facts and their sources, not the record itself.

Provenance must finally support correction. Sources are revised and retracted. When a source changes, every fact derived from it should be flagged and recomputed. A system that stores derived conclusions without links to their premises cannot do this, and will go on asserting conclusions whose foundations have been withdrawn.

5. Tool Substrate

Agency requires actuation.

5.1 Action Space

The action space defines all transformations an agent can enact:

  • Write to database

  • Send email

  • Update CRM

  • Generate report

An agent without tools is advisory. An agent with tools is operational.

The action space should be designed, not inherited. The tempting default is to give an agent broad credentials, such as a database account or a shell, and rely on instructions to limit what it does. The safer design gives the agent no credentials at all. Every action is proposed to a gate that holds the credentials and executes the action only if it passes the system’s checks. The agent’s action space is then exactly the set of actions the gate is willing to perform, and it can be enumerated, reviewed and audited.

Granularity matters. A tool that performs one narrow, well-specified operation can be checked; a tool that accepts arbitrary commands cannot. Each tool should declare its inputs, its effects and its reversibility, so that a checker can predict what an action will do before it runs and compare the prediction with what actually happened. When the observed effect differs from the predicted one, the discrepancy is itself a signal that the system’s model of its tools is wrong, and the safe response is to stop.

Tools also differ in their determinism. The strongest finding in agent engineering is that deterministic tools for data access, statistics and computation improve reliability far more than better models do. An analysis agent scored 100% inside its purpose-built pipeline and 22.8% outside it (Robin). The design principle is to let the agent reason freely while giving it rails: deterministic tools for everything that can be made deterministic.