Key facts
| Function calling | Live for glossary lookups, term validation and QA checks |
| Models | 30+ models including multilingual tiers; route by language and content type |
| Embeddings | plugsky-embed-multilingual is live for terminology and translation-memory retrieval |
| Pipeline | Detect, retrieve terms, translate segments, verify, deliver |
| Governance | Scoped keys and audit logs for every translation action |
| Pricing | Flat monthly self-serve plans with no per-token charges on self-serve |
| Free tier | plugsky-micro and plugsky-lite on the free plan, no card required |
| Roadmap | The batch endpoint is coming soon; translate in bounded-parallel workers today |
TL;DR
- Split translation into detect, retrieve terminology, translate, verify.
- Expose the glossary as a tool so terms are fetched, not guessed.
- Translate segment by segment and keep an audit trail per segment.
- Run a separate QA pass for numbers, names and untranslated text.
- Route by language pair and content type instead of one model for all.
How it works, step by step
- Ingest source content as segments with ids so every unit can be tracked through the pipeline.
- Detect language and domain per segment, then select the target locale rules.
- Expose glossary and translation-memory lookups as function tools the agent can call.
- Translate each segment with approved terms injected and placeholders preserved.
- Run a verification pass that flags missing terms, broken placeholders and numeric mismatches.
- Route flagged segments to a human reviewer with the source, draft and glossary side by side.
- Publish only after review and write the approved pairs back to translation memory.
Try it yourself
Open the best-model-for-agents selector →
The agentic translation loop
A single prompt can translate a paragraph, but production localization needs process. The agent version breaks the job into stages that can each be checked: detect the language and domain, retrieve approved terminology for that domain, translate segment by segment with those terms pinned, then verify the output before it ships. Each stage is a model call or a tool call, and each artifact is stored so a reviewer can see exactly what happened.
Function calling makes terminology an explicit step rather than a hope. Instead of telling the model to keep a glossary in mind, you expose a lookup tool and require the agent to fetch the approved term for each flagged string. When the glossary is wrong, that is a governance fix, not a prompt-tweaking session.
Glossary, tone and locale tools
Build small, strict tools around the assets localization teams already maintain:
lookup_term(source, locale, domain)returns approved translations with status.lookup_tm(segment)returns fuzzy matches from previously approved pairs.check_placeholders(text)verifies that variables, tags and numbers survive translation.style_check(text, locale)flags tone and formality mismatches for the locale.
Design segments so a translation unit expresses one idea. Segment-level work is easier to review, cheaper to retranslate after a fix, and safer to reuse than whole documents.
Verification, review and routing
The verification pass is what separates a demo from a pipeline. Have the agent re-check its own draft against the source for omissions, untranslated fragments, broken placeholders and numeric drift, and route anything uncertain to a human. Reviewers should see source, draft, glossary status and QA flags together, and approved pairs should flow back into translation memory automatically.
Route by language pair and content type: product strings and UI labels are short and terminology-heavy; marketing copy needs stronger prose; legal text needs the strongest tier and a human sign-off regardless. Measure quality with your own reviewers rather than a single score, and build the first version on the free plan with plugsky-micro and plugsky-lite before scaling to paid tiers or the 14-day full-access trial.
Honest comparison
| Concern | Translation agent on Plugsky | Single translate prompt | Traditional MT vendor |
|---|---|---|---|
| Terminology | Glossary fetched by tool call | Prompted, often ignored | Dictionary configured per account |
| Process | Detect, retrieve, translate, verify | One pass | Fixed pipeline |
| Review | QA flags plus human workflow | Manual spot checks | Vendor QA process |
| Audit | Per-segment logs and tool calls | Prompt history | Vendor reporting |
| Model choice | 30+ models behind one API | One model for everything | Vendor engine only |
Frequently asked questions
Why use an agent instead of a single translation prompt?
An agent can split work into checkable stages: detect the language, fetch approved terminology through tools, translate in segments and verify the result. Each stage produces an artifact you can review, which a single prompt does not.
How does the agent respect our glossary?
Expose the glossary as a function tool and require a lookup for flagged terms. Approved terms are injected into the translation step, and glossary gaps become a governance task rather than prompt guesswork.
Which models should handle which languages?
Route high-volume pairs to cheap multilingual tiers, reserve stronger models for complex or high-visibility content, and evaluate per language pair because quality varies by direction. All 30+ models are behind one endpoint.
Can the agent reuse previous translations?
Yes. Store approved pairs in translation memory, retrieve fuzzy matches with embeddings, and let the agent prefer them so consistent phrasing accumulates over time.
How do you catch broken placeholders?
Run a deterministic check tool on every segment and a verification model pass that compares source and draft. Flag placeholders, tags and numbers for human review before publishing.
Is the batch endpoint available for large jobs?
Not yet — batch is coming soon. Today, run translations in bounded-parallel workers with retries, and keep a queue so a provider hiccup does not lose work.
What stays in our systems?
Terminology, translation memory, review workflow and audit records stay in your stack. Plugsky handles the model calls; deployments can run in our cloud, your VPC, on-prem or air-gapped.
Can I start without a card?
Yes. plugsky-micro and plugsky-lite are on the free plan with no card, and a 14-day full-access trial covers stronger models for a pilot.