Creators Own the Loops

Creators should not merely be in the loop. Creators own the loops. Today's systems usually place a person before and after a black box. NoteG+ brings the human inside the process. For creative production, it goes further: creators own the loops themselves. Ownership means more than deciding where a loop starts and ends. Humans hold the right to design, observe, adjust, branch, delegate, optimise and replace a loop while work is taking place. That ownership has six dimensions. ## 1. The right to establish The human sets the initial purpose, scope, constraints, roles, data sources, models or capabilities, acceptance criteria, budget, review points and permitted degree of automation. ## 2. The right to observe The human must be able to see what the system is doing, its assumptions, the intermediate artifacts it has created, what has changed and what has been spent. Is the loop making progress or just creating variations? Which failures keep returning? No observability, no ownership. ## 3. The right to diagnose “Not good enough” is not enough information. Was the problem in the output or the brief? The model or the delegation? Missing references or contradictory ones? Unclear acceptance criteria? A checker using the wrong standard? A task too large to handle in one piece? Or a creative direction that needs reconsideration? ## 4. The right to reconfigure A human, or an authorised Senior, must be able to change task decomposition, sequence, model, execution role, prompt, context, references, sampling strategy, acceptance criteria, checker, level of automation, budget, stopping points, branches and escalation paths. This is the most important right that ordinary “human approval” models leave out. ## 5. The right to preserve and revise selectively A human must be able to say: “Keep these three parts. Try only that part again.” If every iteration destroys all previous state, that is not creative control. It is another wager from scratch. NoteG+ needs to support locking, freezing, branching, isolation, selective rework, comparison, rollback and reuse of accepted components. ## 6. The right to change the objective itself Creators do not always know the full result at the outset. Sometimes an unsuccessful output reveals that the original intent was wrong, a scene needs another direction, a standard was unsuitable, something that seemed essential is unnecessary, or the work is opening a better possibility. Humans do not simply adjust the means of reaching a fixed goal. They can change the goal as the creative process reveals new understanding. This distinguishes creative production from a purely mechanical pipeline. ## An AI loop is a hypothesis, not a truth When we establish a loop, we are proposing a hypothesis: with this task decomposition, model, references, checker and acceptance criteria, we might move closer to the intention. After one or several iterations, we must evaluate that hypothesis. Three outcomes are possible: 1. The output is wrong but the loop is sound. Another controlled attempt may help. 2. Part of the loop is wrong. Change the references, model, prompt, checker or decomposition. 3. The direction itself is wrong. Return to creative intent or the structure of the project. A system that only knows how to retry treats all three as the first case. A real workbench must help distinguish them. ## Media loops have their own economics Each video generation can consume model fees, compute, waiting time, storage, review time, the effort of organising variations and the creator's attention. “Not passed, generate again” cannot be the only condition. A loop also needs an owner-defined budget, an attempt strategy, expected improvement, marginal cost, reuse possibilities, a point to change strategy and a point to stop. For example, if the same identity drift remains after three attempts, the useful response may be to inspect the reference package, change the model, separate the character pass or make a cheaper test before rendering another full video. That is loop optimisation, not retry. ## A good media loop moves from cheap questions to expensive ones Instead of repeatedly generating a full video, the work can progress through intent, textual treatment, rough composition, still keyframe, low-resolution motion probe, locked visual direction, short motion test, selective correction, final generation and finishing. Each stage answers a specific question. Do not use an expensive video to test something that text, a storyboard, a still image, an animatic, a motion sketch or a low-resolution preview can resolve. This is where production experience matters. A model's ability to generate video does not mean every decision should be tested through video generation. Expensive generation before direction is settled turns creative development into a casino. ## Make the loop a first-class working object In NoteG+, a loop should not merely be a hidden flow. It should be a visible, editable working object. It should hold: - Its identity and current purpose. - The version of the intent, inputs and references. - Task decomposition, responsible Seniors and execution roles. - Models, parameters and locked components. - Acceptance criteria, validators and critics. - Budget and stopping or escalation conditions. - Change history, failures and diagnoses. - Cost per run and what has been learned. When a loop changes, record what changed, who changed it, why, which observation supported the change and whether the result improved. A project should not repeat the same failure or start from zero after every generation. ## The Senior's role must change too The Senior is more than a checker standing behind execution. It must be able to design and diagnose loops: recognise poor task decomposition, propose another strategy, detect crude checking criteria, suggest a cheaper probe, identify what to lock, notice rising costs without improvement, recommend stopping a direction or ask the human to reconsider intent. But important changes to authority or structure remain within the Senior's delegated scope. The human still owns the constitution of the loop. Operator executes. Checker critiques. Senior diagnoses and organizes. Human owns the right to change the process and the final decision. ## The full definition Humans owning the loops means owning the purpose, structure, authority and responsibility of the process; being able to observe intermediate states; retaining the right to adjust or replace the loop when new information arrives; and deciding when a result is accepted as part of the work. In creative production, changing a loop mid-process is more than governance. It is part of the creative act. Creators often discover the work through attempts, refusals, adjustments and changes of direction. This makes NoteG+ different from both generation platforms and ordinary maker-checker frameworks. A loop is not a machine that runs until a checker says “pass”. It is an uncertain creative structure that humans and Seniors must keep observing, learning from and redesigning. ## Graphs and loops are mostly theories of control flow The usual explanation is a chain: node A, node B, router, node C, checker, then pass or return to node B. A graph describes which step connects to which. A loop describes when to repeat. A router selects a branch, a checker decides pass or fail, and state carries data between steps. This is useful for building software, but it remains primarily an execution topology. It is not a complete theory of work. It does not explain why tasks were divided that way, whether the objective remains right after three attempts, whether the checker uses the right standards, or whether the fault lies in the output or in the process that produced it. Should the model, references, context or decomposition change? What is already correct and must be preserved? Is another attempt worth its cost? Who may change the workflow? Where can the human see and intervene? Who takes responsibility for the final decision? A graph can execute perfectly while running a badly designed process. ### The fundamental mistake is assuming the loop is already known Many frameworks assume a loop is correctly designed: run it, return failed output to the maker, repeat until it passes. But any loop involving AI should be treated as a provisional hypothesis about how the work might be done. We are assuming that task decomposition is suitable, the model is appropriate, context is sufficient, references are right, the checker understands intent, the criteria can assess it, the number of iterations makes sense and the cost is acceptable. Running the loop may reveal that those assumptions are wrong. Continuing at that point is not persistence. It is spending resources on a configuration that no longer makes sense. A loop that cannot be questioned is not a learning system. It is a retry mechanism. ### The checker cannot repair the loop A checker usually has one assignment: does the output meet the standard? If it does not, send it back. But evaluating a result is not necessarily evaluating the process that produced it. “The character is inconsistent” does not explain whether the reference package lacks face angles, the identity model is unsuitable, video came too early, the keyframe should have been locked first, character and camera motion are conflicting in one pass, acceptance criteria are vague, or the whole visual direction needs to change. If the checker only says “fail”, the maker produces another output. That is discarding a lottery ticket and buying another. Detecting failure does not improve the probability of success. Something meaningful in the loop must change. ### Current theory is too heavily shaped by coding agents Code can compile or fail. Tests can pass or fail. Errors can often be located precisely. A diff shows what changed. One function can be repaired while the rest is preserved. Retrying is often relatively inexpensive. Objectives can be expressed as tests. Generate, test, fix and repeat can therefore converge. In generative media, those assumptions often break. Standards are not fully defined. Beauty, rhythm and depth are not booleans. Errors do not reside on one line. Generation can change many variables at once. Correct parts may not survive. AI checking is uncertain too. Video retries can be expensive, and a different result is not necessarily a closer result. Code can have local errors. Media often has relational failures: individual parts look fine, but fail together. An agent model derived from coding cannot be a universal theory of work. It is one comparatively favourable case. ### A graph is not a workflow, and a workflow is not yet work - Control flow describes which step runs after which. - Workflow describes who does what, and where handoffs and checkpoints sit. - Work includes how objectives change, how judgement forms, and who has the authority to decide and take responsibility. Popular theories are strong at the first level and sometimes reach the second. They rarely address the third fully. In real work, especially creative work, objectives change. Tasks need dividing again. Once-essential steps become unnecessary. A failed output reveals a new direction. Criteria become clearer through execution. A Senior discovers that the brief is wrong. A loop is replaced by a different method. These are not exceptions. They are the nature of work that requires judgement. ### A graph is a temporary projection In NoteG+, a graph should represent our current understanding of how to organise the work, not “the real process”. It has versions. The first version might be: brief, generate video, check. After failure, the second might be: brief, clarify intent, build character references, generate a still keyframe, human lock, motion probe, check motion only, final video. Progress is not that the second version happens to create a prettier output. It is that the second version organises the work better. NoteG+ therefore needs graph and loop histories as well as output history: reasons for changes, supporting evidence, costs before and after, improvement, preserved parts and rejected assumptions. ### The loop must be editable while it runs The human does more than start a loop, set checkpoints or approve at the end. Directly or through an authorised Senior, they must be able to change decomposition, models, execution roles, references, prompt strategy, context, criteria, checking, automation, budget, sampling, locked parts, stopping conditions, escalation and the creative objective itself. Humans own more than whether a loop runs. They own the ability to restructure it during the work. Automation with checkpoints is not yet a human-owned process. ### Not every iteration has value Three kinds of iteration need distinct names: - Retry: keep almost the same configuration and hope for a better sample. Same process, new sample. - Revision: preserve what works and change a specific part intentionally. Accepted state, targeted change. - Loop improvement: change how the work is done. Old process, diagnosis, redesigned process, new experiment. Many platforms call all three “iteration”. They are not the same. ### Agent theory often optimises autonomy instead of governability Systems are often judged by how many steps agents complete alone, how little intervention they need, how long they run uninterrupted or how often they repair themselves. For serious work, the more useful question is how well the process can be understood, adjusted and held accountable. Autonomy and governability are different. An autonomous agent may be difficult to explain or interrupt, lose intent, spend too much, repeat mistakes, change objectives and leave the human only the right to reject a result at the end. That is a black box able to act, not a good colleague. NoteG+ does not need to maximise autonomy everywhere. It needs delegation without loss of authority. ### The better question is not “graphs or loops?” Both are necessary, but both are underlying structures. The real question is how to build an uncertain human-AI process whose execution structure can change with new understanding while authority, state, cost, provenance and responsibility remain clear. In that model, the graph is the current work configuration. The loop is a purposeful experiment. Output is evidence, not automatically a final result. A checker is a critic and diagnostic aid, not only a pass/fail gate. A Senior designs and diagnoses. An Operator executes capabilities. The human owns objectives, authority, structural change and finality. NoteG+ retains the state, history and ability to intervene across the system. A graph that cannot change is an automation diagram. A loop that learns nothing from failure is retry. AI makes more than the output uncertain. The process itself must be treated as a hypothesis that needs continual testing and improvement. Most current theories model how agents run inside a process. They do not fully model how humans and AI change that process together while work is underway. For NoteG+, this is the starting point: no AI loop can be assumed certain. Every loop must remain observable, diagnosable, reconfigurable, versioned and owned by the person responsible for the work.