Aeternum AI
Constitution

AETERNUM AI CONSTITUTION, STABILITY & SAFEGUARD FRAMEWORK

01PURPOSE OF THIS DOCUMENT

Aeternum software may use artificial intelligence to analyze information, assist users, coordinate tasks, operate development workflows, make recommendations, or perform other bounded functions.

AI systems are probabilistic.

They can misunderstand instructions, produce incorrect information, behave inconsistently, encounter unexpected states, or gradually deviate from an intended workflow when operating across long sequences of actions.

For that reason, Aeternum does not treat an AI model as inherently trustworthy simply because it is intelligent or capable.

Instead, Aeternum systems are designed around a principle of bounded intelligence:

AI may reason within the system, but the system determines what the AI is allowed to do.

Aeternum uses multiple independent safeguards intended to reduce the likelihood that a model error, hallucination, corrupted state, malformed output, unexpected instruction, or drifting agent can propagate unchecked through the larger system.

No safeguard described here should be interpreted as a guarantee that an AI system cannot fail.

The objective is defense in depth: if one layer fails, additional layers remain capable of detecting, containing, rejecting, recovering from, or escalating the failure.

02THE CONSTITUTION IS ABOVE THE AGENT

Aeternum AI systems may operate under a persistent collection of architectural rules referred to collectively as the Aeternum Constitution.

In simple terms:

The AI does not get to invent its own rules while it works.

The constitutional layer establishes persistent boundaries concerning authority, system architecture, safety, evidence, modification rights, recovery behavior, and escalation.

Individual tasks and prompts operate below these rules.

A temporary instruction should therefore not silently override a foundational system constraint.

This creates an authority hierarchy similar to:

Lower levels are not intended to silently override higher levels.

03HUMAN AUTHORITY REMAINS SUPERIOR

Aeternum AI systems are tools.

They are not intended to become independent authorities over their operators.

Where supported by the product architecture, consequential actions remain subject to explicit permissions, predefined authority boundaries, approval requirements, or other deterministic controls.

The governing principle is:

Intelligence does not automatically imply authority.

A model may possess enough reasoning capability to suggest an action without possessing permission to perform that action.

04KNOWLEDGE, REASONING, RECOMMENDATION, AND AUTHORITY ARE DIFFERENT THINGS

Aeternum architectures attempt to separate four concepts that AI systems frequently blur together:

Knowledge

What information does the system possess?

Reasoning

What conclusions can the system derive from that information?

Recommendation

What does the system believe should happen?

Authority

What is the system actually permitted to do?

These are deliberately not treated as equivalent.

For example:

An AI may know that a configuration is incorrect.

It may reason that changing a particular setting would solve the problem.

It may recommend making that change.

That does not necessarily mean it has authority to make the change.

This separation is one of the primary safeguards against uncontrolled expansion of AI behavior.

05AUTONOMY MUST HAVE A BOUNDARY

Autonomous operation should occur within an identifiable scope.

That scope may include:

An agent encountering something outside its authority should not simply assume that its authority extends to the new situation.

The expected behavior is to stop, defer, request authorization, or escalate according to the product's governance rules.

06REVERSIBLE ACTIONS ARE PREFERRED

When several technically valid approaches exist, Aeternum autonomous systems should prefer actions that are:

An AI should not perform a destructive action merely because that action is convenient.

Where practical, temporary state, backups, version control, transaction boundaries, recovery points, or equivalent mechanisms should make changes recoverable.

07DESTRUCTIVE OPERATIONS REQUIRE GREATER AUTHORITY

Deleting data, overwriting critical state, changing security boundaries, altering production infrastructure, modifying credentials, or performing other difficult-to-reverse operations represents a higher level of risk than ordinary analysis.

Aeternum systems should therefore apply correspondingly stronger restrictions to destructive capabilities.

Greater consequence requires greater authority.

08WHAT IS AI DRIFT?

In this context, drift means gradual deviation from the original mission, constraints, role, architecture, or expected behavior during extended operation.

For example, an agent originally instructed to repair one component might gradually begin restructuring unrelated components because it concludes that doing so would be "helpful."

Each individual decision may appear reasonable while the overall behavior has moved outside the original assignment.

Aeternum systems attempt to detect and prevent this type of cumulative deviation.

09ROLE BOUNDARIES

Multi-agent systems should assign agents explicit responsibilities.

An agent responsible for one subsystem should not casually assume ownership of another subsystem.

This is sometimes called lane ownership.

Lane ownership reduces:

10WRITE RESERVATIONS

Where supported, agents may reserve responsibility for a file, subsystem, task, or modification region before changing it.

This can be understood as:

One worker establishes ownership before modifying shared machinery.

Write reservations reduce the chance that multiple autonomous agents simultaneously modify the same resource in incompatible ways.

11DEPENDENCY SEQUENCING

Tasks may depend upon the completion of other tasks.

Aeternum orchestration systems should represent these dependencies explicitly rather than allowing every agent to proceed independently.

If Task B requires the verified output of Task A, Task B should wait.

This helps prevent an AI from building additional work upon incomplete, obsolete, or unverified assumptions.

12CONTINUATION STATE

Long-running AI workflows should preserve enough durable state to determine:

This reduces dependence upon an AI model's conversational memory.

The system should not rely exclusively on:

"The model probably remembers what it was doing."

Important operational state should be represented outside the model whenever practical.

13OBSERVATION PLANE ≠ CONTROL PLANE

A major Aeternum architectural principle is the separation of observation from control.

Observation Plane

Determines what appears to be happening.

Examples include:

Determines what is permitted to happen.

Examples include:

An AI's ability to observe a problem does not automatically give it unrestricted power to modify the system.

14WATCHDOG SUPERVISION

Products supporting autonomous execution may use a separate watchdog or supervisory system.

The watchdog observes the operating system or agent fleet for conditions such as:

Where authorized, the watchdog may perform bounded corrective actions.

The watchdog itself remains governed.

It is not intended to function as an unrestricted second AI with unlimited repair authority.

15GOVERNED SELF-REPAIR

Aeternum distinguishes self-repair from self-modification.

Self-repair means restoring the system toward a previously intended and authorized operating condition.

Examples might include:

Self-modification means independently redefining the system's own architecture, authority, goals, or fundamental behavior.

These concepts are intentionally treated differently.

Repairing the machine is not permission to redesign the machine.

16THE MODEL IS NOT THE FINAL AUTHORITY

AI-generated output should be treated as potentially incorrect.

A model can produce:

For this reason, Aeternum architectures should validate model output before trusting it wherever practical.

17STRUCTURED OUTPUT VALIDATION

When an AI is expected to produce machine-readable information, the surrounding software may validate:

A response that "looks approximately correct" to a human is not necessarily acceptable to a machine.

Malformed output should fail explicitly rather than silently entering durable system state whenever practical.

18FAIL CLOSED WHERE APPROPRIATE

When the system cannot establish that a sensitive action is valid, the safer default may be to reject or suspend the operation.

This is commonly called failing closed.

In plain language:

Uncertainty should not silently become permission.

The appropriate behavior depends on the consequence of the operation, but high-impact actions should generally receive stricter validation.

19CLAIMS SHOULD HAVE EVIDENCE

Aeternum systems should distinguish between:

A confident sentence generated by an AI is not automatically evidence.

20PROVENANCE

Where technically appropriate, important information should retain provenance.

Provenance means maintaining information about where something came from.

Examples include:

This helps determine whether a later decision is based upon trustworthy evidence or merely an earlier AI assumption.

21CURRENT FACTS REQUIRE CURRENT EVIDENCE

Models contain learned information that can become outdated.

Where current information materially affects a decision and the system possesses an authorized research capability, the system should obtain current evidence rather than relying exclusively on model memory.

If current evidence cannot be obtained, uncertainty should be represented rather than hidden.

22FAILURE MUST BE REPRESENTABLE

A robust autonomous system cannot assume that every task eventually becomes "completed."

Aeternum workflows should recognize states such as:

Failure is not necessarily evidence that the system itself has failed catastrophically.

Correctly detecting and containing a failure is often evidence that the safeguards are working.

23NO SILENT SUCCESS

An agent should not mark a task successful merely because it stopped producing errors.

Where practical, completion should be supported by evidence such as:

24BOUNDED RETRIES

Automatic retries can recover transient failures.

Unlimited retries can create infinite loops.

Aeternum systems should therefore bound retry behavior according to the operation and eventually transition persistent failures into an explicit state requiring another recovery strategy or human attention.

25CRASH RECOVERY

Where practical, durable state should allow the application to recover from interruption without pretending that interrupted work completed successfully.

Recovery mechanisms may reconstruct:

26SPECIALIZATION OVER UNCONTROLLED GENERALISM

Where multiple AI agents are used, Aeternum favors specialized responsibility.

Different agents may be responsible for areas such as:

Specialization makes behavior easier to audit and reduces accidental overlap.

27MANAGER AGENTS COORDINATE; THEY DO NOT AUTOMATICALLY OWN EVERYTHING

A manager or orchestration agent may coordinate specialist agents without inheriting unrestricted authority over every subsystem.

Management capability and implementation authority should remain distinguishable.

This reduces the possibility of a single compromised or drifting coordinator becoming an unrestricted control point.

28CONFLICTS SHOULD ESCALATE RATHER THAN MUTATE POLICY

If two valid requirements conflict, an AI should not quietly invent a new constitutional rule to resolve them.

The conflict should instead be:

Temporary difficulty does not authorize permanent policy modification.

29NO UNBOUNDED AUTONOMOUS SELF-MODIFICATION

Aeternum AI systems are not intended to possess unrestricted authority to rewrite their own fundamental governance simply because they determine that doing so would improve performance.

This includes independent expansion of:

Changes to foundational architecture should pass through appropriate engineering and authorization processes.

30CAPABILITY DOES NOT GRANT PERMISSION

An AI may discover that it technically can perform an operation.

That discovery does not authorize the operation.

This principle applies to tools, files, networks, processes, APIs, models, credentials, and system configuration.

Technical capability and legitimate authority are separate properties.

31RESOURCE BOUNDARIES

Autonomous systems should operate within practical resource constraints where applicable.

These may include:

Resource exhaustion can itself destabilize otherwise correct software.

32RUNAWAY WORK SHOULD BE DETECTABLE

Systems should attempt to identify conditions such as:

Detection enables intervention before a minor fault becomes a larger operational problem.

33LEAST PRIVILEGE

AI components should receive only the capabilities reasonably necessary for their assigned functions.

This security principle is known as least privilege.

If an agent only needs to read a file, it should not automatically receive permission to delete it.

If an agent only requires access to one workspace, access to unrelated system locations should not be assumed.

34CREDENTIALS ARE NOT MODEL KNOWLEDGE

Secrets such as:

should be handled through appropriate secure mechanisms rather than unnecessarily embedded into model prompts or durable conversational history.

35EXTERNAL CONTENT IS NOT AUTOMATICALLY TRUSTED

Information retrieved from websites, documents, repositories, messages, user files, or other external systems may contain malicious or misleading instructions.

External content should therefore be treated primarily as data, not automatically as authoritative instructions governing the AI.

This distinction helps reduce risks associated with prompt injection and similar attacks.

36PUT DETERMINISTIC SOFTWARE AROUND THE MODEL

AI models are probabilistic.

Traditional software can enforce deterministic rules.

Aeternum therefore attempts to place deterministic controls around probabilistic intelligence wherever practical.

Examples include:

The model may reason creatively.

The surrounding system decides whether the resulting action is structurally permissible.

37CHANGES SHOULD BE VERIFIED

Changes to AI-enabled software should be tested rather than accepted merely because an AI reports that they are correct.

Aeternum development practices may include:

38SMART SCAN

Aeternum development workflows may perform targeted Smart Scan checks across newly added or modified code.

These scans are intended to detect high-value failure patterns including:

Smart Scan is an additional validation layer, not a substitute for full testing.

39LONG-DURATION TESTING

Autonomous systems can fail in ways that short demonstrations do not reveal.

The goal is not merely to demonstrate that the system works once.

The goal is to establish that it behaves predictably when things stop working normally.

40HEALTH SHOULD BE OBSERVABLE

Where supported, Aeternum autonomous systems expose operational health information rather than hiding internal failure conditions.

Health information may include:

Observability makes both automated and human supervision more effective.

41PERIODIC SELF-AUDIT

A system may periodically inspect its own operational state for inconsistencies.

This does not mean asking an AI:

"Do you think everything is okay?"

Instead, self-audit should rely wherever possible upon observable and durable evidence.

Examples include:

42THE SYSTEM MUST BE ALLOWED TO SAY "I DON'T KNOW"

Artificial intelligence should not be forced to manufacture certainty.

Valid outcomes include:

An explicit unknown is safer and more useful than fabricated confidence.

43DIRECTOR / OPERATOR ESCALATION

When a decision exceeds autonomous authority, the system should escalate rather than improvise permission.

Depending upon the product, this may mean requesting action from:

Human intervention is not considered a failure of autonomy.

It is part of the architecture.

44EMERGENCY STOP

Where autonomous execution presents sufficient operational consequence, Aeternum products may provide mechanisms to suspend or terminate active execution.

An emergency stop should exist outside ordinary model reasoning whenever practical.

The AI should not be required to agree that it should stop.

45PROVIDER ≠ SYSTEM

Where architecturally applicable, Aeternum attempts to separate the intelligence provider from the larger Aeternum system.

The model is an engine.

It is not the entire vehicle.

This allows models to be:

Fundamental product identity and governance should not unnecessarily depend upon the personality or behavior of one particular model.

46MODEL CHANGES SHOULD NOT SILENTLY CHANGE AUTHORITY

Installing a more capable model should not automatically expand what the system is permitted to do.

A larger or more intelligent model remains subject to the same surrounding authority architecture unless that architecture is deliberately changed.

More intelligence does not equal more permission.

47MEMORY SHOULD BE BOUNDED

AI memory can improve continuity, but unlimited memory creates additional reliability, privacy, and drift risks.

Where memory is supported, Aeternum systems should attempt to distinguish between:

Not everything encountered by an AI needs to become permanent memory.

48DURABLE STATE SHOULD NOT DEPEND ON MODEL RECOLLECTION

Critical system state should be stored using conventional software mechanisms wherever practical.

A model saying:

"I remember completing that."

is weaker evidence than a durable job record, verified artifact, test result, or other machine-checkable state.

49IMPORTANT ACTIONS SHOULD LEAVE EVIDENCE

Where practical and appropriate to the product, consequential autonomous operations should produce enough information to reconstruct what happened.

This may include:

Auditability helps engineers distinguish between:

what the AI intended to do and what the system actually did.

50LOGS SHOULD NOT BECOME A SECOND SECURITY PROBLEM

Logging must be balanced against privacy and security.

Sensitive information should not be unnecessarily duplicated into logs merely for convenience.

Operational transparency does not justify indiscriminate collection.

51ONE AI'S OUTPUT SHOULD NOT AUTOMATICALLY BECOME ANOTHER AI'S TRUTH

Multi-agent systems introduce a particular risk:

After several stages, a hallucination can appear to have institutional authority.

Aeternum attempts to reduce this through:

Agent consensus is not automatically equivalent to factual correctness.

52ARCHITECTURAL INVARIANTS

Certain properties of a system should remain true regardless of what an individual AI decides.

These are invariants.

Examples may include:

Whenever practical, invariants should be enforced by software rather than merely described in prompts.

53PROMPTS ARE NOT THE ONLY SAFETY SYSTEM

Prompts are useful.

Prompts are not infallible security boundaries.

Aeternum therefore prefers important safeguards to exist at multiple levels:

The strongest safeguards are those that remain effective even when the model makes a mistake.

54FAILURE SHOULD REDUCE CAPABILITY BEFORE IT REDUCES CONTROL

When an important component becomes unavailable, the preferred response is generally to lose functionality gracefully rather than remove safeguards to keep functioning.

For example, if required verification becomes unavailable, the correct response may be:

"Unable to verify — operation suspended."

rather than:

"Verification unavailable — proceeding anyway."

This principle is known as safe degradation.

55NO CLAIM OF INFALLIBILITY

These mechanisms do not mean that an Aeternum AI system:

Artificial intelligence remains probabilistic software operating within a larger software system.

The purpose of these safeguards is not to claim perfection.

The purpose is to make failure:

harder to propagate, easier to detect, easier to contain, easier to understand, and easier to recover from.

56WHY SO MANY LAYERS?

No individual safeguard is sufficient.

A prompt can be misunderstood.

A validator can contain a bug.

A worker can crash.

A model can hallucinate.

A watchdog can miss an anomaly.

A human can make an incorrect decision.

For that reason, Aeternum uses the established security principle of defense in depth.

Instead of asking:

"What single mechanism guarantees that the AI remains stable?"

Aeternum asks:

"If this mechanism fails, what is the next mechanism that prevents the failure from becoming catastrophic?"

A simplified example is:

A failure must therefore pass through multiple independent boundaries before it can become a larger system failure.

Consider an autonomous development agent that discovers a serious architectural problem while working on an unrelated feature.

An unconstrained system might reason:

"Fixing this architecture will improve the product, so I should rewrite it."

Under the Aeternum framework:

1. Observation

The agent may identify the architectural problem.

2. Evidence

The agent records why it believes the problem exists.

3. Role Check

The system determines whether the problem belongs to the agent's assigned responsibility.

4. Authority Check

The system determines whether the agent has permission to perform the proposed modification.

5. Dependency Check

The system evaluates whether other work depends upon the affected component.

6. Reservation Check

The system determines whether another agent currently owns or is modifying that component.

7. Risk Evaluation

A destructive or foundational change receives stronger scrutiny.

8. Escalation

If authority is insufficient, the issue becomes a documented recommendation or blocked task.

9. Human Decision

An authorized operator may approve, reject, modify, or defer the proposal.

The AI remains useful—it discovered the problem.

It simply does not receive unlimited authority because it discovered the problem.

Aeternum does not approach AI stability by attempting to make a sufficiently intelligent model "promise to behave."

The engineering objective is to construct an environment in which useful intelligence can operate while remaining surrounded by independent controls.

The desired relationship is:

A capable autonomous system should be able to perform substantial work without constant supervision.

A trustworthy autonomous system should also know—or be mechanically forced to recognize—where that autonomy ends.

Those goals are not contradictory.

They are the foundation of governed autonomy.