What's new in Ragenta.

One unit, every model

Usage is counted in credits. One credit is one input token of a baseline model, and every model spends credits in proportion to what it actually costs — so switching an agent from a cheap model to a frontier one changes the number, not the unit. Every run shows what it spent, per step.

The free tier is a trial now

New accounts get 20,000 credits once, after verifying their email address, and are not topped up every month. A monthly allowance that never ends is a cost with no end and no reason to ever upgrade. What free is really for — one knowledge base, two agents, one seat, economy models — is unchanged.

• Starter at $9 a month for one person, with widgets, webhooks and triggers
• Pro at $29 per seat, adding API keys, database sources and premium models
• Team at $99 flat for five seats

Buy exactly what you need

Top-up packs remain, and you can now name your own amount from $10 upward. Payment history, downloadable invoices and the date your plan renews are all on the billing screen — including whether it will renew at all.

From a sentence to a graph

The blank canvas was the hard part: seventeen step types and no clue which three the job needs. Type what you want the agent to do and Ragenta drafts the steps, the branches and the connections for you to correct. Nothing is saved until you publish a version, so a draft that lands on top of your work costs you a click to undo, not an afternoon.

• Every draft is checked before it reaches the canvas — an invented step type or an edge that leads nowhere is refused with the reason
• The steps a later one reads from are shown by name, so a prompt can reference them
• Replacing existing work always asks first

Compare versions on one question

You changed the prompt, swapped the model, added a tool. Did it get better? Send the same input to two or three published versions at once and read the answers side by side, with what each one cost. Then publish the winner, or restore what you had.

A chat that shows its work

Answers now stream at a readable pace with a visible ending, hovering a message reveals when it was sent, and a stopped answer says it was stopped instead of just going quiet. When a step fails, the reason is on the step rather than buried in its output.

A chat bubble on your own website

One script tag puts a grounded assistant on your site, answering from your knowledge base. The endpoint is public by design, so it is the most carefully bounded thing in the product: origins are checked server-side against your list, rate limits apply per visitor, and every conversation is billed to your workspace and listed with the questions that were asked.

• Activity log with the real questions visitors asked
• Allowed-origin list checked on the server, not in the browser
• A refusal tells the visitor why, instead of showing an empty bubble

Run without a person present

Put an agent on a schedule, or start it from a webhook. Mint an API key and call it from your own product — a key carries less authority than the person who created it, and every run records which key started it. Outbound webhooks are signed, retried and logged.

Roles a workspace writes for itself

Permissions are answered per resource rather than guessed from a role name, and a workspace can compose its own roles — without being able to compose one it could not hold itself. Denials no longer name resources the asker was not allowed to know exist.

Connected by the person, not by a shared password

An account is connected by its owner over OAuth, so an agent sees exactly what that person sees and access is revoked from their own account settings. Stored credentials are encrypted and never returned by the API — you get a masked hint back, not the secret.

Everything a tool returns is treated as data

A web page, an email, a channel message or a memory that says "ignore your instructions" reaches the model inside a fence it cannot break out of. Tools that change something in the world are marked as such, and approving one is a decision somebody makes.

A prompt is easy to write and impossible to debug

The canvas turns an agent into steps you can see. Ask a model, search the knowledge base, call tools, branch on a category, loop over a list, pause for a human answer — and when something goes wrong, point at the step rather than rewriting the whole instruction.

• Branches are drawn where they actually go
• Problems are named before you can publish, not discovered on a charged run
• Every version is kept, and any of them can be restored

Voice and pictures, in the same conversation

Record a voice note in the composer and it is transcribed before it becomes your question, with the audio still attached to the turn. Attach a screenshot and it reaches a model that can actually see — one that has not declared vision support is not offered for the step.

What a run cost, step by step

Each step records what it was given, what it answered, how long it took and what it spent. A tool call that changes something in the world is marked, and approving it is a decision somebody makes rather than a default.

Upload, and ask

Connect or upload your documents and Ragenta parses the layout, chunks on structure rather than character count, embeds into one multilingual vector space and keeps the result searchable. Scanned pages go through OCR; tables stay tables.

• Vector and keyword search run together, then a reranker decides what reaches the model
• Every answer shows the passages behind it, and which ones fell below the cut
• Vietnamese and English share one index — a question in either finds documents in both

Workspaces, projects and people

A workspace owns its knowledge, its members and its balance. Invite people, put them on projects, and see what each of them is spending.

Usage you can read

Consumption is a ledger, not a counter that can be edited. Every model call is recorded with the model, the tokens and the price in force at the time, and the usage screen adds it up by day, by member and by model.