Connections

A line between two nodes is a line until you say what should travel along it. This is what you can say: which way a value goes, which port at each end, what is allowed across, and how often.

Ports
The three modes
Only when…
Reshaping on the way
What an agent does with them
Limits
When something goes wrong

Ports

A connection joins an output on one node to an input on another. Every node has one of each without you declaring anything:

Port	What it is
`info` (out)	Where a node's agents put what they conclude. A finished run leaves through here.
`inbox` (in)	Where anything sent to this node arrives.

So a connection you drew and never configured already has somewhere to go. You can name other ports when one node produces more than one kind of thing — "orders" and "problems", say — and a port can declare what it carries: text, a number, a boolean, an object, a list, a file, or an event. That declaration is checked: a port that says it takes a number refuses a value that is not one, rather than passing it along for an agent to trip over later.

The three modes

Select a connection to choose one.

Mode	When the value moves	Use it when
Send it as soon as it is produced (push)	The moment the source produces a value, it is delivered to the target's input and waits there.	A node should always have the latest from another — a dashboard, a running total.
Send it, and run the other node's agents (trigger)	The value is delivered and the target node's agents run, with it to work from.	Finishing one piece of work should start the next: "when a payment arrives, fulfil the order".
Keep it until the other node asks (pull)	Nothing moves on its own. When the target's agent asks, it reads whatever the source is holding right then.	The data is big, or expensive, or only sometimes wanted.
Nothing — just a line	Never. It is a drawing.	The connection means something to the people reading the schema, not to the machine.

A node's finished result leaves through its default output like any other value, so everything below — filters, mappings, limits — applies to it too.

Only when…

A connection can carry only what matches. A filter is three things: a field to look at, a comparison, and a value — for example amount, more than, 100. Use a dot to reach inside: customer.name.

Comparison	True when
is / is not	The field equals, or does not equal, the value.
more than / at least / less than / at most	Both sides read as numbers and compare that way.
contains	The field is text containing the value, or a list containing it.
exists / empty	The field is there at all, or is missing, blank or an empty list.

A filter is data, not code. It is a field, a comparison and a value — never an expression that gets evaluated. A schema is a document people send each other, and a connection that ran whatever was typed into it would make opening someone else's schema a risk.

Reshaping on the way

A connection can rename and reshape what crosses it, so the receiving node gets the shape it expects rather than whatever the sender happened to produce. Each move takes a field from the incoming value, puts it somewhere in the outgoing one, and can apply one transformation: as text, as a number, upper or lower case, trimmed, rounded, counted, joined into a line, or just the first of a list.

With no mapping at all, the value crosses unchanged. With one, only the fields it names cross — which is also a way to stop something private travelling further than it should.

What an agent does with them

An agent on a node is told what that node's ports are and where each one goes, and has two tools:

Read an input — what arrived on it, or, for a pull connection, whatever the node at the other end is holding right now.
Send a value — produce something on one of its outputs. Whatever is connected to it receives it, according to that connection's mode.

This is the only way an agent can put something into another node. It cannot write into one directly, which is what makes a schema's wiring the truth about how work moves through it.

Limits

Limit	Value	Why
How far a value travels	6 hops	A schema drawn in a circle would otherwise run forever. Every hop spends one.
Size of one value	256 KB	Past that it is refused, never cut in half — nobody should act on half a message.
Outputs from one run	8	A loop of deliveries is a schema shouting at itself.
Connections followed at once	10 from one node	Fan-out stays something you can reason about.
Per connection	Yours to set	Give a connection a limit per hour when whatever is downstream costs money.
Deliveries kept	7 days	Long enough to see what happened, not a second archive.

A retried run sending the same value on the same connection is one delivery, not two: a delivery's id is derived from the run, the connection and the value, so repeating it changes nothing.

When something goes wrong

What you see	What it means
"nothing is connected to it"	The agent sent a value on a port with no connection out of it. Draw one, or send on a different port.
"This node has no input called …"	The connection names a port the node does not declare. The message lists the ones it has.
"The port … takes number, and that is not one"	The value does not match what the port promises. Change the value, the mapping, or the port's type.
filtered	Working as intended — the value did not match the filter, so it did not cross.
"This has been passed along too many times"	The hop limit. Usually a circle in the schema.
"more than a connection carries"	Over 256 KB. Send a summary, or a reference to the data rather than the data.
"already carried its … for this hour"	The connection's own rate limit. It resets on the hour.
"The node at the other end is not there any more"	The target node was deleted. Remove the connection or point it somewhere else.