Copilot

Copilot is the fastest way to build in Solaris AI Flow. You describe what you want in plain English and Copilot composes the workflow: the nodes, the connections between them, and their settings. Before you see anything, it rehearses the draft against real data, flags safety issues, and lays out exactly what it built and why. Nothing lands on your canvas until you accept it, and every change it applies is undoable.

You can start without connecting anything: on Solaris AI Free, builds run on the free Copilot model at no cost to you, within daily capacity limits. For more model choice and capacity, connect your own AI account (log in with ChatGPT or Grok, or add an OpenRouter or Venice key). Calls on your own account are yours: an OpenRouter or Venice key is billed per token by that provider, with a transparent token readout, and a ChatGPT or Grok login draws on that subscription's own usage limits. Solaris AI never adds a charge for Copilot builds.

What Copilot can do

• Build a new workflow from a single prompt, ready to run.
• Compose portfolio rebalancers from a target allocation, on a vetted path with token confirmation and live route checks. See Portfolio rebalancers from one sentence.
• Compose time-sliced DCA plans from a total, a slice count, and a cadence, on the same vetted path, with durable order-by-order progress. See Time-sliced DCA plans.
• Edit the workflow you have open: add nodes, rewire connections, change settings, or fix what's broken, delivered as a reviewable patch.
• Plan before building: in Plan mode it asks clarifying questions and keeps a running requirements list until the idea is solid, then builds it in one click.
• Answer questions about your workflow or the platform conversationally when a prompt doesn't call for a graph.
• Improve its own drafts: one click simplifies structure, removes dead nodes, and swaps in apps you've already connected.
• Fix failing workflows while you sleep: opt a workflow into Auto-fix and Copilot diagnoses persistent failures overnight, then has a repair waiting for your review in the morning. See Self-evolving workflows.

Free tier and your own AI account

With no provider connected, Copilot runs on the free Solaris AI model: the composer shows a Free badge ("Included with Solaris AI") and builds cost you nothing. Free builds share capacity:

• A daily per-account allowance. When yours is spent, Copilot says so: "You've used today's free builds on Solaris AI. Pick another model to run on your own AI key, or come back tomorrow." The allowance resets at midnight UTC.
• A shared platform-wide ceiling. On busy days you may see "Solaris AI's free tier is at capacity for today. Pick another model to run on your own AI key, or come back after the reset at midnight UTC." Both allowances reset at midnight UTC and retrying the same free build won't clear either message before then; a model on your own key is never subject to the shared cap.

Connecting your own AI account lifts both caps and unlocks the full model catalog. Copilot supports four providers:

• ChatGPT - click Log in with ChatGPT and enter a one-time code on OpenAI's site. No API key; Copilot runs on your existing ChatGPT account. Full guide: ChatGPT Integration.
• Grok - click Log in with Grok and enter a one-time code on xAI's site. No API key; Copilot runs on your existing Grok account. Full guide: Grok Integration.
• OpenRouter - one key for hundreds of models, including free ones. Get a key at openrouter.ai and add it on the Connections page.
• Venice - privacy-focused models. Add your key the same way.

When you have more than one connected, a provider switcher appears in the model picker and your choice is remembered. See Credentials for setup details.

Opening Copilot

In the editor, click the Copilot button at the bottom of the left toolbar, or the Copilot AI pill at the bottom of the canvas. On an empty canvas the prompt is front and center: "What would you like to automate?"

Outside the editor, the dashboard has a Copilot prompt bar. Type what you want to automate and it opens a new workflow with Copilot already building it. Workflows in the dashboard's "Needs attention" list also get a Fix button: Copilot opens that workflow and proposes a repair on the canvas, which you review before it applies.

Writing a prompt

Plain language works: "When a wallet I track buys a token, send me the details on Telegram." Be specific about triggers ("every 10 minutes"), destinations ("to Discord"), and conditions ("only if the market cap is under $1M").

Type @ to tag a specific app or node type, like @pumpfun, @telegram, or @loop. Tagging tells Copilot to build around that piece; the browser that pops up lists everything available. If you're out of ideas, Copilot's welcome screen in the editor opens with strategy tiles and a browsable, filterable gallery of example automations; picking one fills the composer with a full prompt you can edit before sending. The dashboard's prompt bar keeps the simpler example cards, where Shuffle deals a new hand.

Build now or plan first

When creating a new workflow, a Build / Plan toggle sits in the composer:

• Build drafts the workflow immediately. Best when you know what you want.
• Plan starts a conversation instead. Copilot asks numbered questions, keeps a "What I've noted so far" checklist across turns, and when the plan has no open questions it offers a one-click Build this plan.

You can also just chat: if your prompt is a question rather than a request, Copilot answers in the thread instead of forcing a graph.

Editing vs. creating

With a workflow open, an Edit / New toggle controls the target. Edit (the default on a non-empty canvas) changes the workflow you're looking at. New builds a separate workflow from scratch. Phrases like "start over" or "new workflow" switch it automatically, and your explicit toggle choice always wins.

Choosing a model

The model pill in the composer opens a full picker: search, sort by Recommended, Cheapest, Largest context, or Newest, filter to Free or Reasoning models, and star favorites. The list is fetched live from your provider, so it always reflects what your key or plan can actually access. Auto lets the server route for you, and a custom model id can be typed directly.

For models that support it, a Reasoning effort control appears: from None to Max, it trades speed for how hard the model thinks before composing. Default keeps the server's conservative setting, which is the right choice most of the time.

What happens when you generate

While Copilot works, a live thinking strip streams its progress, and drafted nodes light up as they take shape. Then comes the part most builders skip: rehearsal. Copilot actually runs the draft against real data before showing it to you. The preview reports it plainly, for example "Rehearsed live: 6 steps ran against real data", and if a step failed or a message rendered raw objects instead of text, it says so, often alongside "fixed 2 issues found in rehearsal."

The preview itself shows:

• The workflow name, node list, and connection count.
• Would have sent blocks with the exact message a Telegram or Discord step would have produced. Nothing is actually sent during rehearsal.
• Tokens involved - any token mint in the draft is verified against Jupiter and shown as a chip with its symbol, market cap, and a Solscan link. Unverified mints are flagged so you can double-check them.
• Assumptions I made and You'll need to provide - values Copilot guessed and fields or credentials only you can supply, editable inline.
• Trading safety and Could be simpler - flags like "a trade fires on every trigger run with no condition gating it" or "2 nodes whose output isn't used by anything."
• A side-effects note: either "Read-only. This workflow only reads data" or a plain statement of what it sends, trades, or spends.
• How I built this - a collapsible trace of every step Copilot took, ending with the token usage line.

Portfolio rebalancers from one sentence

Describe a target allocation and a cadence, and Copilot builds the entire rebalancer on a vetted path with stricter guarantees than free-form composition:

Keep 40% tokenized Tesla, 30% treasuries, 20% gold, 10% USDC, rebalance daily

What the vetted path adds:

• Curated asset grounding. Category phrases like "treasuries", "gold", or "tokenized stocks" resolve through the Tokens.xyz curated catalog, and every proposed mint is then re-verified against Jupiter. The catalog proposes, Jupiter verifies; catalog membership alone never trades.
• You confirm every token. Before anything is built, a numbered card shows each resolved asset: icon, market cap, trust tier, the exact mint with a copy button, and ranked alternates. Reply "confirm", click an alternate, or correct one slot by number ("2: <mint address>"). Nothing compiles while a token is unconfirmed.
• Live route checks. Each asset is quoted against your cash slot in both directions before the trade legs are pinned. If a token has no live swap route (tokenized stocks and ETFs often stop routing outside US market hours), Copilot refuses to build, explains the issuer's market hours, and suggests a verified alternative that trades right now.
• Vetted strategy logic. The rebalancing code is a hash-verified template, not code a model improvised for you. Every guard fails to a hold decision with a reason: missing prices, a low SOL fee reserve, or dust-sized amounts produce a report, never a blind trade.
• One corrective trade per check. Each run measures drift across every slot and fixes the single largest deviation. A far-off-target portfolio converges over consecutive checks instead of firing a burst of orders in one tick, and runs inside the drift band simply hold.

Portfolios take 3 to 8 assets and need a stablecoin slot (usually USDC): sells route into it and buys are funded from it. Two-asset pairs like "70/30 SOL and USDC" trade directly against each other. Trade legs follow the dry-run default above: every run pulls real quotes and reports the trade it would have made until you switch it live.

Time-sliced DCA plans

Ask for a dollar-cost average and Copilot compiles it on the same vetted-template path as the rebalancer: hash-verified strategy code, not code a model improvised for you.

Sell 2 SOL into USDC over 10 orders, one every hour

• A finite allocation, split across 2 to 100 orders (10 if you don't say), one order per tick on a cadence from every 5 minutes to daily (hourly by default). The allocation is an exact amount of the token you're spending or a percentage of your balance, never a dollar figure; a percentage is measured once at the first order and pinned, so selling doesn't shrink every later slice. If you don't state an allocation, the plan works through your entire balance of the spend token. Copilot says so in the compiled assumptions, so check them before you accept; if your prompt names an amount that Copilot couldn't read, it asks instead of defaulting.
• Solana pairs through Jupiter. Every order is a Jupiter swap with slippage pinned at 1%, so the workflow needs your Jupiter connection and your wallet, like any other Jupiter swap.
• Orders size themselves off what is actually left. Each order takes an equal share of the unspent allocation, and the final order squares the books exactly, even with the optional random size jitter enabled.
• Price guards hold, they don't cancel. An order whose quoted price impact exceeds the ceiling (10% by default) is rejected and stays pending for a later tick, and an optional limit price pauses orders while the market is on the wrong side of it. Held orders resume on their own.
• Progress is durable. The order counter and spend record live in Plan Progress, bookkeeping nodes compiled into the graph: pausing the workflow, editing an unrelated node, or a week of held orders resumes exactly where the plan left off, two overlapping runs can't claim the same order, and a crashed run's order is retried on a later tick.
• Simulation only, for now. A DCA plan refuses to run if any node in the workflow executes live transactions; every order is a dry-run swap against real quotes. Live multi-order execution needs order-level reconciliation against the chain and ships when that does; Plan Progress explains why.

A plan is finished when every order has filled, or earlier if the allocation runs out. Finished plans idle on their schedule and report complete rather than erroring. Refining the pair, direction, order count, allocation, or jitter starts a new plan with fresh progress; rescheduling a plan or changing where it reports keeps its progress.

Reviewing, applying, improving

• Create workflow / Apply to workflow accepts the proposal. Applied edits merge into your canvas and are undoable with Cmd+Z; Copilot also saves a restore point of the pre-change graph to Version History first.
• Discard throws the draft away.
• Improve (on new drafts) makes Copilot critique its own work. A "What I improved" summary lists what changed, like "Removed 2 unnecessary nodes" or "Swapped Birdeye for GMGN (one you've connected)". If there's nothing to simplify, it says "Couldn't simplify further" rather than churning your draft.
• Not happy? Type a follow-up: "make it every 10 minutes", "@discord too". The send button becomes Refine and the draft evolves in the same thread. Thumbs up/down on any proposal helps us tune quality.
• Stop (the send button while running) halts a generation immediately. No orphaned runs, no wasted spend.

Self-evolving workflows

An automated workflow that starts failing usually stays broken until you notice, open the run log, and debug it yourself. Auto-fix closes that gap: Copilot watches the workflow's automated runs, and when a real failure streak develops it diagnoses the problem overnight and drafts the repair before you're awake.

Turn it on per workflow: open the notification bell, go to Notification settings, and flip the Auto-fix switch next to any workflow under Automated workflows. Any workflow with a schedule, webhook, or wallet activity trigger qualifies; there's no minimum cadence. Overnight fixes are not covered by the free tier: they generate on your own connected AI account, and if no provider is connected, Auto-fix waits until one is.

What counts as a failure streak

Copilot checks each opted-in workflow once a night, and it's deliberately hard to trigger:

• Only automated runs count. Manual runs and "Run once now" are ignored, so a debugging session never makes healthy automation look broken.
• At least 2 of the recent automated runs must have failed, and the most recent run must itself be a failure. A workflow that already recovered gets no suggestion.
• Only runs of the current version of the graph count. If you've edited the workflow since the failures, Copilot assumes you may have fixed it and stays quiet.

When all of that holds, Copilot reads the failing node and its error, then generates a repair against your saved graph - the same reviewable patch an interactive "Fix with Copilot" request produces, just prepared while you're away.

Reviewing the fix

When the proposal is ready you get a "Copilot prepared a fix" notification in the bell, and on Telegram or Discord too if you've connected them in the same Notification settings dialog. Clicking it opens the workflow with the proposed change already on the review screen: the same preview, diff, and Apply / Discard controls as any other Copilot edit, with a restore point saved to Version History before anything merges.

Opening a ready proposal costs nothing - the fix was already generated overnight. And the suggestion re-checks itself when you click:

• If the workflow recovered on its own since the notification, the editor just opens plain. Nothing is proposed and nothing is spent on an obsolete diagnosis.
• If the workflow is still failing but the overnight draft no longer fits - you edited the graph after it was drafted, or the proposal expired (unreviewed proposals are kept for 7 days) - the stale draft is retired and Copilot generates a fresh fix on the spot instead. That's a normal interactive generation, run on your account while you watch.

Two quiet behaviors worth knowing: if you click the notification while a Copilot generation is already running on that workflow, the suggestion steps aside rather than interrupting it - let the run finish and click again. And if an overnight generation itself fails (an expired login, a provider outage), you're not notified about anything; Auto-fix simply tries again on a later night.

Threads, history, and memory

Drafts survive closing the rail, reloading the page, and coming back later. Past builds in the rail header lists your recent threads (kept for 7 days), and New build starts fresh without deleting the old thread.

Under Copilot settings there's an optional, off-by-default memory: Remember my workflows grounds new builds in workflows you've previously accepted. It runs on your own OpenRouter key, which embeds each workflow when you accept it and each new request when matching: without an OpenRouter key nothing is captured, and builds on the free model skip memory grounding entirely so they stay free. It's kept about 90 days unless reused, and Forget everything wipes it on demand.

Troubleshooting

• "The copilot runs on your own AI account" - no provider is connected and the free tier is not currently available, so the composer is locked. Log in with ChatGPT or Grok, or add a key; it unlocks the moment a credential resolves.
• "You've used today's free builds on Solaris AI" - your daily free-build allowance is spent. Pick a model that runs on your own key (connect one in Connections if you don't have one), or come back after the reset at midnight UTC. Retrying the free model won't help until then.
• "Solaris AI's free tier is at capacity for today" - free builds across all of Solaris AI hit the shared daily ceiling, which also resets at midnight UTC. Until then, pick a model on your own key, which the shared cap never applies to.
• "Generation failed. Try again, or pick a different model." - some models are poor at structured composition. When the free model is briefly unavailable, builds fall back to a rotating pool of $0 models whose quality varies per request and which rate-limit aggressively; switching to a model on your own key via the picker resolves most failures.
• "ChatGPT session expired. Reconnect it in Connections." (or the same message for Grok) - device logins expire eventually. Reconnecting restores the same credential so nothing else needs to change. See ChatGPT Integration or Grok Integration.
• "No changes proposed. Try rephrasing the request." - in Edit mode, Copilot couldn't map your request onto the current graph. Name the node or app you mean, or tag it with @.

Copilot can make mistakes. The rehearsal, previews, and dry-run defaults exist so you catch them before they matter: review your workflow before running it live.