I built a web-based vector editor from scratch and integrated an AI Agent. Need just ONE beta tester!

Thank you for the incredible, deep insights! Your advice on how to screen and observe the first beta tester is spot on. I'm definitely going to apply these strategies to improve Rayzia. Really appreciate your support!

Done! Just submitted Rayzia to SoftRankings as you suggested. Appreciate the solid advice on targeting solo/product builders — let's see how it goes!

Hey israr034, thank you so much for the kind words and the support! You hit the nail on the head—having truly editable vector paths instead of just flattened SVGs is a game changer for actual design workflows. Really appreciate your support and wishing you all the best too!

Thanks, Arun! 🙏 When you do dive in, here's the one minute worth spending: open the AI panel, ask it to draw something, then grab a node it just made and bend it by hand — that little moment is the whole idea. Would genuinely love to hear what you think.

Good question — and the honest answer is: mostly automation and collapsing intent into execution, not design suggestions.

Plain vector editing isn't hard because you don't know what you want. It's hard because getting there is 40 clicks: draw the shapes, align them, match the palette, name the layers, spin three variants. The AI's job is to erase that mechanical gap. "A 3-card pricing row, aligned, on my brand colors" becomes one sentence, and it operates the real pen/shape/align/recolour tools to build it — as editable objects, not a suggestion you have to redo by hand.

So it's less "here's a design idea" and more "you already know what you want — let me do the tedious 20 minutes." The recolour-to-brand, restyle-a-set, rename-and-organize, spin-safe-variations grind. And because it edits the live file, your taste and judgment stay in the loop — it's an operator, not an oracle. That's the deliberate line: I don't want it deciding whether the design is good, just removing the labour between your idea and a real, editable file.

(And agreed on the single power user — one person running a real project surfaces the exact moment it breaks. Surveys never do.) It's open and free if you ever want to poke it: rayzia.com/vector. 🙏

Totally agree on the specific-workflow point — I'm scripting the first sessions around one concrete task, not "go explore." The one I'd hand a tester, and the clearest speed win, is: take an existing asset, recolour it to a new brand palette, and spin out three on-brand variations.

By hand that's genuinely 20–30 minutes of pure tedium — select a shape, change the fill, repeat, duplicate, restyle, keep them all consistent. With the agent it's one sentence, and you're auditing the result instead of doing the labour. Same for building a structured layout from nothing (a pricing row or icon grid — aligned, grouped, named) and cleaning up a messy imported SVG.

Where it does not win, and I'll say it plainly: a quick one-off shape is faster by hand than typing a prompt. The advantage kicks in the second a task is repetitive, multi-object, or "do this consistently across a set" — which, for real product work, is most of the boring half of the day.

So the test I actually want run is exactly your framing: recolour + variations on a real logo, then hand the still-editable file to a teammate. If that's meaningfully faster and they can take it from there without me, that's the proof point — not a demo render. It's live and free if you want to time it yourself: rayzia.com/vector. 🙏

This honestly made my day — thank you. "Understands the context" is exactly the bet: because it reads the real layers and vectors, it's editing your file, not guessing at a picture. That's the whole reason I didn't just bolt a generator on the side.

Means a lot coming from someone who clearly gets the space. It's live and free if you want to put it through its paces — rayzia.com/vector — and I'd love whatever you find. Shipping Tuesday 🚀🙏

You've named the exact failure mode I built against — the "great for 30 seconds, then you can't touch it" wall. That's the whole reason the agent drives the real editor actions instead of dumping an SVG: the point is that second 31, when you grab a node by hand, actually works.

And that benchmark is sharp — I'm adding it to the beta battery. "Generate 20 icon variations, then refine 3 by hand" is sneaky-good because it stresses both ends at once: the batch has to produce 20 genuinely distinct, named, editable objects (not 20 near-dupes), and then the manual refine is the real test of whether the handoff holds up. If it saved time on the 20 but those 3 are a pain to touch, I've failed the actual promise — and that shows up instantly, exactly like you said.

That "real iteration time vs cool demo moment" line is the exact bar I'm measuring against. It's live and free if you want to run it yourself: rayzia.com/vector 🙏

This is exactly the mental model I built it on — the diff-over-summary instinct is spot on, and it's why the panel narrates every call as it happens: you literally watch createShape → addGradient → setPaint stream in as rows, not a "here's your result" summary. So the "see the sequence, not just the destination" half is already there — plus a History panel where each step is labeled and you can jump to any point.

On undo granularity, let me be precise: today an AI action is designed to undo as one clean unit (one Ctrl+Z reverts the whole thing, not five presses). For your "one shape came out wrong" case, the editable-output half solves it a different way — you don't roll back, you just grab that one wrong shape and fix or delete it directly, since it's a real object, and the visible sequence tells you exactly which call produced it.

But your sharper ask — reject/undo a single call mid-sequence without discarding the rest — is genuinely good, and it's not something I have yet. A per-step "keep / drop this one" control on the streamed calls is exactly what a power tester surfaces that I'd never think to build alone. Adding it to the list. 🙏

Live and free if you want to watch the calls stream: rayzia.com/vector

Thank you — genuinely, this means a lot, and I'm glad the "prompt → edit → prompt" loop clicked for you, because that loop is the whole thesis.

On your questions:

Undo/history for multi-step: each AI action collapses into one clean, labeled step — so a change that touched five shapes is a single Ctrl+Z, not five, and it never gets lumped into one giant blob with your own edits (each AI action and each manual edit is its own entry). There's also a History panel where every step is named, so you can jump back to any exact point instead of only walking back linearly.

The workflow I'm most excited about: honestly, icons and small UI/marketing graphics — the stuff you make in sets and revise constantly. That's where the "generate a batch → recolour to brand → tweak 3 by hand → ask for a variation" loop really pays off. And I'll be straight: pure expressive illustration is less the sweet spot — hand-drawing still wins there. It's the structured, iterative, repetitive work where the agent earns its place.

Really appreciate the kind words and the offer — I'd take detailed feedback any day. Launch is Tuesday, and it's free and open right now if you keep poking. 🙏

Sharp framing — I'll answer the trade-off head-on, because it's the right thing to poke at.

The core isn't skeletal, and that's the key. The editor is a full standalone tool first: pen, node editing, gradients, real OpenType text, ~200 path effects, SVG/PNG/PDF export. It's genuinely useful with the AI panel closed. So the AI isn't propping up a half-built core — the core shipped stable, and the AI is a projection over the same command layer the manual tools use. That's exactly why it can drive createShape/setPaint instead of bolting on a separate generator. Timing-wise that makes it neither premature nor a crutch: your first user gets a working editor regardless, and the AI just removes the boring half.

On who it's for: designers and product folks doing icons and small UI/marketing graphics — structured, set-based, iterate-constantly work. Not fine-art illustrators (hand-drawing still wins there), and not a presentations tool. In that lane the AI is the difference between "nice free editor" and "the thing I reach for," because that's exactly where the recolour / variation / cleanup grind lives.

So, honestly: essential to the positioning, optional to basic usefulness — and I think that's the healthy version of shipping AI at beta, not the premature one. 🙏

Thanks — and these are exactly the questions I'd ask too.

1. Partial failures mid-sequence: every call returns a structured {ok, error}, and ops are serialized (one at a time, never interleaved), so "shape created, paint failed" ends with a real, committed shape and an errored paint call — not a corrupted doc. The agent gets that error back in the loop and can retry or adjust; worst case you're left with a real editable object you finish by hand. The part I obsessed over is the multi-step version — a batch runs under one history transaction, and I hammered the mid-transaction cases hard (long adversarial AI-plus-human interleave runs) specifically so a failure partway never eats prior work or leaves a half-committed undo entry.

2. Runaway loops / cost on BYO key: the biggest lever is that the agent batches — it plans a whole change and sends it as one call instead of a chatty 20-step loop, so cost and loop-risk both drop a lot. On top there's retry-with-backoff on 429/5xx (bounded, honours Retry-After), and since it's your own key, your provider's rate limits and budget are the hard backstop. Fully honest though: a strict per-prompt iteration + token ceiling is the one guardrail I still want to make airtight before this is ever hosted/paid — it's on the list, and exactly the kind of thing I'd love a builder like you to try to break.

Appreciate the sharp questions — good luck to you too. 🙏

Honestly, both — and that's kind of the point. It's not a "generate button," it drives the actual tools, so it sits on either end of the workflow.

Generative side: "lay out a 3-card pricing row," "draw a settings icon," "build a hero with a gradient background and a headline" — it creates the shapes, text and layout as real objects, aligned and grouped, not one flat blob.

The repetitive side is where I think it earns its keep for product work: recolor every shape to a new brand palette, apply the same shadow or corner radius across a whole set, rename and organize the layer stack, align/distribute, swap a component's contents, boolean-merge a pile of paths. The tedious 20 minutes becomes one sentence.

And because it reads the live document first — ids, layers, current styles — it edits what's already there instead of redrawing, so you stay in control and can grab any node the second it stops.

For UI/product work that "kick it off, then let it grind the boring edits" loop is the sweet spot I'd most want your eyes on. No invite needed either — it's live and free at rayzia.com/vector, AI panel's built right in. If you run it through a real project, brutal feedback is exactly what I want before Tuesday. 🙏

This is the sharpest testing note I've had — thank you. "Can they recover, edit and export it without me" is a far better bar than "did it look cool," and I'm going to structure the first sessions exactly like that: import → variations → hand-off, watching for the precise moment trust breaks or someone can't undo their way back out.

To your question — the repetitive task I most want it to replace is the "make this on-brand, now give me a few consistent variations" grind: take an existing asset, recolor it to the palette, normalize the spacing and layer names, and spin out two or three safe variants. By hand that's 30 minutes of tedium and a perfect way to introduce inconsistencies — and it's exactly where "edit the live file, don't redraw" has to earn it. If the agent nails that and the designer hands a clean, still-editable file to a teammate, that's the proof point I care about, not a hero render.

Funny thing is your before/after task is almost a spec for it. If you're up for being that first designer, it's live and free at rayzia.com/vector — I'd take your "here's where I stopped trusting it" notes over a hundred upvotes. 🙏

You just described my launch plan back to me — the whole thing rides on that one cut: prompt in, then a hand reaching over and dragging the exact node the AI just drew. That's the beat I'm leading the video with, because you're right, it's the entire argument in about three seconds.

One place I'll gently push back, though: I went the opposite way on scarcity. There's no gated batch and no signup wall — it's open and free right now at rayzia.com/vector. For a free browser tool, the gap between "saw the demo" and "actually tried it" is the real enemy, and that node-grab moment converts far harder than a waitlist ever could. When I say "first testers," I just mean the people I'll sit with for structured feedback — not who gets in. Anyone can already walk through the door.

Appreciate the positioning eye, though — you clearly think about this stuff properly. 🙏

Really appreciate this — you've put your finger on the exact thesis. Generation is the easy 10%; keeping every node and layer live so you can keep working is the hard part, and it's where most of the build has gone.

Your "where does the agent break down" test is the one I care about most, so honestly:

Precise alignment — the assistant drives the same align/distribute + snapping the manual tools use, on exact coordinates, so it can place things pixel-true rather than "roughly there."
Reusable components — it can create and reuse Symbols (with overrides), so editing the master ripples across every instance.
Revisions on one design — this is the real split from a generator: it edits the live document with full undo history. "Make the roof steeper, recolour the sky, now group it" all land on the same file instead of a fresh render.
I won't pretend it's flawless in beta — those exact prompts are where I'll be watching, and blunt bug reports there are gold.

And the two-question rating idea is genuinely sharp — I'm stealing it. Separating "was the result good?" from "was editing the AI's output faster than drawing from scratch?" is right, because my honest bet is the value is the combination (AI + a real editor), not either alone. The day editing-vs-scratch comes out slower, that's a real signal something's off.

Thanks for actually thinking this through — this is the kind of feedback that shapes the roadmap. 🙏

Thanks — and yeah, "not a black box" is the whole reason it runs on the canvas instead of just piping SVG in and out. If you can't inspect and undo what the AI did, it's really just a slower generator.

Your undo question is the exact part I obsessed over, because you're right — that's where these tools turn to mush. Every agent action is wrapped in one labeled history step. So "restyle these five shapes" is a single undo: one Ctrl+Z reverts all five together — you don't press undo five times, and it also doesn't get lumped into one giant blob with your manual work. Each AI action, and each of your own edits, is its own entry. There's also a History panel where every step is named (Batch / Set paint / Apply effect…), so you can time-travel straight to any point instead of only walking back linearly.

And since AI-and-human edits interleaving is exactly where undo usually breaks, I've hammered on that case hard — running the agent and a human editing the same file back and forth on purpose, so a mid-action undo never eats your work. Still beta, so if you ever catch it dropping a step, that's the #1 report I want.

Great question — it's the one that separates "AI design tool" from "AI image tool," so let me be straight about it.

It edits the existing vector; it doesn't redraw. The agent reads the current file first — object ids, bounding boxes, the actual fills and strokes, the layer tree, even a rendered snapshot — and then acts on those exact objects. So:

"Match my brand colors" is a recolor in place: it walks the existing shapes and swaps their fills/gradients by id. Same geometry, new palette — not a regenerated illustration. Hand it the hex codes and it'll map them across everything.
"Make this icon simpler" runs on the existing path — it can reduce and merge nodes with the real Simplify command, strip decorative bits, or boolean-combine parts, instead of starting over.
And because every change lands on the same objects with full undo, iterating is the normal loop, not the exception — "now warmer, now thinner strokes, now drop the shadow" all stack on the same file.

Thanks! And nice — cost and reliability on top of LLMs is a real pain, so that's a good problem to be chewing on.

On my side, reliability comes mostly from leaning on the client and keeping the surface small:

It's provider-agnostic and BYO-key (Anthropic / Gemini / OpenAI-compatible / a local model), so I'm not a single point of failure sitting between the user and their provider.
Requests are batched — the agent plans a whole change and sends it as one call instead of ten, which cuts both cost and rate-limit exposure.
Calls are serialized and timeout-bounded, with retry + backoff on 429/5xx, so a slow or flaky response degrades gracefully instead of corrupting the document.

Thanks — and you've nailed exactly why I went the MCP route instead of the "here's an SVG blob" approach. The point is the agent uses the same pen, shapes, align and layer tools you do, so the moment it stops, you're already holding an editable file — not decoding someone else's export.

On the parts you want to test:

Multi-step commands land as one action — "add three cards, align them, group and label" is a single labeled undo, not a pile of loose ops you have to clean up.
Complex layouts lean on the real tooling — align/distribute, snapping, symbols for repeated elements, groups and exact coordinates. The agent drives those, so it's placing things precisely, not eyeballing.
Both are exactly where I want more real-world stress, so I'd genuinely value your eyes on it.

No invite needed — I've made it public, so you can jump in right now: rayzia.com/vector. It's free, no signup wall, and the AI panel is built right in — just open it and start asking. Would genuinely love your feedback once you've run it through a real workflow (complex layouts + multi-step is exactly what I want stress-tested). 🙏

Appreciate that — and yeah, "flat, messy SVG" is exactly the wall I didn't want to hit. Watching the agent call createShape and setPaint live on the canvas, then being able to grab any node yourself a second later, is the whole reason it exists.

Good news: no invite needed — I've made it public, so you can jump straight in at rayzia.com/vector. Free, no signup wall, the AI panel's built right in. Raw feedback is exactly what I'm after before launch, so please be brutal with it — send me your email or handle and I'll wire your reports straight to me. 🙏

Awesome! I'd love to have you as the first beta tester. Could you please DM me or drop your email so I can send over the access and details? Looking forward to working with you!

Thanks for the awesome breakdown and questions! Focus on removing tedious design steps is exactly the direction I'm taking. Your tips on setting specific tasks for the tester will be super helpful. Appreciate the support!

That’s the ultimate test of a true collaborative AI! You nailed exactly what makes building Rayzia so challenging yet exciting. Preserving the user's manual edits (paths, layer structures, nodes) while letting the AI iterate on top is indeed the core goal. I’d love for you to put Rayzia through this exact loop during our Beta! Would love to hear how it holds up.

Spot on! Watching where users manually intervene is where the real gold is. For my first beta tester, the number one thing I want to learn is where the 'creative friction' happens. I want to see exactly at what point they feel the AI didn't understand their design intent and had to manually correct it. That gap is where we will find the most valuable features to build next.

Thanks for the awesome feedback, Visiwig! I can definitely make that happen for you. Copy-pasting external SVG graphics/code directly onto the canvas is a fantastic addition for a pro workflow. I'll get to work on this right away. Stay tuned!

Thanks for the awesome feedback, Aryan! You totally nailed it.

That is exactly the core thesis behind Rayzia. Most generative tools today are "one-shot" and leave you with a flat, locked image. I want the AI to act as a collaborative partner on the canvas—where you can prompt it, let it draw, then manually tweak it, and then prompt it again to build on top of your manual edits.

Tracking what users edit manually after the AI finishes is a brilliant suggestion. I will definitely keep a close eye on those patterns during this Beta phase. Thanks again!

Spot on! That’s the exact frustration I had with other tools, and why I took this approach.

Since the agent literally drives the same underlying tools (like drawing shapes and adding gradients step-by-step), it behaves just as if a human designer built it. The layers are generated as native canvas objects, meaning they are fully clean, grouped, and easy to grab, scale, or edit manually.

No messy, autogenerated SVG spaghetti code here.

I'd love for you to put it to the test and break it! Sending you the direct Beta link right away. Let me know what you think of the layer structure.