QuiverAI Launches Arrow 2: Generating Vector Graphics with Code, Independent Editing for Every Shape, and Micro-Animations

Mainstream generative AI models almost exclusively "paint pixels": they output raster images (such as JPG or PNG) composed of thousands of colored squares. Zoom in on these images, and their edges blur; furthermore, all visual elements are flattened together. A designer wanting to reposition a single leaf or a front-end engineer needing to tweak an icon's stroke weight cannot edit them directly.

QuiverAI's next-generation vector generation models, Arrow 2 and Arrow 2 Telos, follow a fundamentally different technical path: generating structured vector graphics (SVG) directly in code. Scalable Vector Graphics (SVG) is an XML-based format that describes geometry. Instead of recording pixels, it records mathematical equations for points, lines, polygons, and curves. Consequently, generated graphics can be scaled indefinitely without loss of fidelity, and every shape, stroke, and layer remains independently editable in vector design software or code.

Alongside the models, QuiverAI launched an updated App combining conversational generation with a canvas editor, as well as a standalone developer platform. The billing model has also shifted: Arrow 2 and Telos use token-based billing rather than the fixed price per SVG charged by the Arrow 1 series.

Why Vector Graphics Cannot Rely on Auto-Tracing Pixels

In traditional design workflows, converting a raster image into a vector graphic typically relies on a design tool's built-in auto-tracing (Image Trace). This approach relies on algorithms fitting paths along color boundaries in the pixels. Even minor edge noise can spawn a chaotic cluster of fragmented anchor points.

Anchor points and control points are the foundation of vector graphics: anchor points determine where geometric paths turn, while control points (Bézier handles) determine the curvature and direction of curves. From a design engineering standpoint, fewer and more consistent control points yield cleaner, smoother lines. When a path is cluttered with redundant points, file sizes balloon, and designers must manipulate each point individually when manually adjusting contours.

M17.5 81.1L18.1 74.4L18.2 68.9L17.9 63.4L19.4 57.5L21.6 51.3L25.1 48.2L27.4 42L32.2 39.5L35.9 34.1L41.1 29.6L45.3 26.9L48.2 23.6L53.5 22.9L58.3 20.2L64.8 18L69.9 16L74 15.5L81.1 15.7L85.5 16.2L85.4 21.1L85.3 27.8L82.6 33L81.7 39.1L80.2 42.8L78.5 47.4L74.3 53.8L70.6 57.7L66.9 62.4L65 66.1L61.3 69L56.5 73L51.6 75.4L47.4 79.1L41.2 80.2L34.7 81.7L30.5 83.3L25 81.8Z

M18 82C14 40 52 14 86 16C84 52 58 86 18 82Z

In its early stages, the QuiverAI team published vector generation research including StarVector and RLRF. Their core product logic frames visual representation as a programming challenge: training large language models to write valid, standard SVG tags and Bézier curve parameters directly. Arrow 2 emphasizes not pixel-level resemblance, but building maintainable design assets through clean, concise, and precise code nodes.

How Arrow 2 and Telos Differ

QuiverAI released two models, differing in positioning, context window, and pricing:

Arrow 2: The flagship workhorse balancing quality and speed. Designed for standard icons, standalone illustrations, flat UI assets, and the vast majority of everyday design exploration. It features a context window of 131,072 tokens and a maximum output limit of 65,536 tokens per request.

Arrow 2 Telos: A long-context, high-fidelity variant designed for complex creative tasks. Telos expands the context window to 1,050,000 tokens (roughly 8x that of Arrow 2), with the same single-request output limit of 65,536 tokens.

QuiverAI describes Telos as combining Arrow's speed, taste and infrastructure with the refinement capabilities and depth of frontier models. However, which company's frontier model is used and how the models are combined have not been disclosed.

In terms of pricing, every token tier for Telos is 50% more expensive than Arrow 2. Telos is suited for tasks involving large diagrams with multi-layered structures, intricate geometric drafts, or scenarios requiring extensive design system documentation or complex multi-image references. For bulk generation of basic icons or cost-sensitive pipelines, Arrow 2 remains the more practical baseline.

Quality, Speed, and Official Examples

QuiverAI claims Arrow 2's quality gains focus on two areas: fewer, more precise control points, alongside more refined spacing, margins, and alignment between elements. However, the company has not published quantitative benchmarks, such as standardized evaluation suite scores or node count statistics; all examples featured in blog posts and social media are cherry-picked showcase assets.

Regarding generation speed, the official blog and tweets offer only qualitative descriptions like "faster." The sole quantitative claim appears in the launch-film narration: "Arrow 2.0 is five times faster" (5x faster)—without clarifying whether the baseline is Arrow 1.0 or Arrow 1.1, or under what test conditions.

QuiverAI's official blog showcases four categories of examples:

Given the reference portrait on the left, Arrow 2 generates four new character portraits maintaining consistent color palettes and geometric styles

Style Continuity and Multi-Character Generation: Given a single reference illustration, the model extracts its color scheme, shading facets, and facial drawing rules to batch-generate cohesive character portraits, facilitating rapid creation of matching asset sets.

A muscular line-art illustration highlighting targeted regions such as the shoulder deltoid in red while keeping surrounding bones and muscles in black-and-white line art

Spotlighted Diagrams: In technical and medical illustration, the model can visually emphasize specific geometric regions according to text instructions—such as highlighting the shoulder deltoid muscle in red with visible internal fiber strokes while keeping adjacent anatomy as black-and-white line art.

A jacket line drawing generated from fashion prompts, clearly displaying zippers, paneling, and seam construction

Apparel and Industrial Line Art: Fashion technical flats require clean lines and structural symmetry. The generated drawings reliably depict varying collar styles, pocket placements, diagonal zippers, and seamlines, enabling designers to extract patterning logic directly.

A hand-drawn pencil mask sketch on the left converted into the vector graphic on the right, with its outer contour defined by only a few dozen key anchor points

Sketch Vectorization: Converting paper sketches or standard raster images into vector code. When a hand-drawn mask sketch is vectorized, outer contour anchor points fall predominantly on corners and curvature inflection points, avoiding the cluttered paths caused by edge noise.

Less than a day after launch, Justine Moore shared a 23-second screen recording on X. She is a partner at a16z, the firm that led QuiverAI's $8.3M seed round, making this an investor hands-on demo rather than an independent evaluation. She praised the new model as "remarkably good at generating detailed SVGs" and noted it was "very fun to watch it draw," feeding various product photos to the model for vectorization. In the clip, she pasted a photo of a $3,200 cropped puffer jacket from Miu Miu's official site into the App, typed the prompt "puffer jacket", and selected Arrow 2 Telos. On the canvas, the SVG materialized piece by piece—first the sleeves, then the body and hem, and finally the quilted stitching, white piping, stand collar, zipper, pockets, and drawstrings—concluding with a side-by-side comparison between the original photo and the generated SVG.

From the final comparison, the stand collar, diagonal shoulder white piping, dual zippered pockets, hem drawstrings, and ribbed cuffs were all rendered. The color was noticeably lighter and more purple than the original deep navy, and the jacket's quilted grid was simplified and made more uniform. While this curated demo provides an intuitive look at the "photo → editable vector graphic" workflow and level of detail capture, it cannot substitute for objective success-rate or stability data. The video does not disclose how long generation took or how many tokens were consumed.

Canvas Workspace and Micro-Animations

The updated App consolidates generation and editing into a unified workspace: users describe what they want in plain language, iterate back and forth via conversation, and fine-tune assets on the canvas. Every creation is an editable SVG that can be exported outside the App.

The updated App: the left chat panel is about to send "Delete all the clouds", while a cloud is individually selected on the right canvas

Inside the App, the left side houses the chat panel while the right side features the SVG canvas. To remove clouds from an illustration, for instance, users can either select the cloud directly on the canvas or type "Delete all the clouds" in the chat.

The same screen recording reveals the App's model picker: offering Arrow 2 and Arrow 2 Telos, alongside an "Effort" parameter (representing reasoning depth), which was set to Medium in the demo. Hovering over Telos reveals a tooltip: "Excels at complex SVG creations and drains usage much faster.", along with a "Usage based" label. Neither the official blog nor developer documentation specifies how many Effort levels exist, how they differ, or how much more quota Telos consumes compared to Arrow 2 within the App.

Arrow 2 can also add micro-animations to static SVGs, bounded by clear constraints:

• Micro-animations apply to existing shapes: The model does not generate video clips from scratch; instead, it animates existing shapes and groups (Group) within the SVG, outputting web-ready animated SVGs.
• Best suited for UI micro-interactions: Ideal for flat graphic elements such as line-drawn logo reveals, loading states (Loading State), rising steam above a coffee cup, or blinking icon eyes.
• Not an entirely new capability: QuiverAI's earlier MCP tools already included features for animating existing SVGs. Arrow 2 primarily productizes this capability and integrates it into the new models and web editor.

In the blog's animation examples, four vignettes play simultaneously: an owl winking and swaying, steam wafting from a cup, a monogram logo outlining before filling in, and a set of fine-line geometric panels subtly morphing. Only pre-existing elements move, and there is no camera motion across the canvas.

Billing: New Models Charge by Token, Not per SVG

For developers integrating Arrow 2 into production workflows, the billing structure is the most critical change to understand.

The Arrow 1 series charged fixed per-graphic rates: Arrow 1.1 costs $0.20 per generated SVG and $0.15 per vectorization. These legacy models remain on the pricing schedule.

Arrow 2 and Telos have no fixed per-SVG price, billing purely on token usage:

How Much Does a Graphic Actually Cost?

The pricing documentation provides a sample calculation: a request consuming 10,000 uncached input tokens and 2,000 output tokens costs $0.08 on Arrow 2 and $0.12 on Telos.

This is merely an illustrative calculation and does not reflect the average cost of generating an SVG. QuiverAI has not disclosed how many tokens an average SVG requires.

Projecting from official rates:

• Looking at output alone: Arrow 2 outputs cost $20 per million tokens, meaning 10,000 output tokens cost exactly $0.20—matching Arrow 1.1's fixed rate per SVG. Telos outputs cost $30 per million tokens, reaching $0.20 at about 6,700 output tokens.
• The official example (10,000 input + 2,000 output) costs $0.08 on Arrow 2 and $0.12 on Telos, both cheaper than Arrow 1.1's $0.20.
• Single-request output limits are capped at 65,536 tokens: at full capacity, output costs alone reach approximately $1.31 on Arrow 2 and $1.97 on Telos.
• When using the Responses API for multi-turn tool calling, each turn is billed independently as described above, and the final cost is the sum across all turns.
• Whether costs are high or low depends entirely on your actual token consumption (including reasoning tokens), a metric QuiverAI has not published; actual consumption per request can be audited in the API platform's Usage and Logs tab.

In production, three engineering rules must be accounted for in budgeting:

1. Reasoning tokens count toward output: Models reason before generating vector output, and all reasoning tokens are billed at the standard output token rate (with no duplicate fees); streaming outputs reveal this reasoning step in real time.
2. Multi-turn tool calls bill per invocation: In agent workflows where a model iteratively refines assets via tools, each separate HTTP request incurs independent token charges, meaning a finalized drawing may accumulate costs across multiple runs.
3. Pre-authorization hold mechanism: For token-billed requests, the system temporarily holds $1 of available account balance before processing. Once complete, actual token charges are deducted and unused funds released. If balance is insufficient to cover the hold, the endpoint may throw a 402 error before execution begins.

App Subscriptions and API Credits Are Strictly Segregated

The App and API operate on entirely separate ledgers:

• App subscriptions cannot credit API calls: The App offers three subscription tiers: Go ($8/month), Basic ($20/month), and Pro ($40/month), which include $5, $15, and $40 in weekly in-app credits, respectively. These credits reset every Monday (UTC) and do not roll over; they can only be used inside the App and cannot fund API calls.
• API calls require separate prepaid deposits: Developers calling the API must fund an independent prepaid balance on platform.quiver.ai, with a minimum initial deposit of $10 and a 1-year expiry on loaded funds.

Developer Integration: Choosing Between Two Interfaces

For developers, Arrow 2 offers two integration pathways: the native /v1/svgs/* endpoints and the Open Responses-compatible /v1/responses interface.

For single-shot "prompt to SVG" or "image vectorization" tasks, calling the native POST /v1/svgs/generations is the most straightforward option. It supports reference images (via Base64 or public URLs), and setting stream: true streams three consecutive Server-Sent Events: reasoning, draft (draft rendering), and content (final SVG output).

If you want Arrow 2 to invoke custom tools within an agent workflow, use the Responses API:

Standard SDK Compatibility: Supports integration via the Vercel AI SDK's @ai-sdk/open-responses extension, or directly via OpenAI's official JS/TS SDK by pointing baseURL to https://api.quiver.ai/v1 and invoking client.responses.create.

Client-Side Tool Calling: Developers can declare functions supported by their host application (such as a write_file utility) within the request. Arrow 2 can decide when to trigger tools across multi-turn exchanges and return structured parameters.

Strictly Stateless Architecture: QuiverAI's Responses API does not persist conversation history and accepts no parameters to store session state. To enable multi-turn adjustments or continue generation following tool execution, the client must explicitly pass the entire message history, tool parameters, and execution results back in the context array.

The launch film narration notes: "Watching what people created with QuiverAI changed how we built our model Arrow. Every generated illustration, every icon, every technical drawing helped our model." However, specific training methodologies were not disclosed. On the API platform, organizations can toggle an "Improve QuiverAI" setting (authorizing the use of eligible organization data to improve QuiverAI), editable by an Owner or Admin; default settings are not specified in documentation. Available materials do not include data-usage terms for App subscribers.

Which One to Pick: A Checklist

• How complex is the graphic, and what are the precision requirements? For graphics with relatively few elements—such as basic icons, logos, and flat illustrations—official documentation recommends Arrow 2 as the default choice. If Arrow 2 outputs exhibit misaligned details or tangled paths, or if you are producing dense illustrations, tight geometric logos, or technical flats where precision takes precedence over speed, switch to Telos (50% higher unit price across all token tiers). Using Telos for routine graphics simply incurs unnecessary expense; conversely, forcing Arrow 2 onto intricate assets requiring extreme precision may fail to meet delivery standards.

• How large is the input payload for a single request? Evaluate the combined volume of design specifications, brand guidelines, and reference assets needed for the prompt. If the payload exceeds Arrow 2's context ceiling of 131,072 tokens, Telos—with its 1,050,000 token capacity—is the only viable option. If the payload fits comfortably within Arrow 2's window, context size alone does not warrant upgrading to Telos. Payloads exceeding the limit cannot fit into Arrow 2; opting for Telos when not needed incurs a 50% pricing premium.

• Does your budget accommodate variable token-based billing? Benchmark real-world prompts on the API platform first, monitoring actual token usage per graphic in the Usage and Logs dashboard. Based on official pricing, once Arrow 2 output (including reasoning) hits 10,000 tokens, the output cost alone reaches $0.20—matching the cost of a single Arrow 1.1 generation—before factoring in input costs. Arrow 2 is only cheaper than Arrow 1.1 when token output remains significantly below this threshold. If your pipeline demands absolute price certainty per graphic, remaining on the fixed per-SVG rate of Arrow 1.1 is advisable. Migrating fully to Arrow 2 without testing risks unexpected budget overruns; however, staying on Arrow 1.1 locks you out of the new model's SVG editing and micro-animation features.

• Is this a single-shot generation or an agent invoking host tools? For fixed "text to SVG" or "image vectorization" requests, the native /v1/svgs/* endpoints are simpler and more direct. Reserve the /v1/responses interface for agent workflows requiring Arrow to call your own tools, and always set a maximum turn ceiling. Using the Responses API for simple tasks introduces unnecessary integration overhead and state management complexity; in agent loops without turn limits, each successive tool invocation is billed separately, easily causing cumulative API costs to spiral.