> For the complete documentation index, see [llms.txt](https://infinitode-docs.gitbook.io/documentation/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://infinitode-docs.gitbook.io/documentation/faqs/questions-about-ais.md).
# Questions about AIs
This page provides an overview of our AI models, and other AI-powered products, including usage, accuracy, and other guardrails.
{% hint style="info" %}
Our models are small and trained for one narrow task each, so they are fast and predictable on data like their training set — and quietly wrong on data that isn't. Treat a low-confidence classification, or a name that makes no sense, as the model telling you your input is outside what it knows.
We do not publish general chat or essay-writing models, so don't point these models at open-ended language tasks.
{% endhint %}
Can AI models' outputs be used for commercial purposes?
Yes. Our AI models' outputs may be used for commercial purposes, but this can differ for some of the AI models we offer, be sure to read their **usage instructions** before use. We try to avoid using copyrighted or licensed content in our data.
What measures are in place to prevent misuse of the AI models?
Most of what we publish returns a label or a number — a crop recommendation, a spam flag, a predicted price — so there is very little surface for abuse, and those endpoints don't run any text filtering at all.
Filtering is applied per product, only where free text is involved:
* **Dungen** takes `seedText` as the literal starting point of a generation, so an NSFW word in the seed would carry through. Seed text is therefore screened with our open-source [ValX](https://github.com/Infinitode/ValX) package first, which blocks most of that.
* **Dungen Dev** has no seed to continue: the `prompt` steers the generation directly and strongly, so the prompt is screened with ValX before anything is generated.
* **KaosGen** also runs ValX on the prompt, but its output is less tied to the exact wording, so it's unlikely to surface NSFW text at all.
* **No model we publish was trained on NSFW data** — the generators and the classifiers genuinely don't know that content. ValX and the hate-speech detector are the only components trained on it, because detecting it is their job.
These checks aren't foolproof and they aren't in the model files you download. Check each model card before you ship anything user-facing.
How are the AI models trained and what data is used?
The training process and data vary heavily depending on the specific model. However, all of our models are trained exclusively on data that is licensed, in the public domain, or available under Creative Commons licenses. We maintain strict data governance to ensure ethical and legal compliance.
Can I fine-tune a base model with my own data?
Fine-tuning isn't available for our closed-source models. For the open-source ones, though, most of our models don't really need it: the OPEN-ARC models are scikit-learn artifacts, so the normal move is to **retrain rather than fine-tune** — open the notebook linked from the model card, swap in your own dataset, and train again. That's usually quicker and cleaner than trying to nudge a small model.
The PyTorch upscaler is MIT-licensed, weights included, so continuing its training is open to you too. Keep in mind that training data carries its own terms: DIV2K, for example, is distributed for academic research use, and an MIT license on the weights doesn't change that.
Are the base models freely available for distribution?
It depends. Models in [**our GitHub**](https://github.com/Infinitode/) repositories, are often available to learn from, and use freely, provided that the terms in the **Model License File** are met. However, this might not be true for other models, that are used in our products, or production environments.
How do I choose the right AI model for my project?
Start from the shape of your data, not from a model name. Our published models are single-purpose: tabular classifiers (crop recommendation, plant stress, traffic accidents, mushrooms, personality traits), a text classifier for spam mail, a tabular regressor for housing prices, a name generator, and an x4 image upscaler. If one of those is exactly your problem, you can use it as it is.
If it isn't, don't bend a model to a job it wasn't trained for — start from an [OPEN-ARC](https://github.com/Infinitode/OPEN-ARC) notebook and train on your own data. Each model card lists its metrics, training data and limitations; read those before you decide. Separately, note that "experimental" in our docs always refers to an **API** flagged `#Experimental`, never to a model.
What should I do if an AI model produces biased or inappropriate content?
Report it to our support team with specific examples — the input you sent and the output you got. That's how these things get fixed.
Keep the expectation in proportion: our generators are screened at the input, as described under "What measures are in place to prevent misuse of the AI models?", and no model here was trained on NSFW data, so genuinely explicit output is rare. A bland, odd, or confidently wrong result is not a safety failure — it's a small single-purpose model outside its training data, which is what the model cards warn about.
Can AI models handle multiple languages?
No, not at the moment. Every model we publish on Hugging Face was trained on English-language data, and the model cards are tagged `en`. Feeding another language in produces a confident, wrong answer rather than a graceful failure.
We don't expose a language parameter, and there's no multilingual variant to ask for. If you need another language, the practical route is to keep the architecture and retrain: the [OPEN-ARC notebooks](https://github.com/Infinitode/OPEN-ARC) ship with the training code, so swap the dataset for one in your language.
How do I evaluate the quality and accuracy of AI model outputs?
Always validate AI outputs against your requirements and use cases. Implement human review processes for critical applications, use multiple samples to test consistency, compare outputs with known good examples, and establish quality metrics specific to your use case.
Each model card reports the number it was tuned on — accuracy or F1 for the classifiers, price error for the regressor, PSNR for the upscaler. Treat that as a baseline to beat on **your** data rather than a guarantee: the numbers come from the held-out split used in each training notebook, so real-world input can score lower. PSNR in particular rewards smooth, faithful reconstructions, so the upscaler can look less "sharp" than a GAN-based one while measuring better.
Are there content filtering options available for AI outputs?
Filtering sits on the products that handle free text, not inside the model files, and not on every endpoint. Dungen screens its seed text with ValX, and Dungen Dev and KaosGen screen their prompts — the classification and regression models have nothing to filter, because they return a label or a number rather than prose.
Two practical consequences. If you download a model, fine-tune one, or host it yourself, no filters come with it: that part is yours to build. And if you want the same checks in your own app, ValX is open source and free to run (`pip install valx`) — `detect_profanity`, `remove_profanity`, `detect_hate_speech`, plus PII detection and removal. See the [ValX package documentation](https://infinitode-docs.gitbook.io/documentation/package-documentation/valx-package-documentation/).
Can I use AI models for creative writing and content generation?
For naming, yes — for prose, no. The only text we generate is names: the [Terraria Weapon Name Generation model](https://huggingface.co/InfinitodeLTD/TWNGM-OPEN-ARC) on Hugging Face is our published open-source example, and the [Fantasy Name Generator API](https://infinitode-docs.gitbook.io/documentation/api-documentation/fantasy-name-generator-api-documentation) is the hosted endpoint for that kind of work. Good for characters, items, factions, places. It won't write a paragraph, and it isn't trying to.
For the rest of a creative project, pair it with our other endpoints — the [Lorem API](https://infinitode-docs.gitbook.io/documentation/api-documentation/lorem-api-documentation) for placeholder copy, the [Name Generator](https://infinitode-docs.gitbook.io/documentation/api-documentation/name-generator-api-documentation) and [Username Generator](https://infinitode-docs.gitbook.io/documentation/api-documentation/username-generator-api-documentation) for more naming — and write the actual text yourself. Several free [Experiments](https://infinitode.netlify.app/experiments) do the same kind of work in the browser, with no API calls needed.
What's the difference between using AI APIs versus downloading open-source models?
Our AI APIs provide hosted, scalable access with built-in safety measures, automatic updates, and no infrastructure management required. Open-source models offer more control and customization but require your own hosting, maintenance, and implementation of safety measures. Choose based on your technical resources and customization needs.
How do you ensure data privacy when using AI models?
We take data privacy seriously. Input data is processed securely via HTTPS, and we don't store personal information from API calls beyond what's necessary for processing. Selected account fields — including your account email, name, API keys and plan identifiers — are encrypted at rest with authenticated encryption.
The [30-day call history](https://infinitode-docs.gitbook.io/documentation/api-documentation/keeping-your-api-key-safe#see-what-your-keys-were-used-for) on your account page is metadata only — endpoint, method, status, and whether the call used an API call — never your request parameters or the model's output, which is why it's safe to share with support. Anything you run in an [Experiment](https://infinitode.netlify.app/experiments) is a step further again: those tools have no server backend, so your data never leaves the browser.
That said, avoid sending sensitive personal information through AI APIs as a general best practice.
Can AI models be integrated into real-time applications?
Yes, many of our AI models are designed for real-time use cases. Response times vary by model complexity and current load. For real-time applications, consider implementing appropriate timeout handling, caching strategies for repeated queries, and fallback mechanisms for high-availability requirements.
What industries and use cases are your AI models designed for?
Our models are research-grade tools aimed at narrow, practical decisions rather than whole-industry platforms. In practice that means agriculture (crop recommendation, plant stress), road safety research (traffic accident prediction), food safety and mycology (mushroom classification), behavioural and psychometric experiments (basic personality prediction), email and content security (spam classification), property and market analysis (housing price regression), game and design tooling (name generation), and image enhancement (x4 upscaling).
If you're evaluating one for a business workflow, the honest framing is: these are small, fast, interpretable baselines. Many are a starting point you retrain on your own data, not a finished industry product.
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.
Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:
```
GET https://infinitode-docs.gitbook.io/documentation/faqs/questions-about-ais.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.