ShvIA
SIGN IN

state reading… version — response — probe: ai.shvia.org/api/v1/health

The AI gateway that shows the bill.

Local models — your own on-prem GPU — and cloud models behind a single interface, with audit, quota and per-project data-protection policy. Every answer arrives with what it cost: tokens, time, tok/s and the infrastructure that served it.

  • Local and cloud models in the same conversation, switchable mid-thread.
  • Every answer reports tokens, time, tok/s and where it ran.
  • Your context only goes to the provider you pick — on your own GPU, it never leaves the network.

A gateway, not one more chat

The question ShvIA answers is not “which model is best”. It is “who talked to which model, with what context, what it cost and where it ran”. It sits between the people doing the work and the providers: applies the project policy, draws down the group quota, records the request and hands back the answer with the gauge beside it.

gateway
One interface for many providers: on-prem GPU and cloud via BYOK — your key, your contract.
provedores
Anthropic, OpenAI, xAI, Z.ai, Gemini, DeepSeek, Kimi, MiniMax, Llama, IBM, Groq, Mistral, Together, Fireworks, Novita, OpenRouter, Perplexity, Kilo and Hermes — plus your own GPU. Each one’s models arrive by live discovery, using your key.
subscription
If you already pay for OpenCode or ChatGPT, plug that subscription in instead of a per-token key — the gateway speaks each dialect, and the bill stays yours, at the provider.
audit
Full log of every request, authentication attempt, token count and timing.
quota
A ceiling per Work Group — Beginner, Professional, Expert, Admin. Daily, weekly and monthly, editable by the administrator, with a warning before you hit it.
workspaces
Folders, files and text extraction, turned into conversation context.
code mode
An agent that reads, proposes a diff, edits and runs commands in your local folder — every operation explicitly approved.
memory
What was already decided comes back in the next conversation — and, with ai-memory, crosses agents and machines as markdown you can read without the app.
channels
The same conversation over WhatsApp and Telegram, under the same policy and the same audit as the screen.
mcp
Both ways: ShvIA consumes MCP servers and also presents itself as one — with allowed_tools closed by default.
anna
The name of ShvIA’s assistant. In the terminal, the anna CLI; on screen, the same voice.

The gauge does not lie

Telemetry is not decoration: it is working information. Every answer comes out with its receipt beside it — the number on screen is the real number from the run, in a mono face with tabular figures, so you can compare line against line without effort.

And when the answer comes off your own GPU, the receipt shows the best line there is: cost R$ 0.00.

SHVIA · INFERENCE RECEIPT#000481
conversationanna · operations
infragpu-local
modelqwen3-coder:30b
effortmedium
input tokens12,481
output tokens1,903
total time28.4 s
speed67.0 tok/s
costR$ 0.00
ran on your GPU — nothing left the network
example
receipt layout — in the app, every line comes from the real run

Where the data goes

From keyboard to answer, through a single place — leaving an auditable trail.

The data path through ShvIA Context leaves the person asking, passes through the ShvIA gateway — policy, quota and logging — and goes to the on-prem GPU or to a cloud provider using your own key. The answer comes back with telemetry attached. You question, files, project code ShvIA · gateway project policy group quota audit record model profile On-prem GPU never leaves the network Cloud via BYOK your key, your contract context answer + telemetry
  1. You send the question and the context — workspace files, a code selection.
  2. The gateway resolves the model profile, checks the group quota and opens the audit record.
  3. The run goes to the on-prem GPU — where context never leaves the network — or to a cloud provider with your key.
  4. The answer comes back with its receipt, and the record closes on the same numbers.

Combos: plan B is settled before the first token

A combo is a queue of models with an owner. If the primary does not answer — provider limit, outage, expired key — the gateway moves to the next one before the first token, in the same conversation and with the same context. No error screen, no starting over.

  1. claude-sonnet-4-6 anthropic · nuvem provider limit
  2. qwen3-coder:30b gpu-local · on-prem served instead
  3. deepseek-chat deepseek · nuvem queued — not needed

example illustrative chain — in the app you build the combo yourself, and the receipt says who actually served

your combos
Created and edited in the panel: the order, the models and the queue’s nickname belong to the user, not to the system.
in the picker
The combo shows up in the model picker marked with ⚡ — choosing the queue is as simple as choosing a model.
on the receipt
Every answer still says which model and which infrastructure served it. Fallback is not a black box.

The agent works in your folder — with your permission

Code Mode reads the project files, proposes the diff, edits and runs commands. Every operation goes through explicit approval — there is no “it sorted itself out”. And the panel shows you the change before you accept it, not after.

four tabs
General, Files, Changes and Workspace: the conversation, the file preview, the diff it wants to apply, and what sits on the other side.
skills
Instructions scoped to a project, importable from a git repository or a standalone SKILL.md — with the price in plain sight before you choose.
documents
Project markdown under versioned revision: what the agent wrote yesterday is still readable and comparable today.
two engines
The ShvIA gateway, or the Claude Code subscription already on your machine. The panel says which one is live — including which anna.
sub-agents
A large task splits, and the budget for the whole tree is declared up front: delegation with a ceiling, not with a surprise.

A token that never travels is never billed

Tool output is the largest consumer of context in Code Mode. RTK compresses that traffic before it reaches the model — content-aware reading of JSON, compacted diffs — and the panel shows how many characters never travelled, account by account. Not a promise: a gauge.

tool output 48,212 chars
what reached the model 4,310 chars
example the ratio of a typical JSON result, measured in development — in the app, the savings panel shows the number for your own account
rtk
Tool-output compressor for Code Mode: the model receives what matters, not the raw dump.
diffs
Code changes travel compacted — editing context without paying for the whole file again.
cache
The provider’s prompt cache where there is one — and whatever the provider caches on its own, the gateway stays out of the way.
panel
Accumulated savings show up in your account, measured — in the same place as every other gauge.

Ask, walk away, get told

Not all work fits inside the time a screen stays open. A routine is a chain of steps with a schedule of its own: it runs without you, handles failure step by step and delivers the result on the channel you pick — in the app, by e-mail, on Telegram or WhatsApp.

  1. Build the chain

    Steps in sequence, each with its own instruction for failing. One step’s envelope is the next one’s input — and the routine picks its infrastructure and model, like any conversation.

  2. It runs on schedule

    Declarative cron, per user. A repeating routine has a failure ceiling: break too often and it stops and says so, instead of insisting in silence.

  3. Check the bill

    Run by run, with tokens, time and infrastructure — drawn from the same quota. Automatic work is not invisible work.

bots
A bot is a conversation with an owner: a memory of its own that does not leak into the others, and spend visible as it happens.
quota warning
At 80% of the ceiling ShvIA tells you — once per window, in the app and on Telegram. A quota blown mid-task is not news you break afterwards.
long question
An answer that takes minutes leaves the open connection and goes to the queue: close the tab and the notice finds you.

Point the CLI you already use

The gateway speaks four dialects: the app’s native one, the OpenAI-compatible one, the one that matches Anthropic’s Messages API, and the Responses API. In practice the same key drives Claude Code, OpenAI-compatible clients and anna — and every call goes through the same audit, quota and project receipt.

  1. Generate the key

    In the app: Account → Generate API Key. It is born with the shvia_usr_ prefix, valid for 365 days — and it is shown exactly once.

  2. Point the base URL

    Two environment variables, no fork, no plugin. The client finds /v1/messages and /v1/models on its own.

  3. Check the bill

    The call from your terminal shows up in the panel like any conversation: tokens, time, infrastructure — drawn from the same project quota.

terminal — Claude Code through the gateway 
# Anthropic dialect (Claude Code, official SDK)
$ export ANTHROPIC_BASE_URL=https://ai.shvia.org
$ export ANTHROPIC_API_KEY=shvia_usr_…
$ claude

# OpenAI dialect (any compatible client)
# base_url: https://ai.shvia.org/v1 — GET /v1/models lists the models

In the app, Account → Connect my CLI generates that block ready to paste — with your chosen client and model, and without ever embedding the key in a page. If you already pay for OpenCode or ChatGPT, plug the subscription in instead of the key; the rest of the path is the same.

One system, seven surfaces

The same gateway answering from different places. Tokens, typography and component vocabulary are identical across all of them — one system, not ten screens.

Context sovereignty

ShvIA exists so that working with AI does not mean sending your own context outside without control. Success is the user never having to ask “where did my code go”.

on-prem
Models running on your own infrastructure’s GPU: context never crosses the network edge.
byok
When the run is in the cloud, the key is yours — the data-processing contract is yours, straight with the provider.
per project
The policy for where each context may go is decided per project, not by the habits of whoever typed.
locality
Every provider declares where the run happens — on-prem, US cloud, China cloud — and that is recorded on the request, not in the memory of whoever chose.
masking
National ID numbers, e-mail addresses and phone numbers leave masked whenever the destination is off-premises.
strict mode
With LGPD protection on — Brazil’s data-protection law — none of the project context goes to the cloud. And the in-house knowledge base never does, switch or no switch.
trail
Request, tokens, time and infrastructure are all recorded: you can audit later, not just trust in the moment.
training
ShvIA does not train models on your content. What leaves here is an inference request.

Questions

Can I sign in straight from here?
Yes — the form at the top of the page is the real sign-in. It talks to the app, which creates the session on its own domain and takes you to the conversation. If for any reason the site cannot reach the app, it says so and offers the direct link instead of pretending it worked.
What is the difference between ai.shvia.org and ia.shvia.org?
None: they are two addresses for the same app. ai in English, ia in Portuguese — whoever types from memory gets it right either way.
Do I need an account? How do I get one?
You do, and access is by invitation — open sign-up has been closed. Write to suporte@shvia.org telling us who you are and what you will use it for; the account is created by the team. Access and quota are settled by Work Group. More detail on the support page.
Is my data used to train a model?
No. ShvIA does inference, not training. When the answer comes from the local GPU, the context never leaves the network; when it comes from a cloud provider using your key, the contract you hold with that provider applies — and the gateway records that the call went there.
Which language does ShvIA answer in?
The interface comes in English and Portuguese, and the choice is remembered — the language picked here is already applied when the conversation opens on the other side. The assistant, though, does not follow the interface: it answers in the language you wrote in. Ask in Portuguese with the screen in English and the answer comes back in Portuguese, which is almost always what you wanted.
Can I use a subscription I already pay for?
Yes, for OpenCode and ChatGPT: instead of a key billed per token you plug in your own subscription, and the gateway speaks each dialect. The same rule as every other provider applies — the contract is yours, straight with them, and ShvIA records that the call went there.
Why does the site change theme?
Because the user’s choice survives. They are the same 10 presets as the app, stored in the same cookie — the theme picked here is already applied when the conversation opens on the other side.
Can I use Claude Code — or another CLI — with ShvIA?
Yes. The app’s /v1 facade speaks OpenAI’s dialect (/v1/chat/completions, /v1/models) and Anthropic’s (/v1/messages). Point your client’s base URL at the app and use the key generated in the panel — the “Point the CLI” section shows the two lines you need.
What is the strip at the top reading?
The app’s /api/v1/health: state, version and how long the probe took. If the reading fails, the fields sit at “—” with the reason beside them. A blank field is information; an invented number is not.

Sign in to ShvIA

The conversation, Code Mode and the usage panel are on the other side of the sign-in.

SIGN IN

ai.shvia.org ia.shvia.org