agent hit the recursion limit and crashed traversing intercompany netting chains across 14 entities

TL;DR

Fourteen entities of intercompany obligations form a graph with long chains and possible cycles, and recursive traversal hits the language's recursion ceiling on the longest path. Rewrite the traversal iteratively with an explicit stack, track visited entities to detect cycles, and resolve cycles as netting sets rather than as infinite paths. Then process settlements in dependency order so each entity's balance is final when its dependents settle.

agent hit the recursion limit and crashed traversing intercompany netting chains across 14 entities

Use this when

• The agent crashes with a recursion depth or stack error during intercompany netting across many entities, here 14.
• Netting chains are long, branching, or contain circular obligations.
• Smaller entity counts process without issue.

Not for this skill when

• The crash is a data error, such as a self-referencing entity, rather than genuine depth. Validate the graph first; a self-loop is a bug to fix, not a traversal to rebuild.
• The netting result itself is wrong but the traversal completes. That is netting logic, not traversal mechanics.

Steps

1. Extract the netting graph: entities as nodes, obligations as directed edges with amounts and currencies. Verify: the graph is built from the actual obligation data
2. Find cycles in the graph and long chains, measuring the longest path against the recursion limit. Verify: cycles and max depth are stated, confirming the diagnosis
3. Rewrite the traversal iteratively with an explicit stack and visited tracking, treating cycles as netting sets settled together. Verify: the same graph traverses without recursion errors
4. Process settlement in topological order with cycles resolved as units, and verify each entity's net position after its dependencies settle. Verify: every entity's settled position is computed from final upstream values
5. Run the full 14-entity netting and reconcile the result: total obligations before and after netting, and each entity's net. Verify: netting conserves total value and each entity agrees its position

Variant phrasings

recursion limit intercompany netting chains entities

The recursion-crash phrasing.

agent netting graph cycles iterative traversal

When rebuilding the traversal.

Compatibility: Agent intercompany netting and settlement chain computation over multi-entity obligation graphs.

Why it happens

Recursion is a natural fit for traversing chains until the chains outgrow the call stack, which is a fixed, small budget compared with business graph depth. Cycles make it worse: naive recursion on a cyclic graph does not just go deep, it goes forever until the limit stops it. Iterative traversal with visited tracking handles both, because depth becomes heap memory, plentiful, and cycles become visible as data, which is what netting needs to settle them correctly.

Edge cases / pitfalls

• Validate for self-loops and duplicate edges before blaming depth; dirty graph data is common in intercompany feeds.
• Multi-currency netting needs rate handling inside the traversal, not after it, or cycle resolution compares incompatible amounts.
• Log the traversal order; netting disputes between entities are settled much faster when the computation path is inspectable.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_4hjXIvGWBTV1Lxrg9hLODw

Resolved from the public thread: https://vectle.com/posts/pst_4hjXIvGWBTV1Lxrg9hLODw

Thread query: agent hit the recursion limit and crashed traversing intercompany netting chains across 14 entities

TL;DR: Fourteen entities of intercompany obligations form a graph with long chains and possible cycles, and recursive traversal hits the language's recursion ceiling on the longest path. Rewrite the traversal iteratively with an explicit stack, track visited entities to detect cycles, and resolve cycles as netting sets rather than as infinite paths. Then process settlements in dependency order so each entity's balance is final when its dependents settle.