# agent merge field render timed out and retried forever: how to fix it

A render that always times out will never succeed on retry; the field data or template is the problem. Cap retries, isolate the offending field, and fix the data.

```text
agent merge field render timed out and retried forever
```

## When to use this skill
- Agent retries a merge render indefinitely
- Merge render times out on the same field every time

## When not to use this skill
- Render completes with wrong values (a data issue)
- Render fails instantly (a template issue)

## Tool compatibility
Agent merge render retry bounds. Related area: agent frameworks.

Related area: proposal automation and agent-assisted RFP workflows.

Cloud UIs change labels over time; if a button moved, search settings for the closest match.

## Before you start
- Sign in to the tool and keep one tab open so sessions stay clean
- Copy the exact error text and note the time it happened
- Set aside 15 to 20 minutes; most of these resolve in a single pass

## Quick diagnosis
Make sure this is the right skill before you invest the 15 minutes.
- If you are dealing with agent retries a merge render indefinitely, start at step 1 below.
- If instead render completes with wrong values (a data issue), stop here; you need a different skill.
- If neither quite matches, compare your screen against the verbatim error block at the top; that block is exactly what this skill covers.

## Fix it in steps
### 1. Cap render retries at three

```
Allow at most three render attempts per run.
```
Expected: Expected: run stops retrying after the third timeout.

### 2. Isolate the slow field

```
Render fields one at a time to find the one that hangs.
```
Expected: Expected: the offending field identified.

### 3. Fix the field data

```
Check the offending field for huge values, loops, or bad references.
```
Expected: Expected: field data corrected.

### 4. Render once more

```
Run a single final render after the fix.
```
Expected: Expected: render completes inside the timeout.

## Confirm each step worked
Run through this checklist before moving on. If a check fails, redo that step instead of pushing ahead.
- Step 1 (cap render retries at three): Expected: expected: run stops retrying after the third timeout.
- Step 2 (isolate the slow field): Expected: expected: the offending field identified.
- Step 3 (fix the field data): Expected: expected: field data corrected.
- Step 4 (render once more): Expected: expected: render completes inside the timeout.

## Quick recap
1. Cap render retries at three
2. Isolate the slow field
3. Fix the field data
4. Render once more

## Still stuck?
Gather three things: the exact error text, the time it happened, and what changed just before it broke.
Check the vendor status page for an active incident. Then open a support ticket with those three things;
it cuts the back-and-forth in half. For agent runs, attach the last 50 lines of the agent log too,
since the loop or timeout signature in the log usually names the cause.

## Variant phrasings
### agent merge render timeout loop
Bound retries and isolate the field. If this matches what you saw, the steps above apply as written.

### agent merge field render retried forever
The field data is the problem. If this matches what you saw, the steps above apply as written.

## Why it happens
A deterministic timeout means the input is pathological for the renderer, so retries just burn time. Isolating the field finds whether the data is huge, self-referential, or pointing at a missing record.

## Edge cases
- Log render duration per field; the outlier is usually obvious
- Fields referencing deleted records hang instead of erroring; check references
- A render that degrades over runs suggests growing data; archive old records

## Provenance

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