"Quick question" — without losing your place - Elyra v0.7.15

What does validateToken actually return? I'd like to know before the agent gets there.

You have three options, and none of them are good.

You can wait. Let the agent finish, then ask. By then you'll have forgotten the question, or the agent will already have made an assumption about validateToken you could have corrected ten minutes ago.

You can interrupt. Type the question now. The agent stops the refactor, answers, and now its context is muddied with a tangent it didn't need.

You can open a second terminal. Start a new Elyra session, ask there, switch back. Now you're juggling two terminals, and neither knows about the other.

The underlying problem is simple: a conversation is single-threaded. One question, one context. If your brain wants to branch, the tool can't follow.

/btw — a second thread that doesn't touch the first

elyra install npm:@elyracode/btw

Type /btw followed by a question, and it runs in a separate process with its own context. The main agent doesn't see it. The main agent doesn't stop. You get an answer while the refactor keeps moving.

/btw what does validateToken return in src/auth/service.ts?

Elyra spawns an isolated sub-process with full tool access — it can read files, run commands, search code. A moment later:

BTW response:
validateToken(token: string): boolean
Returns true if the JWT signature is valid and the token hasn't
expired. Checks against the JWT_SECRET env var. Does not verify user
existence in the database — that's handled by the auth middleware.

The main agent is still refactoring. It never saw the question. It never saw the answer. Its context window is untouched.

And now you know something the agent doesn't yet: validateToken doesn't check user existence. That matters. When the agent gets to that part of the refactor, you can steer it with that knowledge — or hand the BTW thread over directly.

A thread, not a one-shot

BTW remembers. Each question builds on the previous ones:

/btw what does validateToken return?

...answer...

/btw and where is it called from?

...answer, with context from the first question...

/btw is there a test for the expired token case?

...answer...

You've built a small investigation on the side. Three questions, three answers, zero tokens spent in the main context. The main agent is none the wiser.

Bringing it back

Sometimes the side investigation produces something the main agent needs. There are two ways to hand it over.

/btw:inject sends the full thread.

/btw:inject refactor validateToken based on what we found

Your questions, the answers, and your instruction land in the main session as a single message. The agent gets the whole investigation and a clear next step. The BTW thread clears itself.

Use this when the details matter — when you want the agent to see the journey, not just the destination.

/btw:summarize sends a condensed version.

/btw:summarize

Elyra distills the thread into a few sentences and injects that. The main agent gets the conclusions without the back-and-forth.

Use this when only the takeaway matters. "validateToken doesn't check user existence and has no test for expired tokens" is cheaper than three rounds of Q&A.

The commands

Command What it does /btw <question> Ask in a parallel side session /btw:inject [instructions] Send full thread to main agent /btw:summarize [focus] Summarize thread and inject /btw:thread Show the current BTW thread /btw:clear Clear the thread without injecting

When you'll reach for it

Clarifying questions while the agent works. "What does this function return?" "How many tests cover this module?" "What's in the .env for the database?" The kind of quick lookups that would derail the main conversation if you asked them there.

Pre-investigation before steering. Before telling the agent to "refactor the payment module," spend two minutes in BTW understanding what's actually there. Then inject what you found and give a precise instruction instead of a vague one. The difference between a good prompt and a great one is often just a few minutes of looking around first.

Exploring alternatives without commitment. "How would this look with a strategy pattern instead?" Ask BTW. If the answer is promising, inject it. If not, clear it. The main agent never wastes tokens on a dead end.

Checking the agent's work. It just edited five files. Before moving on: /btw run npm test and tell me if anything broke. You get the answer without the main agent spending a turn on verification.

How it differs from !!

If you've used !!command, you know it runs a shell command privately — you see the output, the agent doesn't. BTW is in the same family, but it's different in three ways:

1. BTW thinks. It's a full LLM session, not just a shell command. It can read files, reason about code, and give you an analysis.

2. BTW has continuity. It maintains a thread. !! is fire-and-forget.

3. BTW can come back. You can inject the thread or a summary into the main session. !! output is gone once you've read it.

Use !! when you need raw command output. Use /btw when you need the agent to think about something on the side.

Get it

elyra update
elyra install npm:@elyracode/btw

Then the next time a "quick question" lands sideways while the agent is busy — type /btw instead of waiting.

Elyra v0.7.15 — changelog