Use Cases

Testing

Agent-generated code can pass a final-output check while still containing incorrect intermediate logic. A data or analytics agent may use the wrong input, apply an incorrect filter, introduce leakage, or perform the wrong join or aggregation - and still produce a plausible result.

Etiq creates testable boundaries throughout the execution by linking interim lineage objects to the functions that produced them. Tests and verification checks can therefore be applied to the relevant function-and-artifact pairs, rather than only to the final output or the complete generated script.

Use Etiq to:

• test intermediate datasets, models, agent states, and generated artifacts

• verify the inputs and outputs of individual pipeline stages

• target tests at the parts of the execution affected by an agent’s changes

• compare expected and observed behaviour across repeated runs

• add deterministic checks without relying on the agent to instrument or describe its own code

Benefit: More granular testing of agent-created code, with failures tied to the execution step and state that produced them rather than reported only at the end of the workflow. Etiq’s function-and-artifact lineage is specifically intended to support test harnesses and checks on interim outputs that conventional agent traces do not expose.

Debugging

Logs and agent traces can show that a script ran, a tool was called, or a task failed. They do not always reveal which transformation first made the underlying result incorrect.

Etiq traces outputs backwards through the functions and interim lineage objects on which they depend. Developers and agents can begin with a suspect result, inspect its producer function, and follow the relevant dependency path upstream until they identify the earliest meaningful divergence.

Use Etiq to:

• identify the function that produced a wrong interim result

• distinguish a bad input from a function that transformed a valid input incorrectly

• inspect captured inputs and outputs at the point of failure

• expand into nested functions only where additional detail is required

• limit reruns and repairs to the affected branch of the workflow

Benefit: Faster and more targeted root-cause analysis. Instead of searching the entire repository, transcript, or run history, the reviewer can focus on the execution path that contributed to the failed output. The graph can point to the producer of an incorrect interim artifact, while nested-function drill-down allows inspection to start at a meaningful stage and deepen only along the suspect branch.

Observability and Governance

Agent orchestration records what an agent planned and which tools it invoked. Runtime telemetry records events around the execution, such as model calls, subprocesses, timings, logs, and exit codes. These layers remain important, but they do not necessarily explain what happened inside the generated code.

Etiq adds a separate code-execution-lineage layer. It records the functions that ran, the lineage objects they consumed and produced, and the dependencies connecting those states to the final result.

Use Etiq to:

• trace a generated output back through its underlying code and data lineage

• inspect the interim data, model, or agent states associated with a run

• establish which function produced or changed a governed artifact

• preserve deterministic evidence independently of the agent’s own explanation

• connect review decisions, tests, and approvals to the execution evidence they used

• provide reviewers with a navigable record of how an output was produced

Benefit: Stronger auditability and governance for agent-created code. Teams can retain evidence of the transformations behind an output, rather than relying only on the agent’s plan, a final artifact, or platform-level telemetry. This complements orchestration and OpenTelemetry rather than replacing them: those layers describe the agent and surrounding runtime, while Etiq provides granular visibility into the code execution itself.

Long-Horizon Agents

Long-horizon coding agents work across extended sequences of planning, code generation, execution, review, delegation, retries, and resumption. As the task grows, its state becomes distributed across functions, artifacts, agent calls, retries, and points in time. It can no longer be reconstructed reliably from the latest message or a summary of the conversation.

Etiq provides an execution-grounded state and memory layer for these workflows. It records what actually ran, which inputs and outputs were observed, what was produced, and which later results depend on earlier execution. The etiq graph can also support more reliable context selection. Instead of repeatedly passing the full conversation, complete execution history, or every available artifact to the agent, a workflow can retrieve the graph region relevant to the current decision.

While semantic state records the objective, plan, constraints, decisions, and rationale, the execution state supplied by the etiq graph records the functions that ran, the inputs they consumed, the outputs they produced, and their dependencies.

The etiq execution graph can help constitute a form of shared state and memory for these more complex agents. The complete history of a long-running workflow may contain more detail than the agent needs for any one decision. Etiq can help a context builder select a bounded graph region based on the current operation.

Below example agent operations on the etiq graph:

Operation	Purpose
Planning	Retrieve trusted upstream outputs, relevant prior evidence, and known gaps before deciding what to do next.
Review	Compare observed execution with the task objective and acceptance criteria.
Retrace	Follow a failed or suspect result backwards to the earliest meaningful divergence.
Repair	Change or rerun the affected branch from the last trusted upstream boundary.
Resume	Continue from the latest reviewed state without repeating trusted work.
Memory	Retrieve comparable failures and previously reviewed repairs with their supporting evidence.

Each operation can request a different bounded view of the graph. Review may need a stage and its artifacts, while retrace may need a deeper dependency path and resume may need only the latest trusted boundary and unresolved downstream work.

Benefits:

• More reliable context selection by retrieving only the graph region relevant to the current decision

• Targeted failure recovery without replaying the full conversation

• Smaller rerun scope by preserving trusted upstream and unrelated work

• Reduced memory drift by retaining executed state rather than repeatedly summarising it

• Inspectable hand-offs between agents or workers through graph-linked artifacts

• Checkpoint and resume based on reviewed execution rather than conversational position

• Independent verification of what the code actually did, rather than relying on the agent’s own description

The graph can therefore operate as more than an audit record. It can provide the shared evidence and bounded retrieval layer from which the agent decides what it can trust, which context it needs, and where it should continue.

We will publish our example long horizon harness using the etiq graph shortly.