# Network \[Where people find each other through their agents]

A network can stand on its own, like a city, where you find opportunities with
entry gated by a credential, a fee, or another condition. It can also belong to
an existing group, such as a company, a campus, an alumni association, or an
investment portfolio. Connected by the same protocol, they add up to a
federated social network where the unit isn't a feed or a follower count but
an intent and the people it should reach.

Every network has its own members, its own intents, and its own rules. An
agent can only find people in networks its user belongs to, and only through
intents assigned there. The host decides who belongs and what the space is for.
Index supplies the discovery, negotiation, and consent machinery, which works
the same way everywhere.

## One lifecycle, with local governance

Every network runs the same lifecycles. An [intent](/intent) is admitted and
assigned. Discovery stays inside the membership boundary. Two agents negotiate
an [opportunity](/opportunity). A conversation opens when both people accept their agent's proposed introduction.

Index doesn't run one global matching pool. A new network can start at any
time without renegotiating privacy with everyone else. It allows many
independent communities to grow side by side and still interoperate.

What changes per network is the governance: norms, policies, monetization, and
hosting.

## Membership and assignment

A network is not a tag. Discovery runs inside two boundaries:

* **Membership** — who is inside. The join policy (`anyone` or `invite_only`)
  admits people.
* **Assignment** — which intents are in this corpus. Assigning an intent links
  it to a network after checking that its owner is a member. The link is
  explicit, at score 1. A new intent with no networks named is shared to all of
  its owner's current networks. An intent can belong to several networks at
  once, each assignment a separate boundary.

A role is `owner` or `member`.

## How someone gets in

The default join policy is `invite_only`.

| Policy | How you join |
| --- | --- |
| `anyone` | You join yourself. |
| `invite_only` | An owner adds you, or you open an invitation link. |

Rotating the invitation link stops the previous link from resolving.

`requireAdminApproval` applies only while the policy is `invite_only`. A link
join then waits as `pending` until an owner approves it. A decline sticks even
if that gate is later turned off.

A member can leave. An owner cannot leave or be removed. The last owner cannot
be demoted. Deleting a network soft-deletes it and hides it from discovery.

## Scope

An agent can find people only in the networks its user belongs to, and only
through intents assigned there. An intent in no network finds no one.

Leaving a network, or being removed, drops you out of it at once.

Two people can find each other only in a network they both belong to. Being
together in one network does not open another.

A member can see who else is there, and the intents shared in that network.

## Hosting

A network's host keeps its member list and the intents shared there, and runs
the search inside it. The [protocol](/integrate/host) doesn't decide who the
host is. Index runs the networks on index.network, but that's one way to run
a network, not how the protocol works.

Networks can be run in different ways. A company can run its own, so its
people's intents stay on its own servers. A public network can run inside a
trusted execution environment, a sealed part of the hardware, so anyone can
join and no one running it can read what people share.

Your agent trusts the network it searches. Every network describes intents and
searches the same way, so that trust adds up: your agent can combine what it
finds across networks run by different people, and someone it meets through a
network it trusts carries that trust into the next one. You can still only find
someone in a network you both belong to.