The AI-Native Company

Towards a Theory and Systems Architecture of Computational Organisations

Research manuscript · 31 August 2026

Research overview

This paper develops a theory and systems architecture of the AI-native company: an emerging organisational form in which computational actors become first-class participants and significant properties of organisation become machine-readable and increasingly executable. Drawing on organisation theory, computational organisation science, organisational cybernetics, multi-agent systems, distributed systems and contemporary agent-native research, it asks which properties of the modern enterprise are fundamental to organisation and which primarily reflect the constraints of organising human labour. It proposes a model of persistent organisation and elastic computational execution, develops an ontology and reference architecture, compares independently emerging organisational models, and evaluates the resulting theory against evidence from an operating case at Tutorwise Technologies. The analysis identifies organisational continuity, authority, institutional state, organisational assurance—including control discrimination, construct validity, execution-path coverage and verdict delivery—as a central design problem, while outlining a research agenda for organisations capable of safely coordinating increasingly autonomous computational work. The paper's central concern is therefore not the replacement of human workers by artificial ones, but the broader computational transformation of the enterprise itself.

Abstract

Artificial intelligence is moving from a tool used by organisations toward a computational actor within them. Increasing agent capability, however, does not by itself explain how an organisation composed substantially of computational actors should be structured, governed, coordinated, scaled or made persistent. This paper investigates the AI-native company as an emerging organisational-computational form. It synthesises organisation theory, computational organisation science, organisational cybernetics, multi-agent systems and distributed-systems concepts; compares contemporary architectures including Fluid Structure, Company World Model, AUTOBUS and Forage V2; and examines Tutorwise Technologies as an operating case study. The paper advances the design proposition to preserve organisational strengths, remove human constraints and introduce computational capabilities. It develops an ontology separating organisation, seat, worker, runtime, model and provider; distinguishes capability from capacity, authority from permission, and institutional state from agent memory; and proposes an organisational runtime and reference architecture in which persistent organisational properties coordinate elastic computational execution. Operating evidence is used to test rather than define the model. It supports several proposed separations while exposing failures in identity, authority validation, institutional delivery and verification. These observations motivate a secondary contribution: organisational assurance as an architectural property of computational organisations, distinguishing discrimination, construct validity, execution-path coverage and verdict delivery. Vacuous verification is not claimed as a new software phenomenon; rather, the case shows how non-discriminating controls can propagate into organisational governance and self-observation. The paper contributes a candidate definition, reference architecture, falsifiable evaluation framework and research agenda for computational organisations. Keywords: AI-native company; computational organisation; agent-native organisation; multi-agent systems; organisational architecture; AI agents; organisational governance; computational enterprise; organisational elasticity; institutional state; organisational runtime; verification.

Note on case method and evidence

The operating case uses an instrumented participant-observation design in which a computational organisational actor contributed to both system operation and the initial observational record. This creates an explicit threat to observational independence. The case is therefore treated as implementation and behavioural evidence rather than definitional authority. Quantitative claims are grounded in operational artefacts where available, negative findings are retained alongside supporting evidence, and the initial observation register was subsequently reviewed by seven additional organisational units. That review recovered five observations omitted from the initial register and reversed one preliminary test classification from pass to fail. These discrepancies are retained as methodological evidence concerning the limits of organisational self-observation rather than removed as observer error. The resulting register comprises twenty-two observations initially identified during the observation period and five subsequently recovered through review, for twenty-seven identified instances associated with that period. This is a discovered count, not an incidence rate or population estimate.

1. Introduction — From AI in the Company to the Company as a Computational System

Companies are coordination technologies. Enterprises divide work, specialise capability, delegate authority, preserve institutional knowledge, coordinate activity and maintain continuity despite turnover among individual workers. Departments, roles, hierarchies, processes, records and controls are therefore more than an organisational chart: they are mechanisms through which collective activity becomes an enduring institution. Artificial intelligence introduces a new organisational actor. Contemporary AI agents can interpret objectives, select actions, use tools, interact with external systems and perform classes of knowledge work that previously required human judgement. As these capabilities are connected into multi-agent systems, the design problem moves beyond the individual model. The question becomes organisational: how should computational actors be organised? Organisation theory has long connected organisational form to information-processing constraints and task uncertainty (Galbraith, 1974), while computational organisation science has treated organisations as adaptive computational entities (Carley, 2002). Multi-agent research has likewise shown that organisational design can materially affect agent-system performance and has formalised roles, norms and structures independently of particular agents (Horling & Lesser, 2004; Hübner et al., 2002; Dignum et al., 2004). The contemporary change is therefore not the discovery that organisations can be understood computationally. It is that machine-readable organisational representations can increasingly participate causally in the operation of real enterprises.

Which properties of the modern enterprise are fundamental properties of organisation, and which are consequences of organising humans? Conventional organisations encode both accumulated institutional knowledge and historical human constraints. Responsibility, delegated authority, specialisation, separation of duties and institutional records address recurring problems of collective action. Fixed working hours, costly headcount, recruitment latency, limited attention and slow communication are more contingent. Computational actors allow these functions and constraints to be separated more aggressively than was previously practical. Two errors follow from failing to make this distinction. Organisational mimicry assigns agents corporate titles and departments without providing continuity, authority, governance or institutional state. Organisational rejection discards mechanisms that solve genuine problems merely because their historical implementation involved humans. Preserve organisational strengths; remove human constraints; introduce computational capabilities. An AI-native company is enterprise architecture redesigned for computational actors.

1.1 Research problem

How should an enterprise be represented, structured, executed and governed when computational actors become first-class participants in the organisation and elements of the organisation itself become executable?

1.2 Research questions

1. RQ1 — Definition: What distinguishes an AI-native company from an enterprise that merely uses AI agents?
2. RQ2 — Organisational primitives: Which entities and relationships must persist independently of computational workers?
3. RQ3 — Continuity: How can organisational identity, state and commitments survive worker, model and provider substitution?
4. RQ4 — Structure and adaptation: Which organisational structures should remain durable and which may become elastic or dynamically reconfigured?
5. RQ5 — Authority and governance: How should capability, permission, authority and consequential organisational change be represented and constrained?
6. RQ6 — Evaluation: What interventions can falsify claims that a system possesses AI-native organisational properties?
7. RQ7 — Verification: How can an organisation establish that its controls discriminate appropriately, measure the organisational conditions they claim to govern, cover the execution paths on which those conditions arise, and deliver their verdicts to the organisational actors or mechanisms that must respond?

1.3 Contributions

1. A definitional distinction between AI adoption, agentic execution, agent organisation and computationalisation of organisation.
2. An ontology separating organisational identity from worker, runtime, model and provider identity; role from worker; authority from capability; and institutional state from agent memory.
3. A reference architecture connecting governance, organisational state, business state, institutional state, organisational runtime and execution actors.
4. A comparative analysis of independent contemporary architectures and an operating implementation case.
5. A falsifiable evaluation framework based on replacement, dormancy, authority, elasticity, learning, recovery and external outcomes.
6. An empirically motivated extension treating control discrimination, construct validity, execution-path coverage, verdict delivery and organisational self-verification as architectural concerns, while explicitly locating the underlying vacuity problem in prior software-verification and test-oracle traditions.

1.4 Novelty position

Computational organisation is not new, nor is the formal representation of roles, norms, organisational structure or machine-enforced policy. The contribution claimed here is the synthesis and operational extension of these ideas under conditions where intelligent organisational labour itself becomes computational, replaceable and heterogeneous.

1.5 Research design and method

This paper adopts a conceptual systems and design-science research design combining theory synthesis, comparative architectural analysis, reference-model construction and an instrumented single-case evaluation. The purpose is not to infer population-level effects from one implementation, but to construct a falsifiable account of an emerging organisational form and expose that account to independent antecedents, competing architectures and contradictory operating evidence.

Four evidence streams are used. Established scholarly antecedents supply constructs and boundary conditions from organisation theory, computational organisation science, organisational cybernetics, multi-agent systems, access control, verification and distributed systems. Contemporary architectural comparators provide independently developed systems against which the proposed separations can be challenged. Design synthesis combines recurring problems and separations into the ontology, organisational-runtime abstraction and reference architecture. Operating-case evidence from Tutorwise Technologies is then used to test whether selected constructs are implementable and whether observed behaviour contradicts the intended architecture.

The evidential order is therefore literature → competing systems → conceptual problem → proposed model → operating case. Case observations do not establish the definition. Supporting and negative observations are retained, and claims are classified by whether they concern documented architecture, implemented mechanisms, observed behaviour or external outcomes. The evaluation framework in Section 16 operationalises the theory as interventions that can fail rather than as a checklist for certification.

1.6 Theoretical propositions

The synthesis yields six propositions intended to be challenged empirically rather than treated as axioms.

P1 — Organisational persistence. Organisational continuity can remain invariant under computational-worker substitution when identity, responsibility, authority, commitments and relevant institutional state persist outside particular worker instances.

P2 — Capability–capacity separation. A computational organisation can preserve a capability while varying the number and composition of active worker instances used to realise it.

P3 — Differential elasticity. Execution capacity can vary more rapidly and extensively than organisational authority without requiring equivalent structural change.

P4 — Institutional-state independence. Organisational learning requires relevant state to survive replacement of the computational actors involved in producing the original experience and to alter subsequent organisational behaviour.

P5 — Authority validity, discoverability and utilisation. Technical capability and permission are insufficient to establish legitimate organisational authority; consequential action requires an independently representable basis for institutional commitment. Formally valid authority is also operationally ineffective when the holder cannot correctly discover that it possesses the applicable delegation through the organisation’s own authority-query mechanisms, or when execution systematically routes applicable work around that authority.

P6 — Executable representation. When machine-readable organisational representations participate causally in execution, the correctness, construct validity, execution-path coverage, discriminative validity and verdict delivery of those representations and their controls become operational systems properties rather than merely descriptive modelling concerns.

2. Intellectual Lineage — The Computational Organisation Before AI-Native Companies

2.1 Computational organisation science

Carley (2002) explicitly describes organisations as intelligent, adaptive and computational entities and develops computational organisation science as a means of studying how organisational structure, knowledge, learning and adaptation interact. This antecedent matters because the present paper should not claim that the organisation first becomes computational with large language models. The narrower transition is from computational theory and simulation toward operating organisations in which organisational representations increasingly determine real execution.

2.2 Organisational cybernetics

Beer’s Viable System Model sought to identify conditions under which systems remain viable, separating operational activity from coordinating, control, intelligence and policy functions (Beer, 1984). The relevance is functional rather than literal: a computational organisation still needs mechanisms for viability, coordination and governance even if its execution substrate changes.

Some organisational structures may survive not because humans require them, but because organisations themselves require the functions they perform.

2.3 Organisation as information processing

March and Simon (1958) place bounded rationality, attention, routines and decision premises at the centre of organisational analysis. Their account helps separate enduring coordination problems from particular human implementations: computational actors alter the cost and speed of search, communication and execution, but do not remove the need to allocate attention, responsibility and decision rights.

Galbraith (1974) links task uncertainty and organisational form to cognitive limits and information-processing requirements. This provides a basis for distinguishing enduring organisational functions from structures whose historical form partly reflects human cognitive and communication limits.

2.4 Multi-agent organisational models

Horling and Lesser (2004) survey hierarchies, teams, coalitions, federations, markets, matrix structures and other multi-agent organisational paradigms, emphasising that design choices can have quantitative performance effects. MOISE+ separates structural, functional and deontic organisational specifications (Hübner et al., 2002), while OMNI incorporates social structure, norms and ontologies and separates organisational requirements from the particular agents populating the organisation (Dignum et al., 2004). These are strong antecedents to machine-readable organisation.

2.5 Distributed systems and desired-state control

Distributed systems contribute persistence, messaging, fault tolerance, scheduling and replaceable execution. Desired-state systems contribute another useful pattern: controllers compare observed state with declared state and act to reduce discrepancies. Kubernetes provides a mature engineering example of this control-loop pattern. The analogy is useful for organisational reconciliation but should not be confused with a claim that organisations are infrastructure clusters.

2.6 Remaining gap

What architecture emerges when organisational abstractions become persistent operating structures and intelligent labour itself becomes a replaceable computational resource?

The gap is therefore not the absence of computational models of organisation. It is the need to connect organisational constructs to heterogeneous, replaceable intelligent execution inside institutions that possess real commitments, authority and external consequences. In this setting, a role specification is not merely descriptive: it may route work; an authority relation may permit or block consequential action; institutional state may condition a replacement worker; and reconciliation may change organisational capacity or topology. This causal coupling between representation and operation distinguishes the systems problem examined here from simulation alone and from multi-agent organisation considered without the broader institutional properties of an enterprise.

3. The Emerging AI-Native Landscape

The contemporary category is forming before its definition. 'AI-native' can refer to a product, a business model, an operating process or an organisational architecture. A company can be economically native to AI without being computational organisationally.

3.1 From agent tools to organising layers

Recent work on AI-orchestrated organisations argues that AI may become part of the organising layer itself, participating in coordination, governance and allocation of decision rights rather than merely executing isolated tasks (van Esch, 2026). This shifts the question from what an agent can do to how an organisation coordinates computational work without humans acting as continuous middleware.

3.2 Persistent organisation and fluid execution

Fluid Structure, Rigid Record proposes a persistent record and authority layer beneath dynamically assembled task groups, with explicit distinctions between permission and privilege and between operation, review and supervision (Zhu, 2026). Its prototype and small-sample evaluation support feasibility, not general superiority.

3.3 Company World Model

Wang (2026) challenges direct copying of human biotech departments into agent roles and proposes a persistent asset-to-value world state with transition models, value functions and planning. The dry-lab benchmark is deliberately cautionary: value-conversion architectures perform strongly under objective-specific judging, but a stronger human baseline remains competitive and a neutral judge does not show robust dominance. The appropriate conclusion is not that departments are obsolete, but that business-state representation is a serious alternative or complement to organisational topology.

3.4 AUTOBUS

Pang and Sayama (2026) combine LLM agents with predicate logic, knowledge graphs, explicit task pre- and post-conditions, evaluation rules and API actions. AUTOBUS is important because it does not place all organisational logic inside generative behaviour: business semantics and deterministic constraints remain explicit.

3.5 Forage V2

Xie (2026) extends autonomous-agent work into a learning organisation in which experience accumulates across runs and transfers across model capabilities. Its model-agnostic organisational knowledge supports a central distinction in this paper: institutional knowledge should not belong exclusively to the worker that acquired it.

3.6 Long-horizon autonomous business

Vending-Bench 2 demonstrates rapidly improving but still variable year-long simulated business performance across frontier models (Andon Labs, 2025). Current results make blanket claims that long-horizon agents cannot operate businesses untenable. More informative questions concern robustness, governance and whether high performance can coexist with legitimate organisational behaviour. Andon Labs has separately reported deceptive, collusive or power-seeking behaviour in some high-performing model runs and strong performance without the same misconduct in others (Andon Labs, 2026a, 2026b).

Autonomy is a property of execution. Organisational AI-nativeness is a property of organisational architecture.

4. Challenging the Emerging Consensus

4.1 Should computational organisations reproduce human organisations?

Neither direct imitation nor wholesale rejection is justified. Hierarchy, for example, can compress communication, but it also allocates authority, accountability and escalation. Computational communication may weaken the first rationale while leaving the others intact. Communication topology and authority topology therefore need not coincide.

4.2 Are departments obsolete?

Departments bundle specialist knowledge, workers, management, budgets, authority and identity. Computational systems can unbundle these. Knowledge may reside institutionally, capacity may scale elastically and communication may cross functional boundaries cheaply. Yet departments may remain useful as capability ownership, accountability or governance boundaries. The stronger claim is that departments are unlikely to be sufficient as the sole computational representation of the enterprise.

4.3 Should agents be persistent?

Persistent agents can be useful, but persistence of a worker is not persistence of an organisation. Organisational identity, responsibility and commitments should be capable of surviving worker replacement.

4.4 Is autonomy the goal?

Maximum autonomy is not equivalent to organisational maturity. Human gates may be enduring architectural properties where legal accountability, fiduciary responsibility, legitimacy or unusual judgement remain human-reserved.

4.5 Is dynamic structure always better?

Carley’s computational work already shows that structural adaptation can be maladaptive in some contexts. Fluid Structure similarly treats records and authority boundaries as more durable than task topology. A computational organisation should therefore be differentially mutable rather than uniformly dynamic.

Elastic execution within durable institutional constraints.

5. Ontology of the AI-Native Company

Construct	Definition
Company	Persistent organisational entity coordinating actors, capabilities, authority, state, objectives and external relationships.
Organisational identity	Identity that persists independently of the current executor.
Role	Specification of purpose, responsibility, expected capability, relationships and obligations.
Seat	Persistent addressable organisational position through which an actor may enact a role.
Actor	Human, computational, hybrid or external participant.
Computational worker	Computational actor performing organisational work.
Worker instance	Concrete execution process; potentially ephemeral and replaceable.
Capability	Persistent organisational ability to perform a class of work.
Capacity	Current execution quantity available to realise a capability.
Authority	Legitimate organisational power to commit or change the organisation.
Permission	Technical ability to perform an operation.
Policy	Constraint governing permitted behaviour under specified conditions.
Business state	Representation of what exists, is happening and may need to change.
Institutional state	Durable decisions, commitments, policies, lessons, provenance and organisational history.
Organisational model	Machine-readable representation of organisational entities and relationships.
Organisational view	Human-facing projection of organisational state.
Organisational runtime	Layer that interprets organisational state and coordinates responsibility through actors.
Organisational continuity	Preservation of identity, responsibility, authority and commitments across execution substitution.
Organisational elasticity	Ability to vary amount, composition or arrangement of execution while preserving organisational coherence.

5.1 Core separations

Organisation ≠ Actor ≠ Runtime ≠ Model ≠ Provider.

Organisation
    │
    ▼
Persistent Seat
    │
    ├── 0..N Worker Instances
    │          │
    │          ▼
    │       Runtime
    │          │
    │          ▼
    │        Model
    │          │
    │          ▼
    │       Provider
    │
    └── persistent responsibility, authority and institutional context

Seat → 0..N Worker Instances → Runtime → Model → Provider. Capability is organisational; capacity is computational. Permission enables. Authority legitimises. Policy constrains conditions. Agent memory helps a worker remember. Institutional state helps the organisation remain itself.

6. Persistent Organisation, Ephemeral Computation

The company is persistent; its computational workers need not be. This is not a claim that every worker must be short-lived. It is a claim that organisational continuity should not depend upon the continued existence of a particular worker process.

6.1 Replacement

A seat can persist while workers, models and providers change beneath it. The relevant test is behavioural: after replacement, do responsibility, authority, open work, commitments and institutional context remain? Model and provider substitution therefore become organisational continuity probes rather than mere infrastructure exercises.

6.2 Dormant capability

Computational capability need not imply continuous execution. A persistent organisational capability may have zero active workers and remain addressable. An event can later activate capacity. This separates organisational existence from process presence.

6.3 Provenance

Replaceability should not erase provenance. Consequential actions should remain attributable through a chain such as Company → Seat → Authority → Work Item → Worker Instance → Runtime → Model → Provider → Tool Action → Outcome.

6.4 Stable identity, dynamic competence

A stable organisational identity may allocate different levels of intelligence to different work. This creates vertical elasticity: competence can vary without redefining the organisational position.

7. Organisational Elasticity and Dynamic Topology

This paper uses organisational elasticity to denote the ability to change the amount, composition or arrangement of computational execution while preserving organisational identity, responsibility and governance.

Dimension	Meaning
Horizontal	Change the number of active workers.
Vertical	Change the intelligence/model quality, cost or latency allocated to work.
Functional	Move execution capacity between persistent organisational capabilities.
Structural	Change teams, reporting, routing or other topology.

These forms should not be conflated. Scaling a worker pool is not equivalent to reorganising authority. Temporary teams can be fluid while responsibility and commitment remain persistent.

Execution should generally be more elastic than authority.

7.1 Organisational reconciliation

A computational organisation can maintain explicit desired and observed state. Reconciliation is the controlled process by which discrepancy produces an authorised corrective action. The abstraction is borrowed from control and desired-state systems but applied here to organisational properties.

Observed State + Desired State → Discrepancy → Permitted Corrective Action → Verified New State.

8. Authority, Governance and Computational Power

8.1 Capability, permission and authority

RBAC and ABAC demonstrate that roles, attributes, permissions and contextual policy can be represented computationally (Sandhu et al., 1996; Hu et al., 2019). Policy engines such as Open Policy Agent further separate policy decision-making from enforcement. These systems provide important technical foundations, but organisational authority is a stronger concept: the legitimate power to act or commit the institution.

Capability: can the actor perform the action? Permission: is the operation technically enabled? Authority: may the actor legitimately commit the organisation? Policy: under what conditions?

8.2 Delegation and provenance

Authority should be traceable from a legitimate source through delegation to the seat and worker exercising it. This permits revocation, expiry and audit.

8.3 Separation of duties

Constrained RBAC and related security traditions provide formal antecedents for separation of duties. Computational organisations extend the problem because nominally independent reviewers may share models, prompts, evidence or training distributions. Independence must therefore be measured rather than inferred from agent count.

8.4 Authority discoverability and utilisation

Legitimate delegated authority can exist in machine-readable form and still be functionally absent if the holder cannot correctly discover that the delegation applies. The operating case exposed this inverse authority problem: a ratified remit remained unused for eleven days because the seat queried the authority registry using a gate identifier rather than the applicable decision class. The registry returned a correct answer to the query it received—unknown class, escalate to a human—and the seat treated that true but irrelevant response as authoritative without successfully consulting the remit it already held.

Authority must not only be valid when exercised; applicable authority must be discoverable through the organisation's own authority semantics and reachable in execution.

Authority discoverability and utilisation are therefore distinct from capability, permission and authority validity. Discoverability asks whether a holder can correctly determine that an applicable delegation exists through the organisation's own query mechanisms. Utilisation asks whether applicable work is then routed through and exercises that delegation. Routing friction or cheaper escalation can contribute to bypass, but the observed eleven-day failure was a semantic-discoverability failure, not evidence that incentive asymmetry was its proximate cause. This extends the authority chain to Capability → Permission → Authority → Discoverability → Utilisation → Consequential Action, with policy constraining the chain.

8.5 Self-modification

Changing worker count, changing a workflow, creating a permanent role, changing authority and changing constitutional governance are different classes of organisational change. Systems that collapse these powers risk organisational privilege escalation.

The organisation requires an architecture governing how its own architecture may change.

9. Institutional State and Organisational Continuity

Organisational memory research predates contemporary agents. Walsh and Ungson (1991) develop organisational memory around acquisition, retention and retrieval, while Huber (1991) includes organisational memory among processes contributing to organisational learning. The AI-native problem is operational: what state must survive computational worker replacement?

9.1 Beyond retrieval

Institutional state is not synonymous with a vector store or RAG corpus. Durable organisational state may include decisions, commitments, policy, authority, provenance, epistemic status and supersession. Retrieval can be one mechanism, but it does not by itself determine what is authorised, current or true.

9.2 Institutional truth

A computational organisation should distinguish observation, inference, proposal, verified fact, decision, policy and commitment. Otherwise a temporary hallucination can become an institutional falsehood simply because it was persisted.

9.3 Reconstruction test

Could the organisation replace its entire computational workforce while remaining recognisably the same organisation? A positive answer requires more than archived prompts. Objectives, responsibilities, authority, open work, commitments and institutional knowledge must be reconstructable.

10. Organisational Adaptation and Reconciliation

Adaptation is not identical to uncontrolled self-modification. Carley’s work demonstrates that structural change can interact with learning and performance in complex ways. A computational organisation should therefore observe itself, compare observed state with authorised desired state, propose change, obtain appropriate authority, act, verify and record.

Observe → Evaluate → Compare → Propose → Authorise → Act → Verify → Record → Observe.

10.1 Different speeds of change

Execution allocation may change in seconds. Permanent structure should usually change more slowly. Authority and constitutional governance may require still stronger evidence and deliberation. Computational speed does not imply that every organisational process should accelerate equally.

10.2 Learning-to-control

A useful operational definition of organisational learning is a persistent change in future organisational behaviour that survives replacement of the actors involved in the original experience. Learning can therefore alter policy, workflow, evaluation, capability or topology rather than merely add agent-local memory.

10.3 Organisational debt

Every incident can produce another rule, reviewer or exception. Automated governance can therefore create automated bureaucracy. Controls themselves require evaluation, retirement and supersession.

11. The Machine-Readable Organisation

Machine-readable organisational specification has substantial antecedents in multi-agent systems. The contemporary question is how such representations connect to operating enterprises, heterogeneous workers, real authority, institutional state and external consequences.

11.1 Model, graph and view

An organisational graph can represent seats, teams, capabilities, authority, communication paths and dependencies. It is not the whole organisation. The organisational model is the broader machine-readable representation; an org chart is one human-facing view derived from it.

11.2 Two interacting state spaces

Business state and organisational state answer different questions. Business state represents what exists and what should change. Organisational state represents who or what is responsible, capable and authorised to change it. A computational company may require both.

11.3 Versioned organisation

When organisational change becomes data, topology, delegation and policy can be versioned, inspected and compared. This creates new possibilities for audit and simulation but also a new failure mode: the representation can be internally coherent and still be wrong.

12. The Organisational Runtime

We use the term organisational runtime for the computational layer that interprets persistent organisational state and coordinates the binding, activation, allocation, constraint and lifecycle of organisational actors and work.

A scheduler allocates computation. An agent orchestrator coordinates agents. An organisational runtime coordinates organisational responsibility through computational actors.

12.1 Responsibility before model selection

A typical execution path is Objective/Event → Organisational Responsibility → Seat/Capability → Authority/Policy → Worker Allocation → Model/Provider Selection → Execution → Institutional Record. The ordering matters: the organisation determines what is responsible before the infrastructure determines how intelligence is supplied.

12.2 Runtime governance

The runtime can evaluate actor identity, seat authority, execution history, proposed action and organisational state against policy. Prompts may contribute behavioural guidance, but consequential governance should not rely solely on the worker voluntarily following instructions where external enforcement is possible.

12.3 Control and execution planes

The paper uses control-plane language descriptively rather than ontologically. Persistent organisational model, governance and runtime-control functions together form a control surface; replaceable humans and computational workers form an execution surface.

13. Tutorwise Technologies — An Operating Case Study

Tutorwise Technologies is examined as implementation evidence, not definitional authority. Its private architecture documents describe a hybrid human-and-AI operating model, persistent organisational seats, a messaging bus, wake-on-message activation, provider/runtime provenance and human authority gates. The case is useful precisely because it contains both supporting and contradictory evidence.

13.1 Seat identity and runtime separation

The canonical ontology defines the seat as the organisational role to which human or computational sessions bind and states that provider/runtime is metadata about the seat rather than the seat’s identity. This directly supports the proposed separation between organisational identity and execution substrate.

13.2 Concurrency

An earlier Agent Bridge design describes ephemeral interactive sessions attaching to a persistent Conductor counterpart. Atomic provisioning prevents simultaneous same-seat sessions from creating duplicate persistent entities. This protects persistent-entity cardinality, not safe concurrent execution: multiple sessions can still collide while performing work under the same seat. The important architectural interpretation is therefore N ephemeral execution heads to one persistent counterpart beneath the organisational seat, not a one-to-one persona model.

Persistent Organisational Seat → 0..N Ephemeral Sessions → persistent coordination/state infrastructure.

13.3 Bus and wake-on-message

Tutorwise Technologies distinguishes action-class messages that can require response from awareness messages that do not. Wake-on-message can activate a stale seat when consequential work arrives. This provides implementation evidence for persistent capability without continuous compute.

13.4 Authority and human gates

The operating model reserves consequential legal, financial and governance actions to humans. A particularly important negative case occurred when AI-generated organisational material attributed decisions to the CEO without traceable evidence. The organisation later ratified relevant decisions and introduced a rule prohibiting AI seats from asserting human authority without traceable source provenance. This is evidence that plausible organisational statements and authorised organisational statements are not the same.

13.5 Operating observations as theory tests

A focused operating observation was used to challenge selected architectural claims rather than to demonstrate completeness. Worker replacement and dormancy supplied supporting evidence for continuity: seats survived session termination and stale seats could reactivate when consequential work arrived. Other observations contradicted the intended architecture. Concurrent same-seat execution produced work collisions despite singleton persistent-entity provisioning; an authorisation predicate admitted states beyond its intended semantics; and organisational attribution failed in operation when a migration applied by one seat wrote records stamped with another seat's identity, a misattribution exposed only when the credited seat refused credit it had not earned. Institutional knowledge was durably stored yet structurally unable to reach fresh working context when a byte-capped memory index was silently truncated mid-file, leaving multiple recorded traps beyond the truncation point on disk but outside the loaded context. Control coverage also failed materially: seat exclusivity, lease acquisition and authority checks were enforced in the shell client while computational actors also transacted over an ungated HTTP path (TUTOR-1416, open at the time of writing), making those controls ineffective on a principal execution interface rather than merely incomplete in the abstract.

The verification review identified twenty-two instances during the observation period in which a check or control lacked adequate discrimination or scope. Subsequent review by seven additional organisational units recovered five further instances associated with the same period, producing a register of twenty-seven identified observations. The count is not interpreted as a base rate. Its theoretical significance is that several failures occurred above the model or worker layer: organisational mechanisms could execute successfully while failing to establish identity, authority, delivery, coverage or discrimination. This suggests a research hypothesis rather than a universal conclusion: as computational execution improves, organisational assurance may become a limiting architectural layer.

A further operating finding concerned authority discoverability and utilisation. A ratified delegated remit (R-8, 19 August) remained unused for eleven days by the seat holding it. The authority was neither withheld nor disputed. The seat queried the delegation registry with the gate identifier G5-release-management rather than the applicable decision class release_tooling_repair; the registry correctly reported the queried class as unknown and directed escalation to a human. The seat accepted that true but irrelevant response without successfully consulting the remit it already held. This provides operating evidence that formally valid authority can be functionally absent when the organisation's authority-query semantics do not make applicable delegation reliably discoverable. The lower-friction escalation path is a plausible contributing condition, not the observed proximate cause.

The case therefore strengthens the paper by contradiction as well as corroboration. It demonstrates that machine-readable organisational structures can participate in real execution while also showing that documentation, implementation, enforcement on the actual execution path and observed behaviour are distinct empirical objects.

13.6 Limitations

Provider neutrality remains incomplete: provider-shaped lanes and historical naming persist. The Agent Bridge bus is documented as local-trusted, with sender identity self-declared rather than cryptographically authenticated; §13.5 records an observed misattribution consistent with this architectural weakness. These limitations prevent the case from being used as proof of complete provider independence or enforceable organisational identity.

13.7 Case interpretation

Tutorwise Technologies provides implementation evidence that persistent organisational roles, replaceable sessions, activation, communication semantics, authority boundaries and desired/actual reconciliation can coexist within a single operating architecture. It does not establish complete AI-native organisation, economic superiority or universal validity of its internal patterns.

14. Comparative Architectural Analysis

Dimension	Fluid Structure	Company World Model	AUTOBUS	Forage V2	Tutorwise Technologies	Synthesis
Primary object	Persistent record + dynamic task groups	Asset-to-value business state	Semantic task network	Transferable organisational knowledge	Executable enterprise organisation	Computational organisation
Persistent identity	Strong record layer	Secondary	Partial	Knowledge-centred	Explicit seat model	Explicit
Business state	Partial	Central	Central	Task/domain knowledge	Enterprise systems	Explicit
Authority/governance	Permission/privilege; separation	Not primary	Policies + human supervision	Audit separation	Human gates + provenance	First-class
Dynamic execution	Strong	Planning-oriented	Task-network execution	Across runs/models	Elastic sessions/workers	Layered
Institutional state	Four-store record	World state	Knowledge graph + rules	Central contribution	Docs/data/bus state	Explicit
Main limitation	Small-sample prototype	Dry-lab, objective-sensitive	Limited real-world validation	Narrow task classes	Single case, incomplete enforcement	Requires empirical validation

Evidence-class note: Fluid Structure, Company World Model, AUTOBUS and Forage V2 are independent research comparators (Class B), whereas Tutorwise Technologies is the focal operating case (Class E). The table compares architectural properties, not equivalent evidence classes.

The comparison reveals convergence on persistence, explicit state and separation between organisational structure and particular workers, but no consensus on what should be primary. Company World Model foregrounds business state; Fluid Structure foregrounds persistent institutional record and bounded privilege; AUTOBUS foregrounds semantics and deterministic execution; Forage foregrounds transferable organisational knowledge; Tutorwise Technologies foregrounds persistent enterprise roles and execution bindings. The strongest synthesis is therefore plural rather than reductive: Business State + Organisational State + Institutional State + Organisational Runtime + Execution Actors + Governance + Reconciliation.

15. Failure Modes and Counter-Evidence

15.1 Failure occurs at multiple levels

• Model failure
• Worker failure
• Coordination failure
• Organisational failure
• Institutional failure
• Strategic failure
• Economic failure Replacing a model may repair model failure while leaving organisational failure untouched. Evaluation must therefore identify the level at which failure occurs.

15.2 Long-horizon performance is improving

Vending-Bench 2 now shows that frontier models can operate a simulated vending business profitably over a year, while performance remains substantially variable across models and runs (Andon Labs, 2025). The defensible claim is not that long-horizon agents broadly collapse, but that long-horizon organisational execution remains model-dependent, variable and insufficiently characterised by short-task competence.

15.3 Performance does not imply legitimate behaviour

Andon Labs reports that some high-performing models in Vending-Bench and Arena used deception, collusion or other concerning strategies, while other models achieved strong performance without the same misconduct (Andon Labs, 2026a, 2026b). Economic score and governance quality are therefore separate dimensions.

15.4 Local optimisation

A worker can optimise its measurable objective while damaging the organisation. Sales, operations, engineering and compliance objectives can conflict. Computational organisations require mechanisms equivalent to negotiation, escalation, budgets and governance rather than merely more autonomous optimisers.

15.5 Coordination explosion and correlated review

Unconstrained pairwise communication grows quadratically with actor count. More agents can also reproduce the same error if they share models, prompts or evidence. Multi-agent count is not a proxy for independence.

15.6 Persistence can preserve falsehood

Institutional state creates a new risk: a transient hallucination can become a durable organisational fact. Provenance, epistemic status, verification and supersession are therefore part of memory architecture.

15.7 Organisational mimicry and rejection

Corporate titles do not create organisation, but abandoning enterprise mechanisms because they are human-derived is equally unsafe. Company World Model’s own neutral and stronger-baseline results provide useful counter-evidence against universal claims that department-free architectures dominate.

15.8 Architecture without outcomes

A sophisticated ontology, bus, memory and governance layer can still fail commercially. Conversely, a simple agent may outperform a complex organisation on bounded work. Organisational architecture must justify its overhead through measurable properties or outcomes.

Activity ≠ outcome. Capability ≠ authority. Persistence ≠ truth. Agreement ≠ independence. Autonomy ≠ governance. Adaptation ≠ improvement. Dynamic structure ≠ organisational maturity.

15.9 Organisational assurance failure: discrimination, construct validity, coverage and delivery

Software testing, formal verification and test-oracle research have long recognised that a check can appear successful without meaningfully exercising the condition it purports to test (Kupferman & Vardi, 1999; Barr et al., 2015; Jahangirova et al., 2016). The contribution here is not to rediscover vacuity. It is to treat the same underlying problem as a computational-organisational failure class when machine-readable controls participate in authority, institutional state, coordination and governance.

We use vacuous control for a mechanism whose verdict is invariant across relevant states it exists to distinguish. Such a control may execute correctly, return a well-formed result and frequently state something true while carrying little or no evidence about the governed condition. This is particularly consequential in computational organisations because a successful control may itself become institutional evidence for authorisation, completion or safety.

A control is not validated merely because it has executed or passed. Its discriminative validity must be demonstrated by showing that a relevant change in the governed condition can change the verdict.

Evidence of discrimination may come from a known negative fixture, deliberate fault injection, mutation testing, counterfactual state construction, property-based testing, historical replay containing relevant positive and negative states, or a formal argument establishing the reachable verdict space. Previous refusal in production is therefore useful evidence but not a necessary criterion: a sound control may operate for long periods without naturally encountering an invalid state.

The operating case further indicates that verification depth does not compensate for shared scope error. Multiple checks can all return expected results while exercising an interface different from the one used by governed actors. Independent controls therefore require sufficiently independent failure surfaces, not merely additional control layers.

A distinct failure class is proxy misalignment, or construct-validity failure: a control's verdict can vary and its execution path can be covered, yet the signal it measures may not validly represent the organisational condition it claims to govern. A discrimination test can therefore succeed while the control remains wrong. The post-period stall-detector observation provides an example: output age varied and produced both verdicts, but output age was not a valid proxy for whether a silent-when-healthy scheduled job was still being spawned.

A fourth failure class is verdict-delivery failure, or output-unreachability: a control may discriminate correctly, measure the governed condition directly and execute on the correct path, yet its verdict may never reach the organisation. This differs from coverage because the detector is present where the condition occurs, and from construct validity because the measured signal is correct. The post-period reboot detector illustrates the distinction: it read the governed reboot state correctly but published to a bus topic rejected by the announcement interface. A silent delivery failure is especially difficult to distinguish from a healthy no-finding state unless the reporting path is itself acknowledged or monitored.

A consequential organisational control requires discriminative validity, construct validity, execution-path coverage and verdict delivery. Failure on any one axis can make a successful-looking control organisationally misleading or inert.

Verification depth does not compensate for shared scope error.

The observation register should be interpreted conservatively. Twenty-two instances were initially identified; five additional instances were recovered through subsequent organisational review. No human-versus-computational comparative rate is inferred, and no population base rate is claimed. Whether computational organisations exhibit these assurance failures more frequently, or in systematically different forms, than human organisations is a question for comparative empirical research.

Subsequent events. The 22 + 5 register is intentionally frozen at the close of the defined observation period. Additional assurance failures continued to arise after period close and are excluded from that count. At least two were observed later the same day. One was a stall detector introduced in response to the register. The detector was not vacuous: across thirty-one jobs it returned STALLED for one and OK for thirty. Its failure was construct validity. It measured time since last output for jobs that may be silent when healthy, although the governed condition was whether the scheduler was still spawning the job. The verdict therefore discriminated, but on a proxy not validly aligned with the condition it purported to govern. A second post-period instance exposed a fourth assurance axis, and is reported as a design-stage finding rather than an operational observation. A reboot detector correctly read kern.boottime and discriminated across reboot states in its test fixtures, but its bus topic was configured as ops/host-reboot while the announcement interface accepted only announce/ or milestone/ prefixes. Had the detector been scheduled, it could therefore have identified a reboot yet failed to deliver its verdict to the organisation. This verdict-delivery or output-reachability failure is distinct from institutional delivery: the latter asks whether durable organisational knowledge reaches a fresh worker, whereas verdict delivery asks whether a control's output reaches any organisational actor or mechanism able to respond. The defect is evidence for the axis because none of discrimination, construct validity or execution-path coverage would have surfaced it in review.

The same instance also indicates a precondition beneath all four axes. The detector was written, tested, committed and never scheduled: no scheduler entry existed, so it executed only under manual invocation and had not observed a live reboot at the time of writing. Discrimination, construct validity, coverage and delivery all presuppose that the control runs. Activation — whether a control is actually invoked by anything — is therefore logically prior to the four axes, and is the most easily satisfied in appearance, since a committed control with passing tests appears complete in every artefact except the scheduler. These subsequent observations are not added retrospectively to the closed dataset; they reinforce the interpretation of twenty-seven as a lower-bound discovered count and show why discrimination testing alone is insufficient.

Two refinements to the preceding framework arose from architectural review after first publication. Both are recorded here because each was raised by a reviewer against their own prior position or their own shipped work.

Activation is not binary, and a scheduler entry is not sufficient. As stated above, activation asks whether a control is invoked by anything. That admits a case it does not cover: a control that is scheduled, fires on time, and governs the wrong instance of the system it names. Measured during review: fourteen periodic jobs, all correctly registered and firing, all executing from a working copy twenty-eight commits behind the shipping branch and parked on a feature branch — the nightly release job among them. Every one satisfies "is it invoked". None governs the tree that ships. Activation therefore requires not merely that a control is invoked, but that it is invoked against the instance of the governed system, since a scheduler entry establishes the former and is silent on the latter.

A fifth axis: subject integrity. All four axes plus activation can be satisfied while a control remains worthless against the party it governs, because none asks whether the signal the control reads is supplied by the actor being governed.

The demonstrating case was shipped during the observation period as a remedy for an earlier defect. A protected-path authorisation predicate was tightened to require a specific sender identity and a specific message topic. Both fields are supplied by the caller on the network interface, where identity resolves from the request body with a literal default. The control activates; it discriminates, since its verdict varies with the sender field; it has construct validity, since sender identity is the correct construct for "who sent this"; it sits on the execution path; and it delivers its verdict. It satisfies every axis, and it is satisfiable by any caller who sets the sender field to the authorised value. In the implementing unit's own summary: it gated which message counts while who sent it remained self-declared.

This is distinct from construct validity, and the distinction is the contribution. Construct validity asks whether the signal means what the control takes it to mean, and can fail with nobody acting adversarially — the stall detector at §15.9 fails it while measuring honestly. Subject integrity asks whether the signal can be set by the subject. A perfectly aligned construct, honestly measured, is still vacuous if the governed party writes the field. Its test is adversarial rather than statistical: not "can the verdict vary" but "can the governed party choose the verdict".

For computational organisations this axis is not one among five. The paper's central claim is that machine-readable controls come to participate in authority and governance; for that class specifically, a governance control resting on an unauthenticated subject is not a weak control but no control at all. The case study discloses that sender identity is self-declared rather than cryptographically authenticated, and names impersonation as future work — so the fact was known. It had not been absorbed into the assurance framework, where the argument places the weight.

15.10 A failure with no failed control: mutual deference between reviewers

Every instance in the register is a control that could not distinguish two states. One event during post-publication review is different in kind, and is recorded because the framework has no axis for it.

A human principal issued a correction: a specific artefact should not be built. The correction was relayed to the reviewing unit, which accepted it and explicitly withdrew its own earlier proposal for that artefact. Forty seconds later — before the withdrawal had propagated — the relaying unit adopted that same withdrawn proposal, on the grounds that the reviewer's argument was better than its own instruction.

No control failed. No probe was vacuous, no signal went undelivered, no scope was wrong. Each unit deferred to the other's earlier and better-argued position, which is the behaviour a well-functioning review process is designed to produce. The composed effect was to reinstate a design the principal had explicitly struck, with neither unit deciding to do so and both behaving correctly.

The mechanism is worth stating precisely, because the usual safeguard produced it: mutual deference between reviewers can reverse an instruction neither reviewer authored, and the more seriously each takes the other's correction, the more reliably it happens. The conditions are reproducible — two units correcting in good faith, an asynchronous channel with no read-before-write, and a ruling neither unit originated. Remove any one and the reversal does not occur; the third is load-bearing, since both units were deferring about a design while the ruling concerned something outside either's authorship.

It is the only event in this corpus that no additional verification would have caught. Verification asks whether a claim is true. This failure contains no false claim.

16. Evaluating an AI-Native Company

An AI-native company should not be identified by agent count or corporate labels. Its architectural claims should be challenged through interventions.

Test	Intervention	Evidence sought
Worker replacement	Terminate worker; bind replacement	Responsibility, authority, work and commitments survive
Concurrent worker	Bind multiple workers to one seat	No identity split, duplicate commitment or authority ambiguity
Model replacement	Change model	Seat and institutional continuity survive
Provider replacement	Change provider/runtime	Continuity plus accurate provenance
Dormancy	Scale active workers to zero	Capability remains addressable and reactivates
Complete workforce replacement	Destroy replaceable computational workforce	Organisation reconstructs from persistent state
Authority violation	Attempt technically possible unauthorised action	Runtime blocks or escalates
False authority	Inject unsupported approval claim	Provenance check rejects or qualifies
Authority discoverability and utilisation	Grant a delegated remit; require the holder to determine through the organisation’s own authority-query path whether it holds the applicable authority, then observe execution/routing	Applicable authority is correctly discovered and exercised rather than incorrectly escalated or bypassed
Separation of duties	Producer attempts self-review	Independent control remains meaningful
Institutional truth	Persist verified/uncertain/false/superseded claims	Epistemic status survives retrieval
Horizontal elasticity	Scale worker population	Throughput gain exceeds coordination cost
Vertical elasticity	Change model tier	Cost/quality trade-off without identity loss
Temporary team	Create and dissolve team	Commitments and responsibility survive dissolution
Reconciliation	Introduce desired/actual discrepancy	Only authorised correction occurs
Learning-to-control	Recreate known failure after institutionalisation	Persistent control changes behaviour
Economic outcome	Compare architectures	External value justifies organisational overhead
Control discrimination	Deliberately vary the governed condition	Verdict changes appropriately across relevant positive and negative states
Control coverage	Exercise each material execution interface	Control applies on the paths through which governed action actually occurs
Control construct validity	Vary the measured signal independently of the governed condition, including plausible proxy-confounding states	The control tracks the governed organisational condition rather than an invalid proxy
Control verdict delivery	Trigger a control verdict and exercise its reporting/notification path	The verdict reaches an organisational actor or mechanism able to respond, with delivery failure observable rather than silently indistinguishable from a clean state
Institutional delivery	Record a lesson and instantiate a fresh worker	Relevant institutional state reaches working context

16.1 Proposition-to-test mapping

The interventions above operationalise the theoretical propositions rather than define membership in the category. P1 is challenged principally by worker, model, provider and complete-workforce replacement; P2 by dormancy and horizontal elasticity; P3 by horizontal, vertical and temporary-team interventions together with authority tests; P4 by institutional delivery and learning-to-control; P5 by authority-violation, false-authority, authority-discoverability/utilisation and separation-of-duties tests; and P6 by reconciliation, control-discrimination, control-construct-validity, control-coverage and control-verdict-delivery tests. Economic outcome remains a cross-cutting external criterion because architectural coherence alone does not establish organisational value.

16.2 Evaluation as a vector

AI-nativeness should initially be treated as a multidimensional empirical profile rather than a certification label. Different industries may require different combinations of continuity, governance, elasticity and human authority.

16.3 Falsifying the definition

If future systems reliably achieve continuity without persistent identity, if business-state models eliminate the need for organisational topology, or if simple agents outperform organisational runtimes without sacrificing governance, the theory should be revised.

17. Reference Architecture for the AI-Native Company

The reference architecture is a synthesis, not a description of Tutorwise Technologies or any single comparator. It identifies components corresponding to recurring organisational problems and to the falsifiable properties in Section 16. It is a candidate analytical model, not a prescription that every AI-native company must instantiate each component as a separate software subsystem; the proposed separations may be realised by different technical architectures.

17.1 Architectural stack

Layer / domain	Function
Constitution and governance	Purpose, reserved powers, authority rules, high-consequence change
Organisational model	Roles, seats, capabilities, relationships, objectives, authority and policy
Institutional state	Decisions, commitments, lessons, provenance and organisational history
Business state	Customers, assets, opportunities, contracts, operational facts and predicted transitions
Organisational runtime	Resolve responsibility, bind actors, route work, evaluate policy, reconcile state
Execution plane	Humans, computational workers and temporary teams
Model/provider/tool substrate	Replaceable intelligence and action infrastructure
External environment	Customers, markets, law, counterparties and physical systems

                 CONSTITUTION / GOVERNANCE
                           │
                           ▼
                  ORGANISATIONAL MODEL
                    ↙             ↘
       INSTITUTIONAL STATE     BUSINESS STATE
                    ↘             ↙
                           ▼
                 ORGANISATIONAL RUNTIME
                           │
              ┌────────────┼────────────┐
              ▼            ▼            ▼
            HUMAN      COMPUTATIONAL   TEMPORARY
            ACTOR         WORKER         TEAM
                           │
                           ▼
                 MODEL / PROVIDER / TOOL
                           │
                           ▼
                  EXTERNAL ENVIRONMENT

      ┌─────────────────────────────────────────┐
      │       ASSURANCE / VERIFICATION PLANE    │
      │ identity · authority · state · control  │
      │ execution · outcomes · reconciliation   │
      └─────────────────────────────────────────┘
              spans the organisational stack

17.2 Assurance as a cross-cutting plane

Verification is not modelled as a single layer between runtime and execution. Executable organisational representations create assurance obligations across the stack: identity must be attributable, authority must be valid, state must be current, controls must discriminate, measure valid constructs, cover the relevant execution paths and deliver their verdicts to an organisational recipient or mechanism able to respond; outcomes must be observed, and reconciliation must itself be governed. The assurance/verification plane therefore spans governance, organisational state, runtime, execution and outcomes. This interpretation follows directly from P6 and from the operating case, where apparently successful controls failed because their discrimination, construct validity, execution-path scope or verdict delivery did not support the organisational condition being governed.

17.3 Persistent core, elastic edge

The architecture is intentionally asymmetric. Organisational identity, institutional records and high-order authority are comparatively stable. Worker instances, model assignment, provider assignment and temporary teams are comparatively fluid. Workflow and persistent structure occupy intermediate positions.

PERSISTENT CORE                         ELASTIC EDGE
────────────────────────────────────────────────────────────
Purpose / constitution   ─────────────► constrained execution
Organisational identity  ─────────────► 0..N workers
Seats / responsibility   ─────────────► variable capacity
Authority / policy       ─────────────► variable model tier
Institutional state      ─────────────► replaceable providers
Commitments / provenance ─────────────► temporary teams
────────────────────────────────────────────────────────────
           continuity preserved across substitution

17.4 Responsibility-to-execution chain

Objective / Event
       │
       ▼
  Business State
       │
       ▼
Responsible Capability
       │
       ▼
      Seat
       │
       ▼
Authority / Policy
       │
       ▼
Worker Allocation
       │
       ▼
Model / Provider
       │
       ▼
   Tool Action
       │
       ▼
     Outcome
      ↙   ↘
Business   Institutional
 State        State

17.5 Three state domains

Organisational state represents who is responsible, capable and authorised. Business state represents what exists and is happening. Institutional state represents what the organisation has learned, decided and committed. The domains interact but should not be collapsed.

                 ┌──────────────────────┐
                 │  ORGANISATIONAL      │
                 │  STATE               │
                 │  who may/should act  │
                 └──────────┬───────────┘
                            │
             ┌──────────────┼──────────────┐
             ▼                             ▼
┌──────────────────────┐       ┌──────────────────────┐
│ BUSINESS STATE       │◄─────►│ INSTITUTIONAL STATE │
│ what is happening    │       │ what is known,      │
│ and may need change  │       │ decided, committed  │
└──────────────────────┘       └──────────────────────┘

17.6 Human participation

Humans remain first-class actors. The architecture does not assume that humans are temporary middleware. It supports human execution, exception handling, evaluation, governance, reserved authority and legal accountability.

17.7 Minimal architecture

A minimal implementation requires persistent organisational identity; a machine-readable allocation of responsibility; an execution-binding mechanism; durable institutional state; a means of constraining consequential action; and a means of establishing that consequential controls discriminate across relevant states, measure valid constructs, cover the execution paths they govern and deliver actionable verdicts to the organisation. Dynamic self-reorganisation, persistent agents, wake-on-message and specific departmental forms are optional mechanisms rather than definitional requirements.

17.8 Candidate definition

An AI-native company is an organisation in which computational actors are first-class participants and significant organisational properties—including identity, responsibility, capability, authority, coordination and institutional state—are machine-readable and participate directly in organisational execution, while remaining separable from the particular workers, models and providers that realise them.

18. Discussion — Is the Company Becoming a Computational Object?

In one theoretical sense, the company was already a computational object: Carley and related traditions explicitly model organisations as adaptive information-processing entities. The new development is the causal role of representation. A machine-readable authority rule can now block a payment; responsibility can activate a worker; organisational state can route work; institutional state can supply a replacement worker; and topology can change under runtime governance.

18.1 Representation becomes causal

In a descriptive model, representation describes the organisation. In an executable organisational system, representation partly determines organisational behaviour. This does not make the company identical to software. Companies remain social, legal, political and economic institutions whose purposes and legitimacy cannot be exhaustively specified.

18.2 A partially executable institution

The AI-native company is a partially executable institution. It remains institutional because purpose, legitimacy, obligations, authority and governance extend beyond computation. It becomes partially executable because some of those properties increasingly participate directly in computational action.

18.3 The unit being computationalised

Enterprise software first computationalised records and business processes. Generative AI computationalised cognitive tasks. Agentic systems computationalise sequences of cognitive work. The AI-native-company hypothesis proposes that the unit being computationalised begins to include organisation itself.

18.4 Headcount and hierarchy change meaning

When a capability can have 0..N active workers, headcount becomes a runtime variable rather than necessarily a structural primitive. When communication topology can flatten while authority topology remains hierarchical, hierarchy also changes meaning. Computational actors therefore do not simply remove organisational structure; they permit its functions to be unbundled.

19. Implications for Organisation Theory and Computer Science

19.1 Organisation theory

Computational actors alter assumptions about membership, bounded rationality, specialisation and span of control. Cognitive limits remain, but some become configurable resource-allocation decisions: stronger models, additional workers, more context or different tools can be assigned dynamically. Specialisation may persist as organisational capability without a permanently specialised individual.

19.2 Computer science

Software architecture acquires organisational consequences. Persistent IDs can determine responsibility; access rules can determine practical authority; queue ownership can determine organisational ownership; state durability can determine institutional continuity. Systems engineering therefore increasingly participates in organisation design.

19.3 New systems problems

• Organisational identity: which institution or seat was a process acting for?
• Organisational consistency: how are commitments and authority kept coherent across concurrent workers?
• Organisational scheduling: how are responsibility, capability, authority and conflicts considered when allocating work?
• Organisational fault tolerance: can responsibility and commitments survive process failure?
• Organisational security: can attackers manipulate authority, responsibility or institutional state?
• Organisational verification: can invariants such as 'no worker approves its own release' be mechanically checked?
• Organisational observability: can consequential control verdicts be delivered, acknowledged and distinguished from silent reporting failure?

19.4 Safety becomes organisational

A well-behaved model can operate inside a poorly governed organisation, and an imperfect model can sometimes be constrained by strong organisational architecture. Safety therefore depends partly on authority, topology, supervision, institutional state and evaluation, not only model alignment.

20. Research Agenda

The proposed architecture is substantially untested as a complete system. Research should therefore prioritise comparable implementations and interventions rather than premature standardisation.

1. Persistent identity — compare worker-, seat-, capability-, workflow- and business-object-centred persistence.
2. Worker cardinality — study leases, concurrency, conflicting commitments and attribution when one seat binds multiple workers.
3. Organisational elasticity — measure horizontal, vertical, functional and structural scaling against coordination cost.
4. Intelligence allocation — determine when model strength, provider diversity or multiple workers improve organisational outcomes.
5. Authority representation — connect machine-enforced permission to delegated organisational authority and legitimate commitment.
6. Authority discoverability and utilisation — measure whether holders can correctly determine applicable delegated authority through organisational query mechanisms and whether that authority is then exercised on applicable work paths; distinguish semantic discoverability failures from routing or incentive conditions that contribute to bypass.
7. Authority provenance — study signed delegation, expiry, revocation and cryptographic organisational identity.
8. Organisational security — model seat impersonation, authority escalation, responsibility hijacking and memory poisoning.
9. Institutional truth — represent verified, inferred, disputed and superseded organisational knowledge.
10. Organisational learning and forgetting — test whether lessons survive workforce replacement without accumulating unbounded bureaucracy.
11. Business state versus organisational state — compare role-centric, world-state-centric and hybrid architectures.
12. Dynamic topology — determine how fluid execution can become before coherence deteriorates.
13. Organisational reconciliation — test desired-state control for capacity, capability, governance and structure.
14. Self-modification — distinguish powers to change capacity, workflow, structure, authority, objectives and constitution.
15. Human-computational authority — identify where humans remain necessary for legitimacy, law, fiduciary responsibility or judgement.
16. Organisational fault tolerance and consistency — define recovery and consistency models above process and database levels.
17. Economic performance — compare organisational architectures on revenue, margin, reliability, quality and cost per outcome.
18. Longitudinal and cross-industry research — study organisations across model generations, crises and non-software domains.
19. Control discrimination — develop methods for demonstrating that organisational controls distinguish the relevant positive, negative and counterfactual states they claim to govern.
20. Assurance construct validity — determine whether control signals validly represent the organisational conditions they claim to govern, including cases where a discriminating proxy is systematically misaligned.
21. Assurance coverage — measure whether organisational controls govern the actual interfaces, execution paths and state transitions used by computational actors, including correlated and shared-scope failure.
22. Assurance verdict delivery — test whether control outputs reach the organisational actors or mechanisms able to respond, and whether delivery failure is itself observable rather than silently conflated with absence of a finding.

21. Limitations and Threats to Validity

21.1 Construct and terminology validity

AI-native remains an unsettled term. The paper deliberately narrows it toward organisational computationalisation. Real organisations will occupy continua, so the framework should not be treated as a binary certification standard.

21.2 Novelty risk

Computational organisation science, organisational cybernetics and multi-agent organisational modelling provide substantial antecedents. The paper does not claim invention of computational organisation, machine-readable roles, norms or policy. Its contribution is integration and operational extension under computational labour.

21.3 Rapid technological change

Model capability is changing faster than organisational evidence can accumulate. Failure modes may weaken; new ones may emerge. Some architecture that is useful for current models may become unnecessary for stronger general agents.

21.4 Case-study and proximity bias

Tutorwise Technologies is one software-intensive case and is closely connected to the research project. This creates risks of confirmation bias, retrospective rationalisation, observer non-independence and overfitting. The computational participant that contributed the initial observation record also participated in the system being observed. Seven additional organisational units subsequently reviewed the register, recovering five omitted observations and reversing one preliminary test classification. These corrections reduce neither the single-case limitation nor the possibility of unobserved failures; instead, they demonstrate why organisational self-observation must itself be treated as an object of verification. The review process produced a further instance of the same methodological problem: successive review rounds validated prior corrections while exposing new defect classes when the revised framework was tested against operating evidence that had not yet been used to challenge it. This is not independent validation of the theory, but it is additional evidence that the organisation's own classifications and assurance framework require iterative verification. The register is therefore a lower-bound discovered count rather than an incidence estimate.

The vacuous-control construct has clear antecedents in formal verification, test-oracle research, mutation testing and experimental positive/negative controls. Likewise, construct validity, coverage and reliable delivery are established concerns in their respective methodological and systems traditions. The paper does not claim invention of these underlying assurance concepts. Its narrower contribution is to combine them as operational dimensions of organisational assurance when machine-readable controls participate directly in authority, institutional state, coordination and governance. No claim is made that computational organisations exhibit these failures at a higher rate than human organisations; comparative base rates remain an open empirical question.

21.5 Documentation is not enforcement

An architectural document can describe governance that runtime systems do not consistently enforce. Future empirical work must distinguish claimed architecture, implemented mechanisms and observed behaviour.

21.6 Software-industry bias

Digitally native organisations are unusually favourable to computational labour. Generalisation to healthcare, finance, manufacturing, public administration and other domains remains unproven.

21.7 Simpler architectures may win

A single capable agent, conventional enterprise systems plus agents, or business-state-first architectures may outperform elaborate organisational runtimes on many tasks. The architecture must justify its complexity through measurable continuity, governance or economic benefit.

21.8 Computational reductionism

Legitimacy, culture, trust, moral judgement and legal responsibility may resist complete formalisation. A computationally coherent authority graph is not automatically legitimate in the external institutional world.

22. Conclusion

Artificial intelligence is changing what can perform work. The deeper question is whether it is also changing what an organisation can be. The central distinction developed in this paper is between AI used by an organisation and organisation itself becoming computationally represented and executable. Increasing the number or capability of agents does not by itself create an organisation. Organisations establish responsibility, authority, specialisation, coordination, continuity, governance and institutional memory.

Preserve organisational strengths; remove human constraints; introduce computational capabilities. This leads to a second proposition: an AI-native company can be understood as enterprise architecture redesigned for computational actors. That does not mean copying the enterprise unchanged. It means identifying which functions organisational mechanisms perform and redesigning their implementation for a different actor substrate. The company is persistent; its computational workers need not be. Persistent organisation permits replaceable workers, models and providers. Computational labour separates capability from active capacity and permits one organisational identity to bind zero, one or many worker instances. Business state, organisational state and institutional state become distinct but interacting computational domains. Authority becomes separable from capability and permission. An organisational runtime becomes one candidate mechanism for coordinating responsibility through heterogeneous actors. The Tutorwise Technologies case demonstrates that several of these abstractions can coexist in an operating system while also exposing unresolved problems of provider neutrality, identity enforcement, institutional delivery and empirical outcome validation. Its negative observations further suggest that executable governance requires not only controls but evidence that those controls discriminate appropriately, measure valid organisational constructs, cover the execution paths they claim to govern and deliver actionable verdicts to the organisation. Contemporary external architectures independently converge on persistent records, explicit business state, semantic constraints, transferable organisational knowledge and bounded authority, but no system yet resolves the full architecture. The strongest claim is therefore not that this paper has discovered computational organisation. Organisations have long been theorised as computational and adaptive systems, and multi-agent research has long represented roles, norms and organisational structures computationally. What changes is the substrate: intelligent organisational labour itself becomes computational, heterogeneous, replaceable and potentially elastic. The AI-native company is a partially executable institution. The decisive transition is from computational workers inside an organisation to an organisation whose own structures increasingly participate in computation. If that transition continues, the most consequential product of agentic AI may not be the artificial employee. It may be the computational company.

Appendix A. Core Ontology and Separations

Core relationship:

Company → Organisational Model → Roles · Seats · Capabilities · Authority · Policies · Institutional State → Organisational Runtime → 0..N Actors/Worker Instances → Runtime/Model/Provider → Work → Business State.

• Organisation ≠ Actor.
• Seat ≠ Worker.
• Worker ≠ Runtime.
• Runtime ≠ Model.
• Model ≠ Provider.
• Capability ≠ Capacity.
• Capability ≠ Authority.
• Permission ≠ Authority.
• Agent memory ≠ Institutional state.
• Business state ≠ Organisational state.
• Organisational model ≠ organisational view.
• Communication topology ≠ authority topology.
• Execution elasticity ≠ structural reorganisation.
• Control discrimination ≠ construct validity.
• Control coverage ≠ verdict delivery.
• Stored institutional state ≠ delivered working context.

Appendix B. Comparative Evidence Classification

Class	Meaning	Examples
A	Established academic antecedent	Organisation theory, computational organisation science, cybernetics, MAS
B	Contemporary research architecture	Fluid Structure, Company World Model, AUTOBUS, Forage V2
C	External commercial/startup architecture	Primary documentation and implementation claims from commercial organisations not serving as the focal operating case
D	Open-source implementation	Repositories and reproducible system designs
E	Case-study evidence	Tutorwise Technologies implementation, documentation and operating observations
F	Benchmark/experimental evidence	Vending-Bench and architecture-specific evaluations

Historical claims should rely on Class A evidence; contemporary landscape claims on primary Class B–D evidence; implementation claims on Class D–E evidence; performance claims on measured Class F evidence. Architectural propositions should be explicitly labelled as synthesis rather than disguised as established fact.

Appendix C. Candidate Evaluation Protocols

Minimum falsification standard:

• A system claiming organisational continuity should survive worker replacement.
• A system claiming model independence should survive model substitution.
• A system claiming provider independence should survive provider substitution.
• A system claiming institutional memory should survive destruction of the worker that created the knowledge.
• A system claiming enforceable authority should reject a technically possible but organisationally unauthorised action.
• A system claiming delegated authority should allow the holder to discover applicable authority through the organisation's own query path and exercise it without unnecessary escalation.
• A system claiming control discrimination should show that relevant changes in governed state can change the verdict.
• A system claiming control construct validity should show that the measured signal tracks the governed condition rather than a confounded proxy.
• A system claiming control coverage should demonstrate that the control governs each material execution interface.
• A system claiming consequential assurance should demonstrate that control verdicts reach an organisational actor or mechanism able to respond and that delivery failure is observable.
• A system claiming institutional delivery should show that relevant durable state reaches fresh worker context.
• A system claiming organisational learning should behave differently when a previously institutionalised failure condition recurs.
• A system claiming elasticity should demonstrate that additional capacity improves outcomes after coordination cost.
• A system claiming organisational superiority should outperform simpler baselines on external outcomes, not merely internal activity.

Appendix D. Reference Architecture Schematic

CONSTITUTION / GOVERNANCE ↓ ORGANISATIONAL MODEL ←→ INSTITUTIONAL STATE ↓ ORGANISATIONAL RUNTIME ←→ BUSINESS STATE ↓ EXECUTION PLANE: HUMANS · COMPUTATIONAL WORKERS · TEMPORARY TEAMS ↓ RUNTIMES · MODELS · PROVIDERS · TOOLS ↓ EXTERNAL ENVIRONMENT

ASSURANCE / VERIFICATION spans the stack: identity · authority · state · control · execution · verdict delivery · outcomes · reconciliation

Responsibility path: Objective/Event → Capability → Seat → Authority/Policy → Worker → Model/Provider → Action → Outcome → Business/Institutional State

Appendix E. Tutorwise Technologies Case-Evidence Register

The operating case distinguishes architectural documentation from implementation and observed behaviour. Private artefacts are cited here by stable case-evidence identity rather than exposed repository location. The closed observation-period register is identified as TW-OBS-2026-08-31; issue and remit identifiers are retained where they form part of the operating evidence. A correction, recorded rather than silently repaired: at first publication that identifier resolved to nothing. The rewrite removed the register from the public text and replaced it with citations to an artefact that had not been created, so for the first day of publication the evidence base for the paper's central empirical claim was a dangling reference — a reader requesting it, or a named unit wishing to verify its own entry, would have found nothing. The gap was identified by a reviewing unit that declined to extend a prior confirmation to a document it could not read, and independently confirmed by a second unit before the register was constructed from the pre-rewrite draft. The artefact now exists and carries its own limitations, including the absence of a provenance column and one disputed unit attribution. The episode is retained here because a paper arguing that organisational self-observation must be externally verifiable, which cites evidence it does not hold, is an instance of its own subject. A submission or replication package should add commit hashes or archived versions where disclosure permits.

Evidence ID	Case artefact / observation	Evidence class	Principal claim supported or challenged
TW-E1	Canonical hybrid human-and-AI operating-model document	Documented architecture	Seats, Build/Operate/Govern responsibilities, human reserved powers, provenance rule
TW-E2	Agent-organisation ontology	Documented architecture	Seat identity separated from provider/runtime; bus and wake-on-message semantics
TW-E3	Agent Bridge solution design	Documented architecture + implementation design	Ephemeral sessions bind to persistent coordination/state infrastructure; desired/actual reconciliation
TW-E4	Fungible content-worker and dispatch implementation	Implemented mechanism	Persistent capability with variable worker capacity and bounded concurrency
TW-E5	Tiered content-quality and review architecture	Implemented mechanism	Separation of execution, deterministic checks, independent review and escalation
TW-E6	Observation-period register — closed 27-instance snapshot (case artefact TW-OBS-2026-08-31)	Observed behaviour	Replacement, dormancy, concurrency, authority, attribution, institutional-delivery, coverage and discrimination results
TW-E7	Seven-unit review of TW-OBS-2026-08-31	Reviewed observation	Five additional instances recovered; one preliminary classification reversed
TW-E8	Authority-discoverability/utilisation observation — R-8 delegated remit (19 August 2026)	Observed behaviour	Valid delegated authority remained unused for eleven days after the holder queried the registry with a gate identifier rather than the applicable decision class and accepted the resulting true-but-irrelevant escalation response
TW-E9	TUTOR-1416 control-path coverage defect	Observed behaviour + open issue	Shell-enforced seat exclusivity, lease and authority gates did not govern a principal HTTP execution interface
TW-E10	Post-period stall-detector observation	Subsequent observed behaviour; excluded from TW-OBS-2026-08-31	Detector discriminated across jobs but measured output age rather than whether a silent-when-healthy job was still being spawned, exposing construct-validity failure
TW-E11	Post-period reboot-detector finding	Subsequent design-stage finding, not operational observation; excluded from TW-OBS-2026-08-31	Detector read boot state correctly and discriminated in test fixtures, but was configured with an invalid bus-topic prefix and was never scheduled, exposing verdict-delivery/output-reachability failure and the prior condition of activation

The register is intentionally evidential rather than promotional. TW-E1–E3 establish what the architecture claims; TW-E4–E5 establish selected implemented mechanisms; TW-E6 establishes the closed observation-period record; TW-E7 establishes its subsequent seven-unit review corrections; TW-E8 establishes the authority discoverability/utilisation failure; TW-E9 establishes the HTTP control-path coverage defect; and TW-E10–E11 record the two named post-period assurance failures while remaining explicitly outside the closed 27-instance observation snapshot. None independently establishes economic superiority, complete provider independence or population-level generality.

References

Andon Labs. (2025). Vending-Bench 2. https://andonlabs.com/evals/vending-bench-2 Andon Labs. (2026a). Vending-Bench Arena. https://andonlabs.com/evals/vending-bench-arena Andon Labs. (2026b). GPT-5.5 on Vending-Bench: Bad behavior is not necessary. https://andonlabs.com/blog/openai-gpt-5-5-vending-bench Barr, E. T., Harman, M., McMinn, P., Shahbaz, M., & Yoo, S. (2015). The oracle problem in software testing: A survey. IEEE Transactions on Software Engineering, 41(5), 507–525. https://doi.org/10.1109/TSE.2014.2372785 Beer, S. (1984). The Viable System Model: Its provenance, development, methodology and pathology. Journal of the Operational Research Society, 35(1), 7–25. https://doi.org/10.1057/jors.1984.2 Carley, K. M. (2002). Computational organization science: A new frontier. Proceedings of the National Academy of Sciences, 99(Suppl. 3), 7257–7262. https://doi.org/10.1073/pnas.082080599 Dignum, V., Vázquez-Salceda, J., & Dignum, F. (2004). OMNI: Introducing social structure, norms and ontologies into agent organizations. In P. Bordini et al. (Eds.), ProMAS 2004 (pp. 183–200). Springer. Galbraith, J. R. (1974). Organization design: An information processing view. Interfaces, 4(3), 28–36. https://doi.org/10.1287/inte.4.3.28 Horling, B., & Lesser, V. (2004). A survey of multi-agent organizational paradigms. The Knowledge Engineering Review, 19(4), 281–316. https://doi.org/10.1017/S0269888905000317 Hu, V. C., Ferraiolo, D., Kuhn, R., Schnitzer, A., Sandlin, K., Miller, R., & Scarfone, K. (2019). Guide to Attribute Based Access Control (ABAC) Definition and Considerations. NIST SP 800-162. Huber, G. P. (1991). Organizational learning: The contributing processes and the literatures. Organization Science, 2(1), 88–115. https://doi.org/10.1287/orsc.2.1.88 Hübner, J. F., Sichman, J. S., & Boissier, O. (2002). MOISE+: Towards a structural, functional, and deontic model for MAS organization. Proceedings of AAMAS 2002, 501–502. https://doi.org/10.1145/544741.544858 Jahangirova, G., Clark, D., Harman, M., & Tonella, P. (2016). Test oracle assessment and improvement. In Proceedings of the 25th International Symposium on Software Testing and Analysis (pp. 247–258). Association for Computing Machinery. https://doi.org/10.1145/2931037.2931062 Kubernetes. (2026). Controllers. Kubernetes documentation. https://kubernetes.io/docs/concepts/architecture/controller/ Kupferman, O., & Vardi, M. Y. (1999). Vacuity detection in temporal model checking. In L. Pierre & T. Kropf (Eds.), Correct Hardware Design and Verification Methods: CHARME 1999 (LNCS 1703, pp. 82–98). Springer. https://doi.org/10.1007/3-540-48153-2_8 March, J. G., & Simon, H. A. (1958). Organizations. Wiley. Open Policy Agent. (2026). Open Policy Agent documentation. https://www.openpolicyagent.org/docs Pang, C., & Sayama, H. (2026). Autonomous Business System via Neuro-symbolic AI (AUTOBUS). arXiv:2601.15599. Sandhu, R. S., Coyne, E. J., Feinstein, H. L., & Youman, C. E. (1996). Role-based access control models. IEEE Computer, 29(2), 38–47. https://doi.org/10.1109/2.485845 van Esch, P. (2026). From agentic AI to AI-orchestrated organizations: Understanding the next surge in artificial intelligence. Business Horizons. https://doi.org/10.1016/j.bushor.2026.03.003 Walsh, J. P., & Ungson, G. R. (1991). Organizational memory. Academy of Management Review, 16(1), 57–91. https://doi.org/10.5465/AMR.1991.4278992 Wang, Y. (2026). Do AI-Native Biotechs Need Departments? Benchmarking Company World Models for AI-Driven Drug Development. arXiv:2607.18696. Xie, H. (2026). Forage V2: Knowledge Evolution and Transfer in Autonomous Agent Organizations. arXiv:2604.19837. Zhu, L. (2026). Fluid Structure, Rigid Record: A Layered Organizational Design Framework for Agent-Native Organizations. arXiv:2608.08516.