The graph you see, the system that runs.

State, computation, and effects live in one executable graph. Changes move through declared relationships, related branches settle coherently, and humans and agents inspect the same system that actually ran.

See one change move Why GraphReFly

Executable reactive graphs for changing software.

Change one input. Watch its consequences move.

Follow one cause through the paths it affects, then watch those paths settle into one shared result.

The risk

If the total publishes too early, the customer can see new tax combined with old shipping.

The graph behavior

The address change moves through declared dependencies. The shared result waits for every registered path to settle, then publishes one coherent answer.

One change moves through every affected branchGraphReFly

1
Delivery addressOne cause enters the graph
2
Taxnew jurisdictionShippingnew routeAvailabilitynew region
3
Order totalPublishes after affected branches settle

One change. Many consequences. One coherent result.

Declare the relationships once. Let the running system preserve them.

Principle

The topology is truthful

Every visible edge represents a real dependency. If computation depends on something, that relationship belongs in the graph.

Practical resultReview the dependency that executes, not a diagram that only resembles it.

Principle

Consequences stay coherent

A change can fan out through several branches without publishing a shared result from half-old, half-new inputs.

Practical resultLet the protocol settle shared results instead of rebuilding coordination by hand.

Principle

Context follows dependency

Each node works from its declared inputs. People and agents can focus on the relevant path instead of loading one global workflow state.

Practical resultGive each participant the relevant path without loading one global workflow state.

Ask the graph that actually ran.

GraphReFly exposes read-only views over the executable graph, not a second control plane.

GraphReFly provides the causal evidence. Humans and agents explain it.

describe()

See the live topology, dependencies, status, values, and metadata.

observe()

Watch messages move through a node, subtree, or graph.

profile()

When supported and enabled by the package, measure where computation invokes, emits, resolves, and fails.

Start where coordination becomes unclear.

Boundary rule

Keep outside work honest.

Network calls, models, workers, files, and remote graphs do not share the graph’s timing or failure model. Keep them behind explicit boundaries, then return their outcomes as named facts.

External execution can stay private. Decision-relevant state must return to the graph.

Starting point

Start with one result your team does not understand.

Replace one bounded piece of coordination glue: a derived decision, policy path, fan-out/fan-in calculation, or agent step.

Choose a runtime

Use the language your team already works in.

The graph model is shared. Installation, examples, and exact APIs live with each language package.

TypeScript@graphrefly/tsnpm install @graphrefly/tsEnter TypeScript docs Pythongraphreflypip install graphreflyEnter Python docs Rustgraphrefly-rscargo add graphrefly-rsEnter Rust docs