Lain empezó como un chat wrapper y terminó siendo una plataforma completa con 20 endpoints de API, 4 modos de razonamiento y un sistema de generación de proyectos que orquesta múltiples agentes en paralelo. El backend tiene 16 modelos Prisma (User, Chat, Message, Memory, Project, etc.) conectados a PostgreSQL, y el frontend maneja estado global con Zustand para sincronizar chat, memoria y navegación en tiempo real.

Lain started as a chat wrapper and ended up being a full platform with 20 API endpoints, 4 reasoning modes and a project generation system that orchestrates multiple agents in parallel. The backend has 16 Prisma models (User, Chat, Message, Memory, Project, etc.) connected to PostgreSQL, and the frontend manages global state with Zustand to sync chat, memory and navigation in real-time.

Cómo funciona

How it works

El usuario elige entre 4 modos de razonamiento: NORMAL (chat directo con GPT-4), LATERAL_THINKING (exploración creativa), PROMPT_ENGINEERING (optimización iterativa de prompts) y PROJECT_SCAFFOLDER (generación de proyectos completos). El Scaffolder usa una arquitectura Swarm donde un orchestrator GPT-5.2 descompone el proyecto en tareas y las distribuye a workers paralelos que generan código simultáneamente.

The user chooses between 4 reasoning modes: NORMAL (direct GPT-4 chat), LATERAL_THINKING (creative exploration), PROMPT_ENGINEERING (iterative prompt optimization) and PROJECT_SCAFFOLDER (complete project generation). The Scaffolder uses a Swarm architecture where a GPT-5.2 orchestrator breaks down the project into tasks and distributes them to parallel workers that generate code simultaneously.

Sistema de memoria

Memory system

Cada conversación genera embeddings vectoriales que se guardan en la base de datos. Cuando el usuario hace una pregunta nueva, el sistema busca por similitud coseno en memorias previas de todos sus chats, inyectando contexto relevante automáticamente. Hay 3 tipos de memoria: conversacional (dentro del chat), cross-chat (entre conversaciones) y de proyecto (vinculada a generaciones del Scaffolder).

Each conversation generates vector embeddings stored in the database. When the user asks a new question, the system searches by cosine similarity across memories from all their chats, automatically injecting relevant context. There are 3 memory types: conversational (within chat), cross-chat (between conversations) and project memory (linked to Scaffolder generations).

Autenticación y planes

Authentication and plans

NextAuth.js v5 con bcrypt para hashing de passwords y JWT para sesiones. El plan FREE tiene un límite de 30 mensajes, PRO desbloquea el Scaffolder y memoria avanzada, ENTERPRISE agrega API access y prioridad en la cola de generación. Todo el rate limiting se maneja server-side con contadores en PostgreSQL.

NextAuth.js v5 with bcrypt for password hashing and JWT for sessions. The FREE plan has a 30 message limit, PRO unlocks the Scaffolder and advanced memory, ENTERPRISE adds API access and generation queue priority. All rate limiting is handled server-side with PostgreSQL counters.

Hice esta app para Aisu Capital. El flujo es simple: el usuario escribe un prompt o pega la URL de un token de daos.fun, y la app genera 2 canciones distintas usando el modelo V4_5 de la API de box.fun. Mientras se generan, un polling cada 10 segundos (máximo 30 intentos) chequea el estado hasta que el audio está listo. La parte interesante es la descarga: usé ffmpeg.wasm para generar videos MP4 enteramente en el browser, sin servidor.

I built this app for Aisu Capital. The flow is simple: the user writes a prompt or pastes a daos.fun token URL, and the app generates 2 different songs using the V4_5 model from the box.fun API. While generating, a polling every 10 seconds (max 30 attempts) checks the status until audio is ready. The interesting part is the download: I used ffmpeg.wasm to generate MP4 videos entirely in the browser, no server needed.

Generación de música

Music generation

La API de generación recibe el prompt y devuelve 2 tracks por request. Si el input es una URL de daos.fun, primero scrapea el nombre del token, su descripción e imagen de portada para usarlos como contexto del prompt. El modelo soporta versiones V3.5, V4 y V4.5, y la app usa V4_5 por defecto que da mejores resultados para canciones completas con letra.

The generation API receives the prompt and returns 2 tracks per request. If the input is a daos.fun URL, it first scrapes the token name, description and cover image to use as prompt context. The model supports V3.5, V4 and V4.5 versions, and the app uses V4_5 by default which gives better results for complete songs with lyrics.

Descarga como video

Video download

El usuario puede descargar cualquier canción como video MP4. ffmpeg.wasm corre en el browser y combina el audio con la imagen de portada en un video H.264 + AAC. La imagen se redimensiona manteniendo aspect ratio y se centra sobre un fondo negro. Todo pasa client-side, sin subir nada al servidor.

The user can download any song as MP4 video. ffmpeg.wasm runs in the browser and combines the audio with the cover image into an H.264 + AAC video. The image is resized keeping aspect ratio and centered on a black background. Everything happens client-side, nothing is uploaded to the server.

Integración con daos.fun

daos.fun integration

La app detecta automáticamente si el input es una URL de daos.fun y extrae los metadatos del token (nombre, ticker, descripción, imagen). Esto permite generar canciones temáticas para cualquier token de Solana de forma automática, algo que fue clave para la propuesta de valor de Aisu Capital en el ecosistema.

The app automatically detects if the input is a daos.fun URL and extracts token metadata (name, ticker, description, image). This enables automatic themed song generation for any Solana token, which was key to Aisu Capital's value proposition in the ecosystem.

Proyecto para la MCP Agents Hackathon de E2B. La idea: le mandás un reporte de bug en lenguaje natural ("el botón de login no funciona en mobile") y el agente lo clasifica, lo reproduce en un sandbox real con Playwright, toma screenshots de evidencia, y crea un issue completo en GitHub con labels, severidad y pasos de reproducción. En el test real, el ciclo completo tardó 56 segundos (539ms para clasificación, 54s para reproducción en sandbox).

Project for the E2B MCP Agents Hackathon. The idea: you send a bug report in natural language ("the login button doesn't work on mobile") and the agent classifies it, reproduces it in a real sandbox with Playwright, takes evidence screenshots, and creates a complete GitHub issue with labels, severity and reproduction steps. In the real test, the full cycle took 56 seconds (539ms for classification, 54s for sandbox reproduction).

State machine

State machine

El workflow sigue una state machine de 7 estados: INTAKE (recibe el reporte) → CLASSIFY (Groq con Llama 3.3 70B decide si es bug o feature, asigna severidad y categoría en ~500ms) → ENRICH (agrega contexto técnico) → REPRODUCE (levanta un sandbox E2B con Firecracker microVM, instala dependencias, genera un script Playwright y lo ejecuta) → CAPTURE (toma screenshots a 1280x720, captura console logs y network traces) → CREATE_ISSUE (formatea todo en un GitHub issue con labels automáticos) → DONE.

The workflow follows a 7-state machine: INTAKE (receives report) → CLASSIFY (Groq with Llama 3.3 70B decides if it's a bug or feature, assigns severity and category in ~500ms) → ENRICH (adds technical context) → REPRODUCE (spins up an E2B sandbox with Firecracker microVM, installs dependencies, generates a Playwright script and runs it) → CAPTURE (takes 1280x720 screenshots, captures console logs and network traces) → CREATE_ISSUE (formats everything into a GitHub issue with automatic labels) → DONE.

Reproducción en sandbox

Sandbox reproduction

La parte más compleja. El agente genera un script de Playwright dinámicamente basado en la descripción del bug. Usa un helper findElement() que intenta múltiples estrategias de selección (text, role, test-id, CSS selector) para encontrar elementos en la página. El sandbox E2B corre en Firecracker microVMs aisladas, así que el código generado puede ejecutar cualquier cosa sin riesgo. Los screenshots se toman a resolución 1280x720 y se adjuntan al issue.

The most complex part. The agent dynamically generates a Playwright script based on the bug description. It uses a findElement() helper that tries multiple selection strategies (text, role, test-id, CSS selector) to find page elements. The E2B sandbox runs on isolated Firecracker microVMs, so generated code can execute anything without risk. Screenshots are taken at 1280x720 resolution and attached to the issue.

Stack

Stack

Backend Express con TypeScript strict y 13 endpoints REST. Groq para inferencia LLM sub-segundo (Llama 3.3 70B). E2B SDK para manejo de sandboxes. Frontend en React 19 con Tailwind CSS y un dashboard que muestra el progreso de cada estado en tiempo real vía polling.

Express backend with strict TypeScript and 13 REST endpoints. Groq for sub-second LLM inference (Llama 3.3 70B). E2B SDK for sandbox management. React 19 frontend with Tailwind CSS and a dashboard showing each state's progress in real-time via polling.

Proyecto para la competencia de datos de UdeSA. El objetivo era predecir riesgo de incendios forestales en las 21 provincias argentinas usando datos satelitales de NASA FIRMS. Entrené sobre un dataset de 2,184 muestras con 23 features (temperaturas, precipitaciones, NDVI, historial de focos, variables estacionales) y el modelo final fue un Random Forest que alcanzó un test accuracy de 0.7947 y F1-Score de 0.790.

Project for UdeSA's data competition. The goal was to predict wildfire risk across Argentina's 21 provinces using satellite data from NASA FIRMS. I trained on a dataset of 2,184 samples with 23 features (temperatures, precipitation, NDVI, fire history, seasonal variables) and the final model was a Random Forest that achieved a test accuracy of 0.7947 and F1-Score of 0.790.

Pipeline de datos

Data pipeline

El pipeline descarga datos de la API de NASA FIRMS (satélite VIIRS, focos de calor de las últimas 48 horas), los cruza con datos meteorológicos históricos y calcula features derivados: lag features de 1-3 meses, medias móviles de 3-6 meses, ciclos estacionales (sin/cos del mes), NDVI promedio por provincia y densidad histórica de focos. La actualización corre cada 24 horas vía GitHub Actions que ejecuta el pipeline completo y pushea los resultados al repositorio.

The pipeline downloads data from NASA FIRMS API (VIIRS satellite, hotspots from last 48 hours), cross-references with historical weather data and computes derived features: 1-3 month lag features, 3-6 month moving averages, seasonal cycles (sin/cos of month), average NDVI per province and historical hotspot density. The update runs every 24 hours via GitHub Actions that executes the full pipeline and pushes results to the repository.

Modelo y resultados

Model and results

Probé Random Forest, XGBoost y LightGBM con validación temporal (train en datos hasta 2022, test en 2023). Random Forest ganó con 0.7947 de accuracy. El output son 252 predicciones: 21 provincias × 12 meses, cada una con un nivel de riesgo (bajo, medio, alto). Las features más importantes fueron temperatura máxima promedio, focos históricos del mismo mes en años anteriores y NDVI.

I tested Random Forest, XGBoost and LightGBM with temporal validation (train on data up to 2022, test on 2023). Random Forest won with 0.7947 accuracy. The output is 252 predictions: 21 provinces × 12 months, each with a risk level (low, medium, high). The most important features were average max temperature, historical hotspots from the same month in previous years and NDVI.

Dashboard

Dashboard

El frontend tiene 4 páginas: mapa interactivo con Leaflet mostrando focos activos en tiempo real, mapa de riesgo por provincia con visualización hexagonal H3, gráficos de tendencias históricas con Plotly.js, y una tabla de predicciones filtrable por provincia y mes. Todo deployado en Vercel con los datos actualizándose automáticamente.

The frontend has 4 pages: interactive map with Leaflet showing real-time active hotspots, province risk map with H3 hexagonal visualization, historical trend charts with Plotly.js, and a predictions table filterable by province and month. All deployed on Vercel with data updating automatically.

NeuralLab es probablemente mi proyecto más grande (~37,100 líneas de Python). Arrancó como una CLI para automatizar experimentos de ML y fue creciendo hasta tener 35 comandos, 15 herramientas especializadas, 7 módulos de ML avanzados y una app desktop con Tauri. La idea es que le describas un experimento en lenguaje natural y el agente planifica todo: desde la exploración de datos hasta el reporte final, pasando por feature engineering, entrenamiento, evaluación y explicabilidad.

NeuralLab is probably my biggest project (~37,100 lines of Python). It started as a CLI to automate ML experiments and grew to have 35 commands, 15 specialized tools, 7 advanced ML modules and a desktop app with Tauri. The idea is that you describe an experiment in natural language and the agent plans everything: from data exploration to the final report, through feature engineering, training, evaluation and explainability.

Las 15 herramientas

The 15 tools

Cada herramienta es un módulo Python independiente que el agente puede invocar. Las principales: DataProfiler (genera perfiles estadísticos completos del dataset), ModelTrainer (entrena cualquier modelo con validación cruzada), AutoBenchmark (corre 10 clasificadores + 10 regresores automáticamente y rankea por métrica), InsightAnalyzer (612 líneas, ejecuta 12 chequeos de calidad sobre los datos), PipelineDiagnostics (detecta 17 problemas conocidos en pipelines ML), ModelExplainer (genera explicaciones SHAP + PDP plots), DriftDetector (detecta data drift entre train y producción).

Each tool is an independent Python module the agent can invoke. The main ones: DataProfiler (generates complete statistical profiles of the dataset), ModelTrainer (trains any model with cross-validation), AutoBenchmark (runs 10 classifiers + 10 regressors automatically and ranks by metric), InsightAnalyzer (612 lines, runs 12 quality checks on data), PipelineDiagnostics (detects 17 known problems in ML pipelines), ModelExplainer (generates SHAP + PDP plot explanations), DriftDetector (detects data drift between train and production).

Memoria semántica

Semantic memory

Toda la experiencia del agente se guarda en SQLite con búsqueda full-text (FTS5) y embeddings vectoriales. Si trabajás en un proyecto de clasificación de imágenes y después empezás uno de NLP, el agente puede recuperar insights relevantes del proyecto anterior automáticamente. La memoria persiste entre sesiones y entre proyectos distintos.

All agent experience is stored in SQLite with full-text search (FTS5) and vector embeddings. If you work on an image classification project and then start an NLP one, the agent can automatically retrieve relevant insights from the previous project. Memory persists across sessions and across different projects.

App desktop

Desktop app

Además de la CLI (Typer + Rich para output formateado), hay una app desktop hecha con Tauri + React + Vite. Tiene un diseño ultra-dark con panels para ver el estado de experimentos, métricas en vivo vía MLflow, y un chat donde interactuás con el agente. El backend FastAPI expone los mismos 35 comandos como endpoints REST.

Besides the CLI (Typer + Rich for formatted output), there's a desktop app built with Tauri + React + Vite. It has an ultra-dark design with panels to view experiment status, live metrics via MLflow, and a chat where you interact with the agent. The FastAPI backend exposes the same 35 commands as REST endpoints.

ML Canvas nació de una frustración: los notebooks de Jupyter son lineales y el código se vuelve un desorden rápido. La solución fue un canvas infinito donde cada paso del pipeline de ML es un nodo visual que se conecta con otros arrastrando cables. Subís un CSV, lo conectás a un nodo de preprocesamiento, ese a un modelo, y el resultado a un nodo de visualización. Todo se ejecuta en Python en el backend, pero el usuario nunca toca código si no quiere.

ML Canvas was born from a frustration: Jupyter notebooks are linear and code gets messy fast. The solution was an infinite canvas where each ML pipeline step is a visual node connected to others by dragging cables. You upload a CSV, connect it to a preprocessing node, that to a model, and the result to a visualization node. Everything runs in Python on the backend, but the user never touches code if they don't want to.

Los 13 tipos de nodos

The 13 node types

Hay 13 tipos de nodos, cada uno con dimensiones fijas en el canvas. Los de datos (upload CSV, split train/test), los de preprocesamiento (9 operaciones: encoding, scaling, normalización, PCA, feature selection, imputación, one-hot, label encoding, discretización), los de modelo (15 algoritmos: LogisticRegression, RandomForest, SVM, KNN, XGBoost, GradientBoosting, DecisionTree, NaiveBayes, AdaBoost, MLP, Ridge, Lasso, ElasticNet, SVR, LinearRegression) y los de visualización (ROC curves, matrices de confusión, histogramas, scatter plots con Plotly.js).

There are 13 node types, each with fixed dimensions on the canvas. Data nodes (upload CSV, train/test split), preprocessing (9 operations: encoding, scaling, normalization, PCA, feature selection, imputation, one-hot, label encoding, discretization), model nodes (15 algorithms: LogisticRegression, RandomForest, SVM, KNN, XGBoost, GradientBoosting, DecisionTree, NaiveBayes, AdaBoost, MLP, Ridge, Lasso, ElasticNet, SVR, LinearRegression) and visualization (ROC curves, confusion matrices, histograms, scatter plots with Plotly.js).

Ejecución segura de Python

Secure Python execution

Cuando el usuario conecta nodos y ejecuta el pipeline, el backend genera código Python dinámicamente y lo corre en un sandbox con una whitelist de librerías permitidas (scikit-learn, pandas, numpy, XGBoost). El sandbox tiene timeout y límites de memoria. Los resultados (métricas, gráficos, datos transformados) se devuelven al frontend vía API. El canvas se autoguarda cada 30 segundos.

When the user connects nodes and runs the pipeline, the backend dynamically generates Python code and runs it in a sandbox with a whitelist of allowed libraries (scikit-learn, pandas, numpy, XGBoost). The sandbox has timeout and memory limits. Results (metrics, plots, transformed data) are returned to the frontend via API. The canvas auto-saves every 30 seconds.

Asistente IA

AI assistant

El chat con GPT tiene acceso al estado completo del canvas: qué nodos hay, cómo están conectados, qué resultados dieron. Además tiene memoria semántica con embeddings de OpenAI y un threshold de similitud coseno de 0.5 para recuperar contexto de sesiones anteriores. Puede sugerir qué nodo agregar, explicar métricas, o directamente modificar el pipeline por vos.

The GPT chat has access to the full canvas state: which nodes exist, how they're connected, what results they gave. It also has semantic memory with OpenAI embeddings and a cosine similarity threshold of 0.5 to retrieve context from previous sessions. It can suggest which node to add, explain metrics, or directly modify the pipeline for you.

3 modos de trabajo

3 work modes

Canvas (nodos visualales con React Flow), Simple (formulario paso a paso sin nodos, para principiantes) y Código (editor Python directo para usuarios avanzados que quieren control total). Los 3 modos comparten el mismo backend de ejecución y los resultados son intercambiables.

Canvas (visual nodes with React Flow), Simple (step-by-step form without nodes, for beginners) and Code (direct Python editor for advanced users who want full control). All 3 modes share the same execution backend and results are interchangeable.

Quería entender visualmente qué pasa dentro de una red neuronal cuando clasifica un dígito. Entrené un MLP en PyTorch con arquitectura 784→128→64→10 (input 28x28 pixels aplanados, 2 capas ocultas con ReLU, salida Softmax de 10 clases) sobre MNIST y Fashion-MNIST. Después exporté los pesos y construí un visualizador 3D con Three.js donde cada neurona es una esfera que se ilumina según su activación.

I wanted to visually understand what happens inside a neural network when it classifies a digit. I trained an MLP in PyTorch with 784→128→64→10 architecture (28x28 pixel input flattened, 2 hidden layers with ReLU, 10-class Softmax output) on MNIST and Fashion-MNIST. Then I exported the weights and built a 3D visualizer with Three.js where each neuron is a sphere that lights up based on its activation.

Cómo funciona

How it works

Dibujás un número en un canvas HTML (brush radius de 1.8, fondo negro, trazo blanco). La imagen se downscalea a 28x28, se normaliza y pasa por el forward pass del modelo en JavaScript (los pesos se cargan desde un JSON exportado de PyTorch). En cada capa, las activaciones determinan el color y tamaño de cada neurona en la escena 3D.

You draw a number on an HTML canvas (brush radius 1.8, black background, white stroke). The image is downscaled to 28x28, normalized and passed through the model's forward pass in JavaScript (weights loaded from a JSON exported from PyTorch). At each layer, activations determine the color and size of each neuron in the 3D scene.

Visualización 3D

3D visualization

Las neuronas están distribuidas en capas con un spacing de 5.5 unidades entre capas. Las conexiones entre neuronas son líneas cuya opacidad refleja el peso de la conexión (más gruesa = más peso). Para no matar el rendimiento, limité las conexiones renderizadas a un máximo de 25,000 (la capa 784→128 tiene 100,352 conexiones, así que se muestran solo las top por peso absoluto). La cámara orbita con OrbitControls de Three.js.

Neurons are distributed in layers with 5.5-unit spacing between layers. Connections between neurons are lines whose opacity reflects connection weight (thicker = more weight). To not kill performance, I limited rendered connections to a maximum of 25,000 (the 784→128 layer has 100,352 connections, so only top ones by absolute weight are shown). Camera orbits with Three.js OrbitControls.

Entrenamiento

Training

El modelo se entrena en PyTorch con soporte Metal (Mac) y CUDA (GPU). En MNIST alcanza ~98% accuracy y en Fashion-MNIST un F1 de 0.789. El script de entrenamiento exporta los pesos como JSON plano que el frontend parsea para hacer inferencia directamente en el browser sin necesidad de backend.

The model trains in PyTorch with Metal (Mac) and CUDA (GPU) support. On MNIST it reaches ~98% accuracy and on Fashion-MNIST an F1 of 0.789. The training script exports weights as flat JSON that the frontend parses to do inference directly in the browser with no backend needed.

Vocero es un sistema de 2 agentes IA que resuelve un problema concreto: querés reservar un turno en algún lugar (peluquería, restaurante, médico) pero no tenés ganas de llamar. Le mandás un mensaje de WhatsApp tipo "quiero cortarme el pelo mañana a las 3 en Palermo" y Vocero se encarga de todo: busca negocios cercanos, llama por teléfono con voz IA, negocia el turno y te confirma por WhatsApp.

Vocero is a 2-agent AI system that solves a concrete problem: you want to book an appointment somewhere (hair salon, restaurant, doctor) but don't feel like calling. You send a WhatsApp message like "I want a haircut tomorrow at 3 in Palermo" and Vocero handles everything: searches nearby businesses, calls by phone with AI voice, negotiates the slot and confirms via WhatsApp.

Los 2 agentes

The 2 agents

El agente de texto recibe el mensaje de WhatsApp vía webhook de Twilio, usa NLU para extraer la intención (servicio, fecha, hora, zona), y busca negocios relevantes con Google Places API. El agente de voz toma esa información, genera audio con ElevenLabs y llama por teléfono vía Twilio PSTN. Si el negocio no atiende o dice que no hay turno, intenta con el siguiente de la lista.

The text agent receives the WhatsApp message via Twilio webhook, uses NLU to extract intent (service, date, time, zone), and searches relevant businesses with Google Places API. The voice agent takes that info, generates audio with ElevenLabs and calls by phone via Twilio PSTN. If the business doesn't answer or says no slot available, it tries the next one on the list.

State machine

State machine

El flujo sigue una state machine: IDLE → AWAITING_PROVIDER (buscando negocios con Google Places) → CALLING (llamada en curso con Twilio) → COMPLETED (confirmación enviada por WhatsApp). Si la primera llamada falla, el sistema puede hacer hasta 3 llamadas en paralelo con un stagger de 1.5 segundos entre cada una para maximizar chances de conseguir turno rápido.

The flow follows a state machine: IDLE → AWAITING_PROVIDER (searching businesses with Google Places) → CALLING (call in progress with Twilio) → COMPLETED (confirmation sent via WhatsApp). If the first call fails, the system can make up to 3 parallel calls with a 1.5-second stagger between each to maximize chances of getting a quick appointment.

Integración con calendario

Calendar integration

Cuando se confirma una reserva, Vocero crea automáticamente un evento en Google Calendar del usuario con la dirección del negocio, horario y detalles. El backend es FastAPI en Python con endpoints para cada etapa del flujo, y toda la comunicación con Twilio y ElevenLabs es asíncrona.

When a booking is confirmed, Vocero automatically creates a Google Calendar event for the user with the business address, time and details. The backend is FastAPI in Python with endpoints for each flow stage, and all communication with Twilio and ElevenLabs is asynchronous.

Proyecto para la Kiroween Hackathon. La idea: una terminal de research cripto donde en vez de abrir 15 tabs para investigar un token, le preguntás "analiza $BONK" y 12 agentes especializados salen a buscar información en paralelo: uno scrapea Twitter, otro consulta CoinGecko, otro analiza wallets en Solana, otro revisa liquidez en DexScreener. Al final, DeepSeek Reasoner sintetiza todo en un reporte accionable.

Project for the Kiroween Hackathon. The idea: a crypto research terminal where instead of opening 15 tabs to research a token, you ask "analyze $BONK" and 12 specialized agents go search for information in parallel: one scrapes Twitter, another queries CoinGecko, another analyzes wallets on Solana, another checks liquidity on DexScreener. In the end, DeepSeek Reasoner synthesizes everything into an actionable report.

Los 12 agentes y sus costos

The 12 agents and their costs

Cada agente tiene un costo en créditos: Twitter Intelligence (10 créditos, el más caro porque scrapea en tiempo real), CoinGecko (1 crédito), Solana Token Analysis (5 créditos), Wallet Analysis (5 créditos), Crypto News (3 créditos), DexScreener (2 créditos), Token Metrics (3 créditos), Trending Detection (2 créditos), Liquidity Monitor (3 créditos), Technical Analysis (4 créditos), Blockchain Explorer (3 créditos), y un agente de Sentiment Analysis (4 créditos). El pipeline selecciona automáticamente qué agentes usar según la query para optimizar costos.

Each agent has a credit cost: Twitter Intelligence (10 credits, most expensive because it scrapes in real-time), CoinGecko (1 credit), Solana Token Analysis (5 credits), Wallet Analysis (5 credits), Crypto News (3 credits), DexScreener (2 credits), Token Metrics (3 credits), Trending Detection (2 credits), Liquidity Monitor (3 credits), Technical Analysis (4 credits), Blockchain Explorer (3 credits), and a Sentiment Analysis agent (4 credits). The pipeline automatically selects which agents to use based on the query to optimize costs.

Pipeline de 3 pasos

3-step pipeline

Planning: DeepSeek analiza la query y decide qué agentes activar (no siempre se usan los 12). Execution: hasta 5 agentes corren en paralelo con retry automático y fallback si alguno falla. Synthesis: DeepSeek Reasoner recibe todos los hallazgos y genera un reporte unificado con insights, riesgos y oportunidades. Todo se streama vía SSE al frontend en tiempo real, así el usuario ve los resultados parciales mientras otros agentes siguen trabajando.

Planning: DeepSeek analyzes the query and decides which agents to activate (not all 12 are always used). Execution: up to 5 agents run in parallel with automatic retry and fallback if any fail. Synthesis: DeepSeek Reasoner receives all findings and generates a unified report with insights, risks and opportunities. Everything is streamed via SSE to the frontend in real-time, so the user sees partial results while other agents keep working.

Modo DEGEN y rate limiting

DEGEN mode and rate limiting

El modo DEGEN activa todos los agentes simultáneamente para análisis agresivo de tokens nuevos, incluyendo detección de honeypots y análisis de distribución de wallets. El rate limiting es de 2 queries por día por IP + browser fingerprint para controlar costos de API. Los gráficos de precio se renderizan con TradingView embeddido.

DEGEN mode activates all agents simultaneously for aggressive analysis of new tokens, including honeypot detection and wallet distribution analysis. Rate limiting is 2 queries per day per IP + browser fingerprint to control API costs. Price charts are rendered with embedded TradingView.