Empieza con TramtaiGet started with Tramtai

Todo se descarga desde la última versión en GitHub. Cada archivo tiene su suma SHA-256 en SHA256SUMS.txt.

Windows 10 y 11

1. Descarga Tramtai-…-instalador-windows-x64.exe y ábrelo. Se instala solo para tu usuario, sin permisos de administrador.
2. Si Windows muestra «Windows protegió su PC», pulsa Más información → Ejecutar de todas formas. Aparece porque el instalador no está firmado con un certificado de pago (ver preguntas frecuentes).
3. Elige las opciones: el comando tramtai en la terminal, iniciar con Windows y un acceso directo en el escritorio.

¿Prefieres no instalar nada? Tramtai-…-portable-windows-x64.zip trae la misma app: descomprímelo y abre tramtai-escritorio.exe. Esa copia no se actualiza sola.

macOS 11 o posterior

Con Homebrew es lo más cómodo: se instala sin el bloqueo de Gatekeeper y se actualiza con brew upgrade.

Everything is on the latest release on GitHub. Every file has its SHA-256 checksum in SHA256SUMS.txt.

Windows 10 and 11

1. Download Tramtai-…-instalador-windows-x64.exe and run it. It installs for your user only, with no administrator rights.
2. If Windows shows "Windows protected your PC", click More info → Run anyway. It appears because the installer isn't signed with a paid certificate (see the FAQ).
3. Pick the options: the tramtai command in the terminal, start with Windows and a desktop shortcut.

Rather not install anything? Tramtai-…-portable-windows-x64.zip has the same app: unzip it and open tramtai-escritorio.exe. That copy doesn't update itself.

macOS 11 or later

Homebrew is the easiest way: it installs without the Gatekeeper block and updates with brew upgrade.

brew tap mscottb/tramtai https://github.com/MscottB/Tramtai
brew install --cask tramtai

Sin Homebrew: abre Tramtai-…-macos.dmg (Intel y Apple Silicon) y arrastra Tramtai a Aplicaciones. La app no está firmada por un desarrollador de Apple, así que la primera vez macOS la bloquea: ábrela, cierra el aviso y ve a Ajustes del Sistema → Privacidad y seguridad → Abrir igualmente. O, en la Terminal:

Without Homebrew: open Tramtai-…-macos.dmg (Intel and Apple Silicon) and drag Tramtai to Applications. The app isn't signed by an Apple developer, so macOS blocks it the first time: open it, close the warning and go to System Settings → Privacy & Security → Open Anyway. Or, in Terminal:

xattr -dr com.apple.quarantine /Applications/Tramtai.app

Linux

Los paquetes .deb (Debian, Ubuntu, Mint…) y .rpm (Fedora, openSUSE…) traen la app de escritorio, el servicio y la CLI, para x64 y ARM. Necesitan GTK 4 y WebKitGTK 6.0 (Ubuntu 24.04+, Debian 12+, Fedora), que se instalan solos. En GNOME, el icono de la bandeja necesita la extensión AppIndicator.

Linux

The .deb (Debian, Ubuntu, Mint…) and .rpm (Fedora, openSUSE…) packages include the desktop app, the service and the CLI, for x64 and ARM. They need GTK 4 and WebKitGTK 6.0 (Ubuntu 24.04+, Debian 12+, Fedora), installed automatically. On GNOME, the tray icon needs the AppIndicator extension.

sudo apt install ./Tramtai-…-linux-amd64.deb
sudo dnf install ./Tramtai-…-linux-amd64.rpm

Solo la CLI y el servicio (un servidor, o si no quieres la app): con Homebrew en macOS o Linux, o con el script de instalación, que comprueba la suma SHA-256 y deja tramtai en ~/.local/bin. Después, tramtai abrir inicia el servicio y abre la Web UI en el navegador.

CLI and service only (a server, or if you don't want the app): with Homebrew on macOS or Linux, or with the install script, which checks the SHA-256 checksum and puts tramtai in ~/.local/bin. Then tramtai abrir starts the service and opens the Web UI in your browser.

brew install mscottb/tramtai/tramtai
curl -fsSL https://raw.githubusercontent.com/MscottB/Tramtai/main/scripts/instalar.sh | sh

Tramtai usa los CLI oficiales de cada agente tal como se instalan: Claude Code (claude), Codex CLI (codex), GitHub Copilot CLI (copilot) o una clave de la Gemini API. Antigravity (agy) va con una clave de la Gemini API. Abre la app y ve a Agentes: te dice qué le falta a cada uno.

Con tu suscripción (uso personal)

Si ya usas Claude Pro/Max o ChatGPT en tu equipo, pulsa Usar mi suscripción en la página Agentes. Se aplica al momento. Es solo para uso personal y local, según los términos de cada proveedor. Tramtai nunca lee ni copia las credenciales de los CLI: el propio CLI usa la suya (con GitHub Copilot, Tramtai solo anota qué cuenta inició sesión).

GitHub Copilot: inicia sesión una vez con copilot login en una terminal y elige Usar mi suscripción. Vale cualquier plan con GitHub Copilot CLI (Free, Pro, Pro+, Business o Enterprise). copilot usa el modelo automático, el único del plan Free; con los demás puedes pedir copilot/<modelo>. Cada petición gasta créditos de tu plan (premium requests). En Windows, Tramtai usa el copilot.exe que instala npm, no el envoltorio copilot.cmd.

Con una clave de API

tramtai claves guardar la pide sin mostrarla y la guarda cifrada en el almacén del sistema: el Administrador de credenciales en Windows, el Llavero en macOS y el Secret Service en Linux (necesita secret-tool, del paquete libsecret-tools). Tramtai nunca la escribe en sus archivos y la usa desde la siguiente petición, sin reiniciar. La página Agentes te dice dónde queda en tu sistema.

Tramtai uses each agent's official CLI as installed: Claude Code (claude), Codex CLI (codex), GitHub Copilot CLI (copilot) or a Gemini API key. Antigravity (agy) uses a Gemini API key. Open the app and go to Agents: it tells you what each one is missing.

With your subscription (personal use)

If you already use Claude Pro/Max or ChatGPT on your computer, click Use my subscription on the Agents page. It applies right away. It's for personal, local use only, under each provider's terms. Tramtai never reads or copies the CLIs' credentials: the CLI uses its own (with GitHub Copilot, Tramtai only notes which account is signed in).

GitHub Copilot: sign in once with copilot login in a terminal and choose Use my subscription. Any plan with GitHub Copilot CLI works (Free, Pro, Pro+, Business or Enterprise). copilot uses the automatic model, the only one on the Free plan; on the others you can ask for copilot/<model>. Every request uses credits from your plan (premium requests). On Windows, Tramtai uses the copilot.exe that npm installs, not the copilot.cmd wrapper.

With an API key

tramtai claves guardar asks for it without showing it and stores it encrypted in the system store: Credential Manager on Windows, Keychain on macOS and the Secret Service on Linux (it needs secret-tool, from the libsecret-tools package). Tramtai never writes it to its own files and uses it from the next request, without restarting. The Agents page tells you where it lives on your system.

tramtai claves guardar ANTHROPIC_API_KEY   # Claude
tramtai claves guardar OPENAI_API_KEY      # Codex
tramtai claves guardar COPILOT_GITHUB_TOKEN  # GitHub Copilot (token fine-grained con «Copilot Requests»)
tramtai claves guardar GEMINI_API_KEY      # Gemini, Antigravity

En la app, Mis APIs te da la URL y la clave, con ejemplos listos para copiar. Cualquier SDK de OpenAI o Anthropic funciona cambiando solo la URL base:

In the app, My APIs gives you the URL and the key, with ready-to-copy examples. Any OpenAI or Anthropic SDK works by changing just the base URL:

¿Qué URL uso? Si tu app ya usa el SDK de OpenAI, o una herramienta que deja cambiar la URL base (LangChain, n8n, un editor con IA), la de OpenAI; si usa el SDK de Anthropic, la de Anthropic. Si necesitas enviar archivos, seguir tareas largas y retomarlas si se corta la conexión, cancelar, reintentar o elegir respaldo en cada petición, la API propia: su descripción OpenAPI está en /api/v1/openapi.json. En la app, Mis APIs compara las tres y trae ejemplos de cada una, y Probar → Ver como código da tu prueba lista para copiar.

Which URL do I use? If your app already uses the OpenAI SDK, or a tool that lets you change the base URL (LangChain, n8n, an AI editor), the OpenAI one; if it uses the Anthropic SDK, the Anthropic one. If you need to send files, follow long jobs and resume them if the connection drops, cancel, retry or pick a fallback per request, the Tramtai API: its OpenAPI description is at /api/v1/openapi.json. In the app, My APIs compares the three with examples for each, and Try → View as code gives you your test ready to copy.

El campo model elige agente y modelo: claude/sonnet, claude/haiku, codex, copilot, gemini/gemini-flash-latest o un perfil como perfil/rapido. Sin model se usa el modelo predeterminado de Ajustes. En Claude, Codex y GitHub Copilot (con un modelo concreto), reasoning_effort elige cuánto razona el agente.

The model field picks agent and model: claude/sonnet, claude/haiku, codex, copilot, gemini/gemini-flash-latest or a profile like perfil/rapido. Without model, the default model from Settings is used. For Claude, Codex and GitHub Copilot (with a specific model), reasoning_effort sets how hard the agent reasons.

from openai import OpenAI

cliente = OpenAI(base_url="http://127.0.0.1:17373/openai/v1", api_key="<clave de Mis APIs>")
r = cliente.chat.completions.create(model="claude/sonnet", messages=[{"role": "user", "content": "Hola"}])
print(r.choices[0].message.content)

import anthropic

cliente = anthropic.Anthropic(base_url="http://127.0.0.1:17373/anthropic", api_key="<clave de Mis APIs>")
r = cliente.messages.create(model="claude/haiku", max_tokens=1024, messages=[{"role": "user", "content": "Hola"}])
print(r.content[0].text)

Tramtai escucha solo en 127.0.0.1: tus aplicaciones deben correr en el mismo equipo. La respuesta en vivo (stream: true) funciona igual que con OpenAI o Anthropic.

Tramtai listens only on 127.0.0.1: your apps must run on the same computer. Live responses (stream: true) work just like with OpenAI or Anthropic.

Pásale tus funciones en tools, como con OpenAI o Anthropic. El agente decide si las necesita y pide la llamada; tu aplicación la ejecuta y le devuelve el resultado en el siguiente mensaje. El agente nunca ejecuta nada por su cuenta.

Pass your functions in tools, just like with OpenAI or Anthropic. The agent decides whether it needs them and requests the call; your app runs it and sends the result back in the next message. The agent never runs anything on its own.

herramientas = [{"type": "function", "function": {
    "name": "tiempo", "description": "El tiempo actual de una ciudad",
    "parameters": {"type": "object", "properties": {"ciudad": {"type": "string"}}, "required": ["ciudad"]}}}]

mensajes = [{"role": "user", "content": "¿Qué tiempo hace en Lima?"}]
r = cliente.chat.completions.create(model="claude/haiku", messages=mensajes, tools=herramientas)
llamada = r.choices[0].message.tool_calls[0]          # tiempo({"ciudad": "Lima"})

mensajes += [r.choices[0].message, {"role": "tool", "tool_call_id": llamada.id, "content": "19 °C, nublado"}]
r = cliente.chat.completions.create(model="claude/haiku", messages=mensajes, tools=herramientas)
print(r.choices[0].message.content)

• Los argumentos llegan validados con el JSON Schema de cada herramienta.
• tool_choice (auto, required, none o una función concreta) y las llamadas en paralelo funcionan igual que en OpenAI y Anthropic.
• Con herramientas, la respuesta llega completa al terminar, aunque pidas stream.

• Arguments arrive validated against each tool's JSON Schema.
• tool_choice (auto, required, none or a specific function) and parallel calls work as in OpenAI and Anthropic.
• With tools, the response arrives complete at the end, even if you ask for stream.

En Mis APIs puedes crear una API para cada aplicación, con su propia clave. Esa clave solo se muestra al crearla: cópiala entonces. Si la pierdes, Regenerar la clave te da una nueva. Cada una puede:

• permitir solo ciertos modelos, o fijar uno que se usa siempre;
• añadir instrucciones fijas (por ejemplo, «responde siempre en español»);
• escuchar en su propio puerto si tu aplicación lo necesita.

Se activan o detienen sin reiniciar, y cada una ve solo sus propios trabajos.

In My APIs you can create one API per app, each with its own key. That key is shown only when it is created: copy it then. If you lose it, Regenerate the key gives you a new one. Each one can:

• allow only certain models, or pin one that is always used;
• add fixed instructions (for example, "always answer in Spanish");
• listen on its own port if your app needs it.

They turn on or off without restarting, and each one only sees its own jobs.

En Probar defines una receta: las instrucciones, el agente y el modelo, un esquema JSON si quieres que la respuesta tenga siempre la misma forma, y un respaldo. La pruebas con un mensaje y tus archivos y, cuando funciona, Guardar como API te da una URL y una clave para tu aplicación. Tu aplicación solo envía el mensaje y recibe la respuesta con esa forma.

El respaldo son hasta 3 agentes que siguen, en orden, si el principal falla antes de empezar a responder: llega a su límite, falta la clave o da un error. Verás un aviso en Probar, y el Historial muestra qué agente respondió. Si el agente ya había empezado a responder no se cambia, para no mezclar dos respuestas. Cada agente del respaldo puede tener su propio esfuerzo; si no eliges uno, usa el del principal.

Bajo la respuesta, Registro muestra la hora de cada paso y cuánto duró cada etapa, y Pruebas recientes guarda tus últimas pruebas para abrirlas o usarlas de nuevo.

Desde Mis APIs, Abrir en Probar carga la receta de una API para cambiarla y Actualizar guarda los cambios.

Cada API puede tener un presupuesto diario y mensual en peticiones, tokens o dólares. Mis APIs muestra una barra por límite, amarilla desde el 80 %; al 100 % la aplicación recibe un error 429 hasta que empieza el día o el mes siguiente, o hasta que pulses Reiniciar consumo. El límite en dólares solo suma el coste que informa el agente (hoy Claude).

In Try you define a recipe: the instructions, the agent and model, a JSON schema if you want the answer to always have the same shape, and a fallback. Test it with a message and your files and, once it works, Save as API gives you a URL and a key for your app. Your app just sends the message and gets the answer in that shape.

The fallback is up to 3 agents that take over, in order, if the main one fails before it starts answering: it hits its limit, the key is missing or it errors. You'll see a notice in Try, and History shows which agent answered. If the agent had already started answering it is not switched, so two answers are never mixed. Each fallback agent can have its own effort; if you do not pick one, it uses the main one's.

Under the answer, Log shows the time of each step and how long each stage took, and Recent tests keeps your latest tests so you can open them or use them again.

From My APIs, Open in Try loads an API's recipe so you can change it, and Update saves the changes.

Each API can have a daily and monthly budget in requests, tokens or dollars. My APIs shows one bar per limit, yellow from 80%; at 100% the app gets a 429 error until the next day or month starts, or until you press Reset usage. The dollar limit only adds up the cost the agent reports (Claude today).

Tramtai acepta PDF, Word, PowerPoint, Excel, HTML, texto y ZIP, y los convierte a texto antes de pasarlos al agente. Para PDF y Office necesita markitdown:

Tramtai accepts PDF, Word, PowerPoint, Excel, HTML, text and ZIP files, and turns them into text before handing them to the agent. PDF and Office files need markitdown:

uv tool install "markitdown[pdf,docx,pptx,xlsx]==0.1.8"
tramtai ejecutar -f informe.pdf "Resume el documento en tres puntos"

Para recibir JSON con una forma concreta, usa response_format con un JSON Schema: Tramtai valida la respuesta antes de devolverla y, si no lo cumple, responde 422 salida_no_cumple_esquema con el primer problema (por ejemplo, «Falta el campo `total`»). Desde la v0.46 también se comprueban los format (date, date-time, email, uri…), en las respuestas y en los argumentos de las herramientas.

En Probar, «Respuesta con forma» arma el esquema con plantillas (extraer datos, clasificar, resumen en puntos, sentimiento, sí o no, lista de tareas, entidades) o campo a campo; la pestaña JSON queda para lo avanzado. Si la respuesta no cumple, verás cada problema y el botón Corregir, que pide al mismo agente que la arregle. En la receta, «Si la respuesta no cumple» permite hasta 3 correcciones automáticas; cada una es otra petición al agente.

To get JSON with a specific shape, use response_format with a JSON Schema: Tramtai validates the answer before returning it and, if it doesn't match, replies 422 salida_no_cumple_esquema with the first problem (for example, "The field `total` is missing"). Since v0.46 format is checked too (date, date-time, email, uri…), in answers and in tool arguments.

In Try, "Shaped response" builds the schema from templates (extract data, classify, summary in points, sentiment, yes or no, task list, entities) or field by field; the JSON tab is for advanced cases. If the response doesn't match, you'll see each problem and the Correct button, which asks the same agent to fix it. In the recipe, "If the response does not match" allows up to 3 automatic corrections; each one is another request to the agent.

Tramtai comprueba cada hora si hay una versión nueva (solo pide a GitHub la ficha pública de la última versión). Cuando la hay, la cabecera de la app muestra Actualizar y el menú de la bandeja la indica junto a «Acerca de Tramtai». Antes de instalar, el aviso muestra lo que trae cada versión que te saltas.

• Windows (instalador): Actualizar ahora la descarga, comprueba que lleva la firma de Tramtai y su suma SHA-256, y la instala sin preguntar nada más. La app vuelve a abrirse ya actualizada, con tu configuración y tus datos.
• Homebrew: brew upgrade.
• Portable, .dmg, .deb y .rpm: el aviso trae el enlace de descarga; se actualiza instalando el paquete nuevo encima.
• Sin esperar: Ajustes → Buscar actualización ahora, o Buscar actualizaciones en el menú de la bandeja.
• Instalando a mano: si Tramtai está abierto, el instalador lo cierra, instala y lo vuelve a abrir.
• Terminal: tramtai actualizar (o --comprobar para solo mirar).

Se desactiva en Ajustes → Buscar actualizaciones.

Tramtai checks for a new version every hour (it only asks GitHub for the public page of the latest release). When there is one, the app's header shows Update and the tray menu shows it next to "About Tramtai". Before installing, the notice shows what each version you skip brings.

• Windows (installer): Update now downloads it, checks that it carries Tramtai's signature and its SHA-256 checksum, and installs it without asking anything else. The app reopens already updated, with your settings and data.
• Homebrew: brew upgrade.
• Portable, .dmg, .deb and .rpm: the notice has the download link; update by installing the new package over the old one.
• No waiting: Settings → Check for updates now, or Check for updates in the tray menu.
• Installing by hand: if Tramtai is open, the installer closes it, installs and opens it again.
• Terminal: tramtai actualizar (or --comprobar to only check).

Turn it off in Settings → Check for updates.