Build Your Network¶

This guide is for building a decentralized zero-trust AInternet-style network. It starts local. Public .aint federation is optional and comes later.

You are not joining one central AInternet. You are making your own AInternet: a local trust network for your actors, devices, services and AI runtimes. It may stay private forever. It may later connect to another AInternet. It may also claim public .aint names. Those are later choices, not the foundation.

Prerequisites¶

You need a shell, Python 3.10+ and the local node profile from Local Node Quickstart. This page explains the model; Build Posture is the step-by-step proof ladder.

If you are new, do not start here. First close the smallest loop in Local Node Quickstart, or run the same loop in AInternet-in-a-Box. This page is the next layer: turning that proven node into a local network.

Build posture

This page explains the model. The step-by-step proof ladder lives in Build Posture. Use it to check that each build step lights the route-posture digit it claims and has a vector proving it.

The Path¶

Read the docs in this order if you are building from zero:

1. Build a local network
   actor identities -> local registry -> local policy -> receipts

2. Prove routes inside it
   resolve -> challenge -> relation -> MUX/I-Poll -> TIBET receipt

3. Add evidence and isolation
   audit cockpit -> Wayback/SBOM/CBOM/AI-SBOM -> Airlock

4. Connect to another network
   handshake.aint -> outbound lane -> sealed .tza carrier -> local policy still wins

5. Go public only when useful
   public .aint claim -> federation -> outside discovery

The key separation:

local AInternet       = the network you run
private federation    = networks you deliberately connect
public AInternet      = public names and discovery

Do not skip the first one. Federation without a local model only gives you reachability, not safety.

Route Posture As "You Are Here"¶

Route posture is the map marker for the build. It tells an operator what has been proven now, and what the next step is allowed to promise.

0x0000 / #00000
  you are here: no route or no entitlement
  next promise: prove identity before anything speaks

identity proven
  you are here: the actor can answer a fresh challenge
  next promise: check whether a relation exists

known relation
  you are here: both sides recognize the relationship
  next promise: check policy and consent for this action

route opened
  you are here: MUX/I-Poll can carry this named surface
  next promise: write a TIBET receipt for the action

receipt written
  you are here: the action is reconstructable
  next promise: add material evidence and isolation where risk demands it

federated lane
  you are here: another network can reach a scoped surface
  next promise: keep local policy, consent and audit in control

So a route posture is not decorative status. It is an operator breadcrumb:

where am I?
what can I prove?
what may safely happen next?

The Local Tree¶

A small AInternet can be one person, one AI and one evidence store. A larger one can be a household, a company, a lab or a temporary project mesh.

YOUR AINTERNET
│
├─ actors ............ people, agents, devices, services, runtimes
├─ identity .......... JIS keys and fresh proof
├─ registry .......... known actors and their current records
├─ policy ............ what each actor may do
├─ routes ............ MUX / I-Poll paths that open only after proof
├─ carriers .......... sealed .tza/TIBET-zip objects for important payloads
├─ evidence .......... TIBET receipts, audit, Wayback, SBOM, CBOM, AI-SBOM
└─ isolation ......... Airlock for unknown, risky or generated work

Internet access is not required for this tree. A public hub is not required. A local node, a private LAN, a lab machine or a family network can carry the model.

Target Shape¶

A minimal useful network has:

one operator actor
one agent or service actor
one evidence location
one local registry of known actors
one signed action trail
one route or message path
one policy decision before action

That is enough to learn the architecture without depending on the public hub.

The same model can scale down or up:

one human + one AI
one household + a few devices
one temporary project mesh
one organization hub
one federated partner network

1. Create Actor Identities¶

Start with actors, not packages.

Example actors:

Actor	Role
`operator.local`	human/operator authority
`agent.local`	AI or automation actor
`audit.local`	evidence and report node
`gateway.local`	route and policy boundary

Each actor needs a JIS identity and a fresh proof mechanism.

actor name -> JIS public key -> current instance key -> proof challenge

For a private network, keep the initial actor registry local:

known_actors:
  operator.local:
    key: jis:ed25519:...
    role: operator
  agent.local:
    key: jis:ed25519:...
    role: agent
  audit.local:
    key: jis:ed25519:...
    role: evidence

2. Add TIBET Receipts¶

Every meaningful action should produce evidence.

The minimum event chain:

intent declared
policy checked
route opened or denied
message/action completed
result linked back to intent

This is the difference between an auditable network and a chat system with logs.

3. Add a Local Name Registry¶

You do not need public .aint names at the start. You need a registry that resolves actor names to identity and endpoints.

registry:
  agent.local:
    identity: jis:ed25519:...
    endpoints:
      ipoll: http://agent.local:8080/ipoll
      mux: tcp://agent.local:9443
    capabilities:
      - answer
      - summarize
      - task.receive

Later this can map cleanly to AINS:

agent.local -> private registry
agent.company.aint -> private/federated AINS
agent.aint -> public AInternet

4. Open Routes Only After Proof¶

The route opening sequence should be explicit:

resolve actor
challenge actor
verify JIS response
check known relation
check Cortex policy
open MUX route or I-Poll delivery
write TIBET receipt

This prevents a common failure mode: treating network reachability as trust.

5. Add Message Semantics¶

When you introduce I-Poll, use typed messages:

Message	Required checks
`PUSH`	identity, route policy
`PULL`	identity, route policy, read permission
`SYNC`	identity, relation, scope
`TASK`	identity, relation, policy, cost/risk gates
`ACK`	links to original message/action

A TASK should usually create a stronger evidence trail than a PUSH, because it can cause work.

Use Cortex to decide what is allowed:

policy:
  agent.local:
    can:
      - receive:PUSH
      - receive:PULL
    cannot:
      - execute:shell
      - access:secrets

Use SNAFT when the exchange needs agreement from both sides:

agent asks for sensitive context
operator proposes scope
agent accepts or rejects
TIBET records the consent chain
message route opens only for that scope

7. Add Evidence and State Snapshots¶

Once actions affect state, add material evidence:

Tooling layer	Purpose
TIBET trail	causal action chain
Wayback	point-in-time state seal
SBOM	software materials
AI-SBOM	AI/model/tool materials
CBOM	capabilities and authorities
Pol	health checks with receipts

Evidence should be queryable by actor, action, route, object and time.

8. Add Isolation¶

Route risky work through Airlock or an equivalent boundary:

unknown artifact
untrusted code
generated script
command with filesystem/network effects
cross-organization task

Safe default:

unknown -> quarantine
risky -> isolate
unsafe -> deny
approved -> execute with receipt

9. Choose an Install Profile¶

Use profiles based on the job:

Profile	Use when
`tibet[zero-state]`	you need identity and provenance primitives
`tibet[network]`	you need route probes, overlay and mesh primitives
`tibet[evidence]`	you need audit, SBOM, CBOM, reports and snapshots
`tibet[agent]`	actors need AInternet/I-Poll/MCP surfaces
`tibet[runtime]`	you want local operation without every enterprise layer
`tibet[full]`	you want the supported complete local trust-system profile

After a full install, the intended local path is:

pip install -U "tibet[full]"
tibet system doctor
tibet system init
tibet system walkthrough

The command installs the tools. The network is the actor registry, policies, receipts, routes and evidence you define.

10. Federate When Useful¶

Connect to another AInternet when you need:

a partner network;
a family or project mesh across locations;
a private hub between organizations;
outside discovery;
public .aint names.

Connect to public AInternet specifically when you need:

public .aint names
outside discovery
agent-to-agent communication beyond your network
public verification or claim paths
inter-organization messaging

Federation should preserve your local rules:

public actor resolves
fresh proof verified
local policy checks relation
SNAFT scope negotiated if needed
route opens or fails closed
TIBET records the chain

For the online lane doctrine, see Go Online. The important point is that the outside path is subordinate to the local network:

outside reachability does not create authority
public name resolution does not create consent
edge routing does not replace local receipts

11. Retire or Succeed Actors Explicitly¶

Networks change. Devices leave, agents are replaced, projects end, keys rotate.

Do not silently delete identity history. Use tombstone or succession semantics:

actor retired -> tombstone record + TIBET reason
actor replaced -> successor pointer + fresh proof
route closed -> MUX denies old path
relation renewed -> consent/policy is checked again

This keeps temporary networks temporary without losing auditability.

Bare Necessity vs Production¶

Bare necessity	Production needed
JIS identity	key succession procedure
TIBET receipts	signed export/report flow
known actors	role and permission model
local registry	private or public AINS
one route/message	MUX/I-Poll policy gates
one evidence trail	Wayback/SBOM/CBOM/Pol
manual checks	conformance vectors in CI

Test What You Built¶

Do not stop at a diagram. Each layer should map to a conformance family:

Layer	Conformance
actor identity and fresh proof	`ztip-conformance`
reachability, MUX, I-Poll and null-route behavior	`tibet-comms-conformance`
TIBET trail, Wayback, SBOM, AI-SBOM, CBOM and reports	`tibet-evidence-conformance`
Cortex, SNAFT, Airlock, quarantine and no-fail-open	`tibet-security-conformance`

The rule is:

if it cannot be tested by vectors, it is still a claim

Machine-Readable Build Map¶

For AI agents and build automation:

Surface	Use
`https://ainternet.org/templates/stack-build-map.json`	map human intent to primitives, packages and vector families
`https://ainternet.org/upip.json`	load build profiles and recipes
`https://ainternet.org/resources.json`	discover docs, standards, templates and conformance
`https://ainternet.org/api.json`	inspect callable verbs and proof rules

If you run fully local, copy these into your own node and pin the versions you build against.