Building by conversation

You describe what you want and Imaginne builds it. It creates the agent, adds the steps, points to a connection, tests, publishes and turns on the trigger — by talking.

This is not a separate mode of the product. There are two hands on the same document: the mouse and the conversation. What the conversation creates shows up on the canvas immediately, and what you move with the mouse is what it sees in your next sentence. There is no "AI mode" and "manual mode".

Where the conversation lives

Surface	Where it is	What it is for
Terminal	the front door of /agent	starting from scratch, finding an agent, asking why something failed
Editor dock	beside the open flow	changing what is on screen without switching context

Both are the same conversation. Switching screens does not switch who you are talking to: what you said in the terminal still holds when you open the editor.

What it does

• builds, changes, tests, publishes and activates agents;
• reads executions to explain what happened;
• points steps at connections, APIs, databases and organization skills.

What it does not do

This list is deliberately short, and every item has a reason:

It will not	Why
Create or administer Agent Spaces	that is an administrative act, and it has its own screen
Grant a role to someone	governance has its own screen, MFA and audit trail
Run loose code, open a shell or administer a host	it only runs a published automation, which has declared inputs and outputs
Read back or repeat a credential value	what exists in the conversation is the connection name, never the secret

The absence is the contract

In operator mode, Imaginne sees only the tools the Agents product declared. The engine's general tools — files, shell, search — are neither offered nor accepted.

This is not a request in the prompt ("don't use the shell"): they do not exist in that turn. The practical consequence is good for you: when something is missing from the product, it shows up as a gap instead of being worked around through an improvised path nobody reviewed.

How it works

Imaginne follows playbooks declared by the product itself. The ones you will meet most often:

Build a new agent — confirms the space, creates the agent with a name that says what it does, declares the input, adds the steps in order, declares the result, and publishes only once validation is sound.

Change an agent that already exists — opens it, looks at the flow as it stands, identifies the exact step and changes what is there. It does not rebuild the flow from scratch and then replace it: you would end up with two.

Put a step in the middle — when you say "before X, do Y", it uses the insert-block gesture and the server rewires the edges, preserving the branch labels. Nobody unplugs and replugs steps by hand.

Find out why it failed — it lists recent executions, opens one, and reads what each step received and returned. It does not guess the cause without opening the execution.

Let a step reach an external system — it checks whether a connection with that name already exists in the space; when it does not, it opens the secure credential capture in the interface and then points the step at the connection by name. The password never travels through the conversation.

What "done" means

Two distinctions are worth knowing, because they change what you should expect:

It said	It means	It does not mean
"I published the version"	an immutable version exists, created from the draft	that it is in production
"I promoted it to production"	the version counts for real	that the agent will fire on its own
"I started the execution"	it began	that it finished — the outcome comes from inspection

With no active trigger, nothing runs on its own

A flow that is correct, published and in production will not fire if its trigger is off. This is the most common misunderstanding, and Imaginne is instructed never to say something is live before the trigger is active.

When it refuses

Refusals are typed, and each one asks something different of you:

What you read	What happened	What to do
missing role	the resource exists and your role does not reach it	it tells you which role is missing and where it is granted
more than one match	the name you used matches several	it asks, naming what it found; it never picks for you
not found	the reference matches nothing you can reach	it tells you what does exist, instead of inventing a near-miss name
not available here	the capability does not exist in this installation	it carries on without it and says what was left out
refused	the change was judged by the product and rejected	read the reason; repeating the same change will be refused the same way

A dropped turn comes back on its own

When the model's transport dies in the middle of a long inference — and it does —, the turn is resumed automatically, up to twice. Resuming does not redo what was already applied: the work is saved, and it continues from where it stopped.

Twice, not endlessly: an interrupted turn has already consumed tens of thousands of tokens, and retrying without a ceiling would turn a network failure into a bill. If both attempts fail, you get the real outcome — a turn that stopped halfway never appears as completed.

What it never sees

An organization skill is a resource you attach to an agent; it enters the environment where the agent runs. It does not enter the context of the Imaginne operating the product.

In the conversation it can search for skills and see the descriptor — key, name, what it is for, whether it is enabled — in order to point a step at one. The skill's content never reaches it. The name and description of any resource are text somebody typed into a form: to the operator that is data, never an instruction.

Not every installation has it

The conversation depends on an operations manual published and active for this environment. When there is none, the interface does not offer the conversation rather than offering it and failing.

If the dock is not where this page says it should be, that is why — and it is resolved by whoever administers the installation. See Administration.

Next steps

• Quickstart
• Getting to know Studio
• Step types
• Connections