Objectspace is a persistent semantic computing environment in which durable state is represented as typed, identity-stable objects and explicit relationships rather than pathname-addressed files arranged in directory trees.
Files and folders may exist as compatibility projections, import/export formats, or human-facing views. They are never canonical state.
Objectspace is designed for a future in which software agents are primary operators of computers and major creators of software. The system must therefore optimize for machine comprehension, deterministic verification, explicit semantics, transactional modification, and extremely small blast radii.
Objects have stable identity independent of:
- names;
- views;
- presentation;
- storage location;
- organization.
Renaming or reorganizing an object must not break references to it.
System structure is represented through explicit typed relationships such as:
depends-on
implements
tested-by
owned-by
derived-from
configured-by
produces
consumes
governed-by
Containment is only one possible relationship.
The canonical entity is a typed object.
Text, JSON, source code, images, PDFs, and other formats are representations of objects, not necessarily their fundamental identity.
Conceptual objects have stable ObjectIds.
Every state of an object has an immutable RevisionId.
Changes create new revisions.
Committed history is never silently overwritten.
A WorldRevision represents one internally consistent logical state of Objectspace.
Changes occur in candidate transactions or derived worlds.
Only verified changes become committed worlds.
Failed work must not partially alter committed state.
Applications and agents receive only explicitly granted capabilities.
Authority is deny-by-default.
An application that has not been granted access to a resource must be unable to access it.
Objectspace should reason about what an object is, not merely how its bytes happen to be encoded.
Serialization is an interchange or compatibility boundary.
Critical architectural rules must be executable.
If a dependency is forbidden, CI must reject it.
If an invariant matters, verification must check it.
Documentation alone is insufficient.
A well-designed change should require understanding the smallest possible semantic closure.
The system should continuously reduce Agent Comprehension Cost:
the amount of context an autonomous agent must inspect or infer before safely making a change.
Safety and velocity are not opposing goals.
Clear architecture, reusable primitives, explicit contracts, immutable history, strong typing, and deterministic verification should enable faster autonomous iteration.
Novelty belongs in the Objectspace machine model.
Prefer mature infrastructure for:
- hardware support;
- operating-system substrate;
- storage;
- compilation;
- WebAssembly;
- cryptography;
- networking;
- testing.
Do not reinvent infrastructure merely to make Objectspace appear more novel.
The semantic kernel should remain minimal.
Complexity should live outside the trusted core whenever possible.
For agentically engineered code:
- explicit is better than magical;
- shallow is better than deeply abstract;
- typed is better than stringly typed;
- one obvious path is better than several equivalent patterns;
- small modules are better than sprawling frameworks;
- deletion is better than unnecessary generalization.
Objectspace may project objects into:
files
directories
POSIX paths
JSON
source trees
legacy APIs
Compatibility layers may depend on Objectspace.
Objectspace core must never depend on compatibility projections.
Dangerous changes must be:
- transactional;
- isolated;
- inspectable;
- verifiable;
- abortable;
- reversible.
Speculative agent work should be cheap.
The agent that implements a change is not sufficient evidence that the change is correct.
Important work should be checked through some combination of:
- compiler enforcement;
- independent tests;
- property testing;
- fuzzing;
- mutation testing;
- adversarial review;
- model checking;
- selective formal verification.
The bootstrap implementation will begin inside a conventional filesystem.
That is temporary scaffolding.
The long-term objective is for Objectspace itself to be developed through Objectspace-native primitives such as:
object.query
graph.impact
world.fork
transaction.diff
program.verify
As more of the system becomes native, autonomous engineering should become faster and safer.
The following must always hold:
- Object identity is stable.
- Revisions are immutable.
- Every committed world is internally consistent.
- Failed transactions cannot mutate committed state.
- Persistent relationships resolve to valid identities or explicit tombstones.
- Capabilities are deny-by-default.
- Authority cannot silently expand.
- Every committed change has provenance.
- Compatibility projections are never canonical state.
- Core dependency rules are machine-enforced.
- Canonical identity never depends on a pathname.
- Any committed world can be rolled back without application-specific reconstruction.
Every architectural decision should be evaluated partly by:
How much context must an autonomous agent reconstruct before it can make a correct change?
Objectspace should prefer architectures that expose the relevant semantic closure directly.
The system succeeds when agents spend progressively less effort understanding machinery and progressively more effort solving the actual problem.
Objectspace is not a better filesystem.
It is a different computing model.
Unix made everything look like a file.
Objectspace should make everything exist as what it actually is.