Ask a chatbot a question and you get an answer. One turn. You speak, it speaks, the exchange is over. That's a conversation, and conversations are lovely, but they don't build anything.

An agent is different in exactly one way, and it's a surprisingly deep way: an agent doesn't answer, it loops. And once you see that loop clearly, you understand Elyra completely — because Elyra is that loop, given a body.

The smallest big idea in AI

Here's the whole concept on a napkin. An agentic loop is a cycle that repeats:

observe  →  reason  →  act  →  observe  →  reason  →  act  →  ...  →  done

• Observe — look at the situation: the task, the files, the result of the last action.

• Reason — decide what to do next.

• Act — actually do something in the world: read a file, run a command, edit code.

• Then look at what happened, and go around again.

That's it. The magic isn't in any single step — it's in the repetition. A chatbot stops after "reason." An agent keeps going, using what it just learned to choose its next move, until the job is genuinely finished.

Three ingredients make the loop turn: a model that can reason, tools it can use to act, and a stopping condition so it knows when to rest. Take away the tools and you're back to a chatbot — all talk, no hands.

Elyra is the loop

This is the part worth sitting with. People sometimes describe Elyra as "an AI that writes code." That's true but it undersells it. Elyra isn't the model — you can swap the model out mid-session. Elyra is the loop around the model. The harness. The body.

When you give Elyra a task, here's what's actually spinning:

1. It observes — reads the relevant files, the error output, your request.

2. It reasons — works out the next concrete step.

3. It acts — calls a tool: read, grep, edit, write, bash.

4. It observes the result — the file contents, the test output, the failure.

5. It goes around again — feeding what it learned back into the next turn.

You watch it happen in real time:

> The checkout test is failing. Find out why and fix it.

  Running npm test -- checkout         (act)
  ✗ "applies discount" expected 90, got 100
  Reading src/checkout.ts               (observe)
  Reading src/discounts.ts              (observe)
  ...the discount is calculated but never subtracted (reason)
  Editing src/checkout.ts               (act)
  Running npm test -- checkout          (act)
  ✓ all passing                         (observe → done)

  Fixed. The discount was computed but not applied to the total.

Read it again and you'll see the loop breathing: act, observe, reason, act. Nobody told it to read discounts.ts — it decided that, because the first observation pointed there. That decision-in-the-loop is the entire difference between a tool and an agent.

/goal is the loop in its purest form

Most of the time, Elyra's stopping condition is a judgment call: "this looks done." Reasonable, but soft. Sometimes you want the loop to run against something hard and objective.

/goal npm run check

Now the stopping condition isn't an opinion — it's an exit code. Keep looping: observe, reason, act, run the check, read the result, fix what broke, run it again. Stop only when the command passes. No "continue." No babysitting. This is the agentic loop stripped to its essence: a goal, a body, and the patience to go around as many times as it takes.

It's a small command that quietly changes your relationship with the tool. You stop steering every turn and start setting destinations.

A loop you can run without fear

There's a catch hiding in any loop that touches real files: what if a turn goes wrong? A bad edit, three iterations deep, used to mean cleanup.

Elyra checkpoints every turn — the conversation and the files, together. So if the loop wanders somewhere you don't like:

/rewind

…and you're back. The whole point is psychological as much as technical: when undo is free, you let the loop be bold. And bold loops solve harder problems than timid ones.

Tuning the loop

Because the loop wraps the model rather than being the model, you can tune it on the fly:

• Thinking levels change how hard it reasons on each pass — minimal for mechanical work, high for the gnarly bug.

• Switching models with /model lets you put a cheap, fast brain on the boilerplate iterations and a powerful one on the hard calls — even within the same loop.

Same body, different engine, dialed to the moment.

The honest part

A loop is powerful precisely because it keeps going — and that's also where it bites. The longer it runs, the more small errors can accumulate, and the more it costs, turn by turn. A loop with a vague stopping condition can grind in circles. A loop with no verification can confidently arrive at the wrong place.

So the craft isn't "let it run forever." It's giving the loop good bones: a clear goal, real tools, and an objective way to know it's done — a passing test, a green check. The loop amplifies your judgment about what finished looks like. It doesn't supply that judgment for you.

Why this is the whole story

Strip away the features, the providers, the extensions, and what's left at the center of Elyra is this quiet cycle: look, think, act, look again. It's not flashy. You won't see it on a billboard. But it's the difference between a thing that talks about your code and a thing that changes it and checks its own work.

Elyra is a loop. Give it a goal, and let it turn.

Happy building.