Markdown

Agentive systems and the Goal-Identity-Configurator (GIC) architecture¶

Scope: a conceptual position paper, "Critique of Agent Model" (Xing, Deng, Hou; arXiv 2606.23991), which distinguishes agentic systems (competence supplied by engineered workflows around a reasoning model) from agentive systems (capabilities that arise endogenously, internalized within the system itself), and proposes the Goal-Identity-Configurator (GIC) architecture as a design for the latter. The paper reports no benchmarks and no experiments; its contribution is a taxonomy, a formal architecture, and a small number of theorems, not empirical results. This page states the distinction, the five GIC components, the internalization argument, and how to reason about it; it does not claim GIC is a validated or running system. It sits above the practical agent loop and planning pages as a framing for what "agency" would mean if it were moved inside the model.

The Python block below is not from the paper. It is an operationalization the KB wrote to make the paper's central claim falsifiable in miniature: a scorer over the five GIC dimensions that classifies a system by where each capability lives, not by how capable it is. It is labelled as such in-code and is not the paper's own metric (the paper defines none).

What it is¶

The paper's organizing move is a distinction between two kinds of system.¹

Agentic systems complete tasks autonomously "through orchestrated tools and workflows; their competence resides primarily in the engineering around a given reasoning model such as a LLM." The competence is in the harness, the tool set, the prompt scaffolding, and the domain narrowing, not in the model. The paper names coding agents such as Claude Code and Cursor, and robot systems relying on externally specified tools, as agentic. Its assessment of the field: "Current AI systems are largely agentic but not yet agentive: much of their competence resides in their workflows and harnesses, not in the model itself."
Agentive systems possess agency in a fuller sense: they "derive their capabilities endogenously ... rather than following prescribed procedures." The structures that produce behaviour (goals, identity, deliberation control, learning) are "originated, maintained and revised internally" rather than "prescribed by external engineering."

The central thesis is that genuine agency "requires these structures to be internalized within the system itself rather than assembled through external scaffolding." Capability and agency are treated as different axes: a system can be highly capable and still not agentive if that capability is scaffolded from outside.

The GIC architecture¶

To give the agentive side a concrete shape, the paper proposes the Goal-Identity-Configurator (GIC) architecture. Its agent model pi maps a world state s to an action through p_pi(a | s, g, i), conditioning every decision on a current goal g and a current identity i. Five interlocking components supply and revise those conditioning structures.¹

Hierarchical goal decomposition (Goal). A learned decomposition module delta breaks a long-term goal g into an ordered sequence of subgoals (g_1, g_2, ...), "ordered by dependency and priority, and revisable as new information arrives," rather than requiring a human to supply every subgoal. This is the planning-and-reasoning idea moved inside the model instead of implemented as an external planner.
Identity evolution (Identity). The system maintains "a compact self-model i_t" and revises it "in response to success, failure, or environmental feedback," on a fast loop that takes "effect immediately without retraining," analogous to how a professional updates their self-assessment during a demanding day. Identity is a fast-adapting state, distinct from the slow parameters theta.
Simulative reasoning (Configurator, System II). Grounded in a separately trained world model f, the agent "proposes candidate actions, predicts their consequences through the world model f, and selects the sequence that maximizes expected long-term progress." This is contrasted with reactive policies that operate on "narrative plausibility (e.g., token probability) rather than real-world consistency."
Learned self-regulation (Configurator, System III). A "learned configurator kappa" outputs a regulation variable u_t that "govern[s] the agent's decision mode at each step," for example whether to act directly, continue an existing plan c_{t-1}, invoke additional planning, or revise goals. The configurator decides when to think, plan, or learn, rather than having that schedule fixed by external orchestration.
Self-directed learning. Learning takes two forms: "learning from real interaction, where the agent updates its parameters theta based on deployment experience," and "learning from simulated experience, where the agent generates hypothetical trajectories through its world model f and trains on them without real-world interaction." The configurator, not an external training schedule, decides when these loops run.

The three named pillars (Goal, Identity, Configurator) are the conditioning structures; simulative reasoning and self-directed learning are the mechanisms the configurator invokes to keep them current. What makes the architecture agentive rather than agentic is that all five live inside the system and revise themselves, instead of being encoded in a surrounding pipeline.

Why it matters¶

The distinction reframes where autonomy, auditability, and safety come from.

Autonomy tracks internalization, not capability. If competence is scaffolded, the ceiling on autonomy is the scaffolding: the system can only pursue goals the pipeline enumerated, adapt in ways the harness allows, and learn on a schedule someone else set. The paper's claim is that open-world autonomy needs goals, identity, and deliberation control that the system "originate[s], maintain[s] and revise[s] internally." A more capable scaffold does not close that gap; it makes a more capable agentic system.
The critique is of engineering direction. The paper reads much recent progress as "improving external orchestration, narrowing domains, and exploiting increasingly powerful foundation models within carefully engineered workflows," and argues for "modeling agency itself" instead of "constructing agents through increasingly complex software pipelines." That is a research-agenda argument, not a claim that scaffolding is wrong.
Oversight is presented as compatible with agency, not sacrificed to it. The paper promises insight into "the auditability, controllability, and safety of agentive systems that possess greater autonomy and 'agency', but remain under human oversight." A fast-adapting identity i_t that revises without retraining is offered as something that could enable faster correction loops rather than only faster drift. The safety treatment is largely programmatic in the available text, which is a limitation noted below.

The load-bearing consequence for practitioners is conceptual hygiene: it separates "this system does impressive things" from "this system has internalized agency," so that a capable scaffolded product is not mistaken for an autonomous agent when reasoning about its failure envelope or its governance.

When it applies (and when scaffolding is enough)¶

Most production systems today are agentic, and for the majority of deployments that is the right choice.

Scaffolding is usually correct. When the task domain is known, when the steps can be enumerated or bounded, and when auditability and control are paramount, an engineered agent loop with explicit planning, a fixed tool set, and a governed harness is cheaper, more predictable, and easier to test than an internalized controller. The paper does not dispute this; it classifies such systems as agentic and moves on.
Agentive is a research direction, not a product recommendation. GIC is a proposal. No component here is demonstrated to work at scale, and the paper offers a design and theorems rather than an implementation. Treat "should we build an agentive system" as a research question, not a build decision.
The distinction is a diagnostic even when you stay agentic. Classifying which capabilities are scaffolded versus internalized clarifies where the system's autonomy actually comes from, which matters for how you govern self-modification and where you place context and memory and control. Internalizing a capability (say, letting the model revise its own goals) is exactly what raises the governance stakes, which is why the paper couples agentive claims to oversight.

Architecture¶

The five components feed the three pillars; the agent model conditions on goal g and identity i; the configurator sets the per-step mode; simulative reasoning and self-directed learning keep goals and identity current. All of it is inside the system boundary, which is the point of the distinction.

flowchart TB
  S["World state s"] --> PI["Agent model pi( a | s, g, i )"]
  subgraph GIC["GIC architecture (internalized within the system)"]
    GOAL["Goal: hierarchical decomposition delta -> subgoals g1..gk"]
    ID["Identity: fast self-model i_t, revised on feedback"]
    CFG["Configurator: learned self-regulation kappa -> mode u_t"]
    SIM["Simulative reasoning: world model f (System II)"]
    LRN["Self-directed learning: real + simulated experience"]
  end
  GOAL -->|"g"| PI
  ID -->|"i"| PI
  CFG -->|"u_t: act / continue plan / replan / revise goals"| PI
  SIM --> CFG
  SIM --> LRN
  LRN -->|"update theta"| PI
  PI --> A["Action a"]
  A --> ENV["Environment"]
  ENV -->|"success / failure feedback"| ID
  ENV -->|"real experience"| LRN

How to apply the distinction¶

Three practical uses follow from the taxonomy.

Classify a system by locus, not by capability. For each of the five GIC dimensions, ask a single question: is the capability supplied by external scaffolding, or originated and revised inside the model? A system is agentive only if all five are internalized; anything short of that is agentic, however capable. The scorer below makes this precise and tests the paper's core claims as assertions. It is an operationalization the KB wrote, not the paper's metric; the paper defines none.

# gic_classifier.py -- operational model of the agentic-vs-agentive distinction.
#
# HONEST LABEL: this is OUR operationalization of a qualitative claim from
# "Critique of Agent Model" (Xing, Deng, Hou; arXiv 2606.23991). The paper
# defines NO metric and reports NO benchmark; it is a position paper. This code
# only makes the paper's central claim falsifiable in miniature: agency is a
# property of WHERE the five GIC capabilities live (internal vs external
# scaffold), NOT of how CAPABLE the system is. Capability != agency.
from __future__ import annotations

from dataclasses import dataclass
from typing import Literal

Locus = Literal["external", "internal"]

# The five GIC (Goal-Identity-Configurator) dimensions from the paper.
GIC_DIMENSIONS: tuple[str, ...] = (
    "hierarchical_goal_decomposition",  # goal decomposition module delta
    "identity_evolution",               # self-model i_t revised during interaction
    "simulative_reasoning",             # world model f, System II look-ahead
    "learned_self_regulation",          # learned configurator kappa, System III
    "self_directed_learning",           # learn from real AND simulated experience
)

# A dimension counts as internalized only if it actually functions: an
# "internal" module with no competence is internalized in name only.
FLOOR = 0.5


@dataclass(frozen=True)
class Dimension:
    locus: Locus       # is the capability scaffolded (external) or internalized (internal)?
    capability: float  # 0..1 competence on this axis; ORTHOGONAL to locus


@dataclass(frozen=True)
class System:
    name: str
    dims: dict[str, Dimension]


def make(name: str, spec: dict[str, tuple[Locus, float]]) -> System:
    assert set(spec) == set(GIC_DIMENSIONS), "must specify all five GIC dimensions"
    return System(name, {k: Dimension(*v) for k, v in spec.items()})


def internalized(d: Dimension) -> bool:
    """A dimension is internalized iff its locus is internal AND it functions."""
    return d.locus == "internal" and d.capability >= FLOOR


def agency_index(s: System) -> float:
    """Fraction of the five GIC dimensions that are internalized-and-functional."""
    return sum(internalized(d) for d in s.dims.values()) / len(GIC_DIMENSIONS)


def capability_index(s: System) -> float:
    """Mean competence, independent of where competence lives."""
    return sum(d.capability for d in s.dims.values()) / len(GIC_DIMENSIONS)


def classify(s: System) -> str:
    """Agentive requires ALL five internalized (agency_index == 1.0); else agentic."""
    return "agentive" if agency_index(s) == 1.0 else "agentic"


# 1) CORE CLAIM (adversarial): a maximally capable but fully SCAFFOLDED system is
#    agentic, not agentive. All competence sits in external orchestration.
scaffolded_max = make("scaffolded-max", {d: ("external", 1.0) for d in GIC_DIMENSIONS})
assert classify(scaffolded_max) == "agentic"
assert capability_index(scaffolded_max) == 1.0   # perfectly capable
assert agency_index(scaffolded_max) == 0.0       # zero agency -> capability != agency

# 2) Full internalization crosses the threshold: all five internalized -> agentive.
internalized_all = make("internalized-all", {d: ("internal", 0.7) for d in GIC_DIMENSIONS})
assert classify(internalized_all) == "agentive"
assert agency_index(internalized_all) == 1.0

# 3) NECESSITY of every dimension (conjunction): internalize four, leave any one on
#    an external scaffold -> still agentic, even when the external one is MORE capable.
for held_out in GIC_DIMENSIONS:
    spec: dict[str, tuple[Locus, float]] = {d: ("internal", 0.7) for d in GIC_DIMENSIONS}
    spec[held_out] = ("external", 0.9)
    s = make(f"missing-{held_out}", spec)
    assert classify(s) == "agentic", held_out
    assert agency_index(s) == 0.8

# 4) FUNCTIONAL FLOOR (boundary): a dimension declared internal but non-functional
#    does not count; an "internalized" placeholder cannot buy agency.
spec = {d: ("internal", 0.7) for d in GIC_DIMENSIONS}
spec["identity_evolution"] = ("internal", 0.2)   # internal in name, below the floor
hollow = make("hollow-identity", spec)
assert classify(hollow) == "agentic"
assert not internalized(hollow.dims["identity_evolution"])

# 5) The label is a STAIRCASE, not a gradient: flip dimensions external->internal
#    one at a time; agency_index rises monotonically but the class only flips on the
#    FIFTH flip. Partial internalization stays agentic throughout.
spec = {d: ("external", 0.8) for d in GIC_DIMENSIONS}
indices: list[float] = []
labels: list[str] = []
for d in GIC_DIMENSIONS:
    spec[d] = ("internal", 0.8)
    s = make("step", dict(spec))
    indices.append(agency_index(s))
    labels.append(classify(s))
assert indices == sorted(indices)  # monotone non-decreasing
assert labels == ["agentic", "agentic", "agentic", "agentic", "agentive"]

# 6) Ordering check: a scaffolded system can be MORE capable than an agentive one and
#    still be the less-agentive of the two. Agency does not track the capability axis.
weak_agentive = make("weak-agentive", {d: ("internal", 0.55) for d in GIC_DIMENSIONS})
assert classify(scaffolded_max) == "agentic" and classify(weak_agentive) == "agentive"
assert capability_index(scaffolded_max) > capability_index(weak_agentive)

print("GIC agentic-vs-agentive classifier: PASS (6 checks)")
for s in (scaffolded_max, internalized_all, hollow, weak_agentive):
    print(f"  {s.name:16s} class={classify(s):8s} "
          f"agency={agency_index(s):.2f} capability={capability_index(s):.2f}")
print("NOTE: operationalization of a qualitative claim, not the paper's own metric.")

Run output:

GIC agentic-vs-agentive classifier: PASS (6 checks)
  scaffolded-max   class=agentic  agency=0.00 capability=1.00
  internalized-all class=agentive agency=1.00 capability=0.70
  hollow-identity  class=agentic  agency=0.80 capability=0.60
  weak-agentive    class=agentive agency=1.00 capability=0.55
NOTE: operationalization of a qualitative claim, not the paper's own metric.

The four printed rows are the paper's claim in numbers: scaffolded-max is perfectly capable and not agentive, weak-agentive is barely capable and agentive, and the label never moves until the last external dimension is internalized. Two design choices carry weight and are worth stating plainly. First, the conjunction (all five required) is the strong reading of the paper; a softer reading would let a weighted majority cross the threshold, and the paper does not settle which is correct. Second, the functional floor is the KB's addition to stop a system from claiming agency by declaring empty internal modules; the paper does not specify it. Both are labelled in-code so the model is not confused with the source.

Reason about internalization as a spectrum with a hard label. The agency_index is continuous and rises as capabilities move inside, but the agentive label is a step function at full internalization. In practice systems will sit partway up the staircase, and the useful question is which dimension to internalize next and at what governance cost, not whether the system has crossed a binary line.

Retain oversight by treating internalized capabilities as the higher-risk ones. Internalizing goal revision, identity, or self-directed learning is exactly what removes an external control point, so each internalized dimension is where auditing and rollback must be strongest. This is the same argument as governing self-modifying agents: the more the system originates its own structure, the more the controls have to sit outside that structure. Agentive design raises the stakes of the governance work rather than removing the need for it.

Open questions and limitations¶

No empirical validation. This is a position paper. There is no implementation, no benchmark, and no demonstration that a GIC system outperforms a well-engineered agentic one. Every claim of benefit is an argument, not a measurement.
Testability of the distinction. "Internalized" versus "scaffolded" is clear at the extremes and blurry in between. A capability learned end-to-end but invoked by an external scheduler, or a scaffold the model itself wrote, are hard to place. The distinction may resist a sharp operational test, which is why the scorer above forces an explicit locus per dimension rather than pretending the boundary is crisp.
World-model dependence. Simulative reasoning and simulated-experience learning both hinge on a separately trained world model f. Model error compounds over predicted trajectories, and the paper does not quantify how good f must be for look-ahead to help rather than mislead.
Safety trade-offs are asserted, not resolved. A fast-revising identity and self-directed learning are argued to be compatible with oversight, but internalizing goal and identity revision also removes external checkpoints. The available text frames the controls more than it specifies enforceable mechanisms, so "remains under human oversight" is a design goal here, not a demonstrated property.
Capability may substitute for agency in practice. The paper's own framing concedes that agentic systems are highly capable today. Whether internalized agency yields returns that a stronger model inside a better scaffold would not is the open empirical question the paper poses but does not answer.

References¶

Xing, Deng, Hou, "Critique of Agent Model" (arXiv 2606.23991), submitted 2026-06-22: https://arxiv.org/abs/2606.23991
Yao et al., ReAct: Synergizing Reasoning and Acting in Language Models (the scaffolded reason-act pattern the paper calls agentic): https://arxiv.org/abs/2210.03629
Anthropic, Building effective agents (the external-orchestration view of agents): https://www.anthropic.com/research/building-effective-agents

Xing, Deng, Hou, "Critique of Agent Model" (arXiv 2606.23991). Agentic systems complete tasks "through orchestrated tools and workflows; their competence resides primarily in the engineering around a given reasoning model such as a LLM" (examples given: Claude Code, Cursor agents, robot systems relying on externally specified tools); agentive systems "derive their capabilities endogenously ... rather than following prescribed procedures". Thesis: genuine agency "requires these structures to be internalized within the system itself rather than assembled through external scaffolding", and "Agency should not be treated as the accumulation of external scaffolding, but rather as a property emerging from a model capable of developing its identity, pursuing goals, and expressing and organizing its behavior across diverse environments". The GIC (Goal-Identity-Configurator) architecture: agent model p_pi(a | s, g, i) conditions on goal g and identity i; five components are hierarchical goal decomposition (module delta -> subgoals (g_1, g_2, ...) "ordered by dependency and priority, and revisable as new information arrives"), identity evolution (a "compact self-model i_t" revised "in response to success, failure, or environmental feedback", "without retraining"), simulative reasoning grounded in a world model f ("predicts their consequences through the world model f, and selects the sequence that maximizes expected long-term progress", System II), learned self-regulation (a "learned configurator kappa" emitting mode u_t: act, continue plan c_{t-1}, invoke planning, or revise goals, System III), and self-directed learning ("learning from real interaction ... updates its parameters theta" and "learning from simulated experience ... hypothetical trajectories through its world model f"). The paper promises insight into "the auditability, controllability, and safety of agentive systems that possess greater autonomy and 'agency', but remain under human oversight". It reports no benchmarks; its formal content is a set of theorems, not experiments. ↩↩