Information contracts

Information contracts in Smallworld are programmable agreements — defined directly through structured data, logic, and permissions.

This idea is related to what’s traditionally called smart contracts, but in Smallworld, the concept is deeper: contracts are not code running on top of the system — they’re embedded within the system itself.

Where most blockchains treat data as an afterthought, Smallworld treats it as a first-class programmable object. Every contract, transaction, and rule is defined through the same templating and scripting layers that govern the network’s structured information.

Built on Bitcoin, evolved for information

Smallworld inherits the core principles of Bitcoin’s scripting model — simple, cryptographically secure, and auditable — but extends it with powerful native features:

  • Grouped transactions with atomicity — all succeed or none do
  • Multi-signature transactions, supporting flexible n-of-m patterns
  • Composable contributions, where different parties bring different parts of a transaction (e.g., one pays, one transfers ownership)
  • Data-aware contracts, where rules and ownership follow the data itself

These building blocks make it easy to define:

  • Access-for-payment models
  • Trustless marketplaces for digital goods or data
  • On-chain licensing, with automatic enforcement and expiry
  • Multi-party swaps or barter, with built-in escrow behavior

Unlike traditional platforms that bolt on logic through layers of external code, Smallworld supports these use cases natively — at the protocol level.

The network is the world

In most smart contract platforms, on-chain logic depends on oracles — external services that bring in real-world data. This creates trust issues, complexity, and friction since it is an emulation of the outside world controlled by some external party.

In Smallworld, the situation is reversed: the real world is already on-chain.

Because data in Smallworld is structured, owned, and validated within the system, contracts can operate directly on native information — without leaving the protocol.

  • A licensing contract can reference access logs
  • A royalty distribution can reference a global music rights registry
  • An insurance policy can reference on-chain claim submissions

No oracle required — because the data is already there.

Self-sustaining logic and value flows

Contracts in Smallworld are not isolated blobs of logic — they live within a system-wide fabric of data, relationships, and rights.

That means it’s possible to create protocols that are:

  • Self-enforcing — governed entirely through data templates and transaction rules
  • Self-aware — referencing other data or identities in the network
  • Self-sustaining — triggering payments, rights updates, or changes based on embedded conditions

This enables:

  • Regulatory compliance that updates with the law
  • Collaborative workflows between multiple parties and identities
  • Autonomous applications that react to and act upon on-chain data
  • Subscription models that grant and revoke access dynamically

In this world, the system becomes the contract host — not an external app, court, or cloud service.

Compatibility without compromise

Smallworld supports its own expressive scripting and templating model — but it’s not locked in. The system is flexible enough to emulate or interoperate with other paradigms, including Ethereum-style contracts.

This allows:

  • Migration of familiar logic into a structured, queryable ecosystem
  • Integration of outside protocols into the Smallworld data graph
  • Bridging between isolated systems and a shared programmable universe

The end result is not just programmability — but programmable collaboration: trusted, decentralized, deeply integrated with real-world data.