# Primeros Pasos

Esta guia te guiara a traves de la configuracion de Symbi y la creacion de tu primer agente de IA.

▶ **Mira el tutorial de inicio:**

[![Symbiont — get started](https://img.youtube.com/vi/RPyKpqKz5ik/hqdefault.jpg)](https://www.youtube.com/watch?v=RPyKpqKz5ik)

## Tabla de contenidos


---

## Prerrequisitos

Lo que necesitas depende de como instales y ejecutes Symbi.

### Para ejecutar el binario preconstruido

Los binarios preconstruidos ya estan compilados: **no** necesitas Rust, protobuf ni Git para instalarlos o ejecutarlos. Instala con Homebrew, el script de instalacion (`curl`) o una descarga manual desde GitHub Releases.

- **Docker** solo se necesita en *tiempo de ejecucion* si ejecutas agentes bajo el nivel de sandbox predeterminado (`tier1`, respaldado por Docker). **No** se necesita para instalar Symbi ni para ejecutar `symbi init`, `symbi dsl` o `symbi --version`.

### Para construir desde el codigo fuente

Requerido solo si instalas via `cargo install` o construyes el repositorio tu mismo:

- **Rust 1.82+**
- **protobuf-compiler** (`apt install protobuf-compiler` en Ubuntu, `brew install protobuf` en macOS)
- **Git** (para clonar el repositorio)

### Opcional

- **[symbi-claude-code](https://github.com/thirdkeyai/symbi-claude-code)** (plugin de gobernanza para Claude Code)
- **[symbi-gemini-cli](https://github.com/thirdkeyai/symbi-gemini-cli)** (extension de gobernanza para Gemini CLI)

> **Nota:** La busqueda vectorial esta integrada. Symbi incluye [LanceDB](https://lancedb.com/) como base de datos vectorial embebida -- no se necesita ningun servicio externo.

---

## Instalacion

### Opcion 1: Binarios Preconstruidos (Inicio Rapido)

> **Nota:** Los binarios preconstruidos estan probados pero se consideran menos confiables que cargo install o Docker.

**macOS (Homebrew):**
```bash
brew tap thirdkeyai/tap
brew install symbi
```

**macOS / Linux (script de instalacion):**
```bash
curl -fsSL https://raw.githubusercontent.com/thirdkeyai/symbiont/main/scripts/install.sh | bash
```

**Descarga manual:**
Descargar desde [GitHub Releases](https://github.com/thirdkeyai/symbiont/releases) y agregar al PATH.

### Opcion 2: Docker (Recomendado)

La forma mas rapida de obtener un runtime funcionando es dejar que el contenedor cree el proyecto por ti:

```bash
# 1. Crear symbiont.toml, agents/, policies/, docker-compose.yml y
#    un .env con un SYMBIONT_MASTER_KEY recien generado.
docker run --rm -v $(pwd):/workspace ghcr.io/thirdkeyai/symbi:latest \
  init --profile assistant --no-interact --dir /workspace

# 2. Iniciar el runtime. Lee .env automaticamente.
docker compose up
```

La API del runtime queda ahora en `http://localhost:8080` y HTTP Input en `http://localhost:8081`.

Si prefieres trabajar desde un clon (para compilar la imagen tu mismo o ejecutar pruebas):

```bash
git clone https://github.com/thirdkeyai/symbiont.git
cd symbiont

# Build the unified symbi container
docker build -t symbi:latest .

# Run the development environment
docker run --rm -it -v $(pwd):/workspace symbi:latest bash
```

### Opcion 3: Instalacion Local

Para desarrollo local:

```bash
# Clone the repository
git clone https://github.com/thirdkeyai/symbiont.git
cd symbiont

# Install Rust dependencies and build
cargo build --release

# Run tests to verify installation
cargo test
```

### Verificar Instalacion

Probar que todo funciona correctamente:

```bash
# Test the DSL parser
cd crates/dsl && cargo run && cargo test

# Test the runtime system
cd ../runtime && cargo test

# Run example agents
cargo run --example basic_agent
cargo run --example full_system

# Test the unified symbi CLI
cd ../.. && cargo run -- dsl --help
cargo run -- mcp --help

# Test with Docker container
docker run --rm symbi:latest --version
docker run --rm -v $(pwd):/workspace symbi:latest dsl parse --help
docker run --rm symbi:latest mcp --help
```

---

## Inicializacion de Proyecto

La forma mas rapida de iniciar un nuevo proyecto Symbiont es `symbi init`:

```bash
symbi init
```

Esto lanza un asistente interactivo que te guia a traves de:
- **Seleccion de perfil**: `minimal`, `assistant`, `dev-agent` o `multi-agent`
- **Modo SchemaPin**: `tofu` (Trust-On-First-Use), `strict` o `disabled`
- **Nivel de sandbox**: `tier0` (ninguno, solo desarrollo), `tier1` (Docker), `tier2` (gVisor / `runsc`) o `tier3` (microVM Firecracker)

### Lo que produce `init`

Cada ejecucion escribe:

| Archivo | Proposito |
|---------|-----------|
| `symbiont.toml` | Configuracion del runtime y de politicas |
| `policies/default.cedar` | Politica Cedar deny-by-default |
| `agents/*.symbi` | Definiciones de agente especificas del perfil (los `.dsl` heredados tambien se reconocen; excepto `minimal`) |
| `AGENTS.md` | Indice autogenerado de los agentes declarados |
| `.symbiont/audit/` | Directorio del registro de auditoria a prueba de manipulacion |
| `.gitignore` | Se anade con entradas especificas de Symbiont, incluyendo `.env` |
| `.env` | `SYMBIONT_MASTER_KEY` generado desde `/dev/urandom` (permisos 0600) |
| `.env.example` | Plantilla segura para commit que muestra las variables de entorno requeridas |
| `docker-compose.yml` | Archivo compose listo para ejecutar con los montajes de volumen y el cableado de env correctos |

Pase `--no-docker-compose` para omitir el archivo compose, y `--dir <PATH>` para escribir en un directorio distinto del actual (esencial dentro de un contenedor Docker — ver mas abajo).

### Modo no interactivo

Para CI/CD o configuraciones por script:

```bash
symbi init --profile assistant --schemapin tofu --sandbox tier1 --no-interact
```

### Ejecutar `init` dentro de Docker

Como el WORKDIR de la imagen es `/var/lib/symbi`, use `--dir` para escribir en su volumen montado:

```bash
docker run --rm -v $(pwd):/workspace ghcr.io/thirdkeyai/symbi:latest \
  init --profile assistant --no-interact --dir /workspace
```

Eso rellena el directorio actual del host con el arbol completo del proyecto.

### Perfiles

| Perfil | Que crea |
|--------|----------|
| `minimal` | `symbiont.toml` + politica Cedar por defecto |
| `assistant` | + un agente asistente gobernado |
| `dev-agent` | + agente CliExecutor con politicas de seguridad |
| `multi-agent` | + agentes coordinador/worker con politicas inter-agente |

### Importar desde el catalogo

Importa agentes preconstruidos junto con cualquier perfil:

```bash
symbi init --profile minimal --no-interact
symbi init --catalog assistant,dev
```

Listar agentes disponibles en el catalogo:

```bash
symbi init --catalog list
```

Despues de la inicializacion, valida e inicia:

```bash
symbi dsl -f agents/assistant.symbi   # validate your agent
symbi run assistant -i '{"query": "hello"}'  # test a single agent
symbi up                             # start the runtime locally
docker compose up                    # ...or start it in Docker (reads .env)
```

### Ejecutar un agente individual

Usa `symbi run` para ejecutar un agente sin iniciar el servidor de runtime completo:

```bash
symbi run <agent-name-or-file> --input <json>
```

El comando resuelve nombres de agentes buscando: ruta directa, luego el directorio `agents/`. Configura la inferencia en la nube desde variables de entorno (`OPENROUTER_API_KEY`, `OPENAI_API_KEY` o `ANTHROPIC_API_KEY`), ejecuta el bucle de razonamiento ORGA y sale.

```bash
symbi run assistant -i 'Summarize this document'
symbi run agents/recon.symbi -i '{"target": "10.0.1.5"}' --max-iterations 5
```

### Partir desde una plantilla (`symbi new`)

`symbi init` genera un proyecto generico; `symbi new` genera un proyecto en torno a una de varias plantillas orientadas a tareas. Es util cuando sabes que tipo de agente necesitas antes de saber cuales agentes necesitas.

```bash
symbi new --list                     # show available templates
symbi new <template> <project-name>  # create a new project from a template
```

Plantillas incluidas:

| Plantilla | Que obtienes |
|-----------|--------------|
| `webhook-min` | Agente minimo dirigido por webhooks — configuracion de HTTP Input + un DSL manejador |
| `webscraper-agent` | Agente de scraping con politicas de acceso Cedar y una herramienta scraper de ToolClad |
| `slm-first` | Patron de router + lista blanca SLM + respaldo por confianza |
| `rag-lite` | Scripts de ingesta respaldados por Qdrant mas un agente de busqueda |

`symbi new` y `symbi init` son complementarios: `new` te da un punto de partida especifico para una tarea, `init` (+ `--catalog`) te da uno especifico para gobernanza. Tambien puedes combinar — genera el esqueleto con `new` y luego ejecuta `symbi init --catalog ...` para incorporar agentes preconstruidos adicionales desde el catalogo.

---

## Tu Primer Agente

Vamos a crear un agente simple de analisis de datos para entender los conceptos basicos de Symbi.

### 1. Crear Definicion de Agente

Crear un nuevo archivo `my_agent.symbi`:

```rust
metadata {
    version = "1.0.0"
    author = "your-name"
    description = "My first Symbi agent"
}

agent greet_user(name: String) -> String {
    capabilities = ["greeting", "text_processing"]

    policy safe_greeting {
        allow: read(name) if name.length <= 100
        deny: store(name) if name.contains_sensitive_data
        audit: all_operations with signature
    }

    with memory = "ephemeral", privacy = "low" {
        if (validate_name(name)) {
            greeting = format_greeting(name);
            audit_log("greeting_generated", greeting.metadata);
            return greeting;
        } else {
            return "Hello, anonymous user!";
        }
    }
}
```

### 2. Ejecutar el Agente

```bash
# Parse and validate the agent definition
cargo run -- dsl parse my_agent.symbi

# Run the agent in the runtime
cd crates/runtime && cargo run --example basic_agent -- --agent ../../my_agent.symbi
```

---

## Entendiendo el DSL

El DSL de Symbi tiene varios componentes clave:

### Bloque de Metadatos

```rust
metadata {
    version = "1.0.0"
    author = "developer"
    description = "Agent description"
}
```

Proporciona informacion esencial sobre tu agente para documentacion y gestion del runtime.

### Definicion de Agente

```rust
agent agent_name(parameter: Type) -> ReturnType {
    capabilities = ["capability1", "capability2"]
    // agent implementation
}
```

Define la interfaz, capacidades y comportamiento del agente.

### Definiciones de Politicas

```rust
policy policy_name {
    allow: action_list if condition
    deny: action_list if condition
    audit: operation_type with audit_method
}
```

Politicas de seguridad declarativas que se aplican en tiempo de ejecucion.

### Contexto de Ejecucion

```rust
with memory = "persistent", privacy = "high" {
    // agent implementation
}
```

Especifica la configuracion de runtime para gestion de memoria y requisitos de privacidad.

---

## Siguientes Pasos

### Explorar Ejemplos

El repositorio incluye varios agentes de ejemplo:

```bash
# Basic agent example
cd crates/runtime && cargo run --example basic_agent

# Full system demonstration
cd crates/runtime && cargo run --example full_system

# Context and memory example
cd crates/runtime && cargo run --example context_example

# RAG-powered agent
cd crates/runtime && cargo run --example rag_example
```

### Habilitar Funciones Avanzadas

#### API HTTP (Opcional)

```bash
# Enable the HTTP API feature
cd crates/runtime && cargo build --features http-api

# Run with API endpoints
cd crates/runtime && cargo run --features http-api --example full_system
```

**Endpoints de API Principales:**
- `GET /api/v1/health` - Verificacion de salud y estado del sistema
- `GET /api/v1/agents` - Listar todos los agentes activos con estado de ejecucion en tiempo real
- `GET /api/v1/agents/{id}/status` - Obtener metricas detalladas de ejecucion del agente
- `POST /api/v1/workflows/execute` - Ejecutar flujos de trabajo

**Nuevas Funciones de Gestion de Agentes:**
- Monitoreo de procesos en tiempo real y verificaciones de salud
- Capacidades de apagado gracioso para agentes en ejecucion
- Metricas de ejecucion completas y seguimiento de uso de recursos
- Soporte para diferentes modos de ejecucion (efimero, persistente, programado, basado en eventos)

#### Inferencia LLM en la Nube

Conecta a proveedores de LLM en la nube via OpenRouter:

```bash
# Enable cloud inference
cargo build --features cloud-llm

# Set API key and model
export OPENROUTER_API_KEY="sk-or-..."
export OPENROUTER_MODEL="google/gemini-2.0-flash-001"  # optional
```

#### Modo Agente Autonomo

Una sola linea para agentes nativos de la nube con inferencia LLM:

```bash
cargo build --features standalone-agent
# Enables: cloud-llm
```

> **Note:** Composio MCP and SymbiBot integration were removed in this version due to security concerns — see SECURITY_AUDIT.md C3 for context.

#### Primitivas de Razonamiento Avanzado

Habilita curacion de herramientas, deteccion de bucles atascados, pre-carga de contexto y convenciones con alcance:

```bash
cargo build --features orga-adaptive
```

Consulta la [guia de orga-adaptive](/orga-adaptive) para la documentacion completa.

#### Motor de Politicas Cedar

Autorizacion formal con el lenguaje de politicas Cedar. **Activado por defecto desde v1.14.x**: los binarios publicados de `symbi` (crates.io, Docker, tarballs de GitHub Release) incluyen Cedar, y `symbi up` / `symbi run` autocablean `CedarPolicyGate` desde los archivos `policies/*.cedar` al arranque; si no hay ninguno presente, el runtime recae en el `DefaultPolicyGate` fail-closed. Para construir sin Cedar (por ejemplo, cuando pretendes cablear `OpaPolicyGateBridge` o un `ReasoningPolicyGate` personalizado en su lugar), usa:

```bash
cargo build --no-default-features --features "keychain,vector-lancedb"  # drop cedar
```

#### Base de Datos Vectorial (Integrada)

Symbi incluye LanceDB como base de datos vectorial embebida sin configuracion. La busqueda semantica y RAG funcionan de inmediato -- no se necesita iniciar ningun servicio separado:

```bash
# Run agent with RAG capabilities (vector search just works)
cd crates/runtime && cargo run --example rag_example

# Test context management with advanced search
cd crates/runtime && cargo run --example context_example
```

> **Compilacion minima:** LanceDB se incluye por defecto, pero puede excluirse para binarios mas ligeros: `cargo build --no-default-features`. El runtime recurre de forma transparente a un backend vectorial no operativo.
>
> **Despliegues a escala:** Qdrant esta disponible como backend opcional. Compila con `--features vector-qdrant` y define `SYMBIONT_VECTOR_BACKEND=qdrant`.

**Funciones de Gestion de Contexto:**
- **Busqueda Multi-Modal**: Modos de busqueda por palabra clave, temporal, similitud e hibrido
- **Calculo de Importancia**: Algoritmo de puntuacion sofisticado considerando patrones de acceso, recencia y retroalimentacion del usuario
- **Control de Acceso**: Integracion del motor de politicas con controles de acceso por agente
- **Archivado Automatico**: Politicas de retencion con almacenamiento comprimido y limpieza
- **Compartir Conocimiento**: Comparticion segura de conocimiento entre agentes con puntuaciones de confianza

#### Referencia de Feature Flags

| Feature | Descripcion | Por defecto |
|---------|-------------|-------------|
| `keychain` | Integracion de llavero del SO para secretos | Si |
| `vector-lancedb` | Backend vectorial embebido LanceDB | Si |
| `vector-qdrant` | Backend vectorial distribuido Qdrant | No |
| `embedding-models` | Modelos de embedding locales via Candle | No |
| `http-api` | API REST con Swagger UI | No |
| `http-input` | Servidor webhook con autenticacion JWT | No |
| `cloud-llm` | Inferencia LLM en la nube (OpenRouter) | No |
| `standalone-agent` | Meta-feature Cloud LLM | No |
| `cedar` | Motor de politicas Cedar — autocableado desde `policies/*.cedar` al arranque | **Yes** |
| `orga-adaptive` | Primitivas de razonamiento avanzado | No |
| `cron` | Programacion cron persistente | No |
| `cli-executor` | Subprocesos de CLI de IA gobernados (Claude Code, etc.) — Modo B | **Yes** |
| `native-sandbox` | Sandboxing nativo de procesos | No |
| `metrics` | Metricas/trazado OpenTelemetry | No |
| `interactive` | Prompts interactivos para `symbi init` (dialoguer) | Si |
| `full` | Todas las funciones opcionales de runtime, vectoriales y de politicas | No |

```bash
# Build with specific features
cargo build --features "cloud-llm,orga-adaptive,cedar"

# Build with everything
cargo build --features full
```

---

## Plugins para Asistentes de IA

Symbiont proporciona plugins de gobernanza propios para asistentes de programacion con IA populares, con tres niveles progresivos de proteccion:

1. **Awareness** (por defecto) — registro consultivo de todas las llamadas a herramientas que modifican estado
2. **Protection** — un hook de bloqueo aplica una lista local de denegacion (`.symbiont/local-policy.toml`)
3. **Governance** — evaluacion de politicas Cedar cuando `symbi` esta en el PATH

La configuracion de la lista de denegacion es agnostica respecto a la herramienta — el mismo `.symbiont/local-policy.toml` funciona con ambos plugins:

```toml
[deny]
paths = [".env", ".ssh/", ".aws/"]
commands = ["rm -rf", "git push --force"]
branches = ["main", "master", "production"]
```

### Claude Code

```bash
# Install from marketplace
/plugin marketplace add https://github.com/thirdkeyai/symbi-claude-code

# Available skills: /symbi-init, /symbi-policy, /symbi-verify, /symbi-audit, /symbi-dsl
```

Consulta [symbi-claude-code](https://github.com/thirdkeyai/symbi-claude-code) para mas detalles.

#### Modo B: subproceso gobernado de Claude Code

Mas alla de los hooks integrados en el editor, Symbiont puede ejecutar Claude Code como un *subproceso gobernado* — la ruta del "Modo B" (gestionado por ORGA). Un agente cuyos metadatos declaran `executor = "claude_code"` se ejecuta lanzando Claude Code bajo el `CliExecutor` del runtime en lugar del bucle de razonamiento del LLM. El agente `code_reviewer` incluido es el ejemplo de referencia:

```bash
# Review a working tree with a governed Claude Code subprocess
symbi run code_reviewer --target /path/to/repo

# Bounds: --max-turns is the primary (cooperative) limit; --budget-timeout is a
# hard wall-clock backstop (graceful SIGTERM -> SIGKILL).
symbi run code_reviewer --target . --max-turns 12 --budget-timeout 15m
```

En cada ejecucion Symbiont:

- evalua el lanzamiento a traves del **Gate** de politicas (fail-closed — permitelo mediante una politica Cedar, o `SYMBI_INSECURE_ALLOW_ALL=1` para desarrollo local);
- establece el handshake de entorno (`SYMBIONT_MANAGED=true`, `SYMBIONT_SESSION_ID`, `SYMBIONT_BUDGET_TOKENS`, `SYMBIONT_BUDGET_TIMEOUT`, `CLAUDE_PROJECT_DIR`) para que el plugin symbi-claude-code **delegue** sus hooks al Gate externo;
- carga el plugin mediante `--plugin-dir` y conecta el canal de retorno stdio `symbi mcp` mediante `--mcp-config --strict-mcp-config`;
- ejecuta Claude Code en modo headless (`--print --output-format json --permission-mode dontAsk`).

| Variable / flag | Purpose | Default |
|---|---|---|
| `SYMBIONT_CLAUDE_PLUGIN_DIR` | Ruta al plugin symbi-claude-code | autodeteccion del repositorio hermano |
| `--plugin-dir` | Sobrescribe la ruta del plugin para una ejecucion | — |
| `--target` | Directorio de trabajo sobre el que operar | directorio actual |
| `--max-turns` | Limite cooperativo primario (turnos agenticos) | 12 |
| `--budget-timeout` | Backstop de tiempo de reloj, p. ej. `15m` / `900s` | 15m |
| `--budget-tokens` | Sugerencia de presupuesto de tokens pasada al subproceso (awareness) | 100000 |

> **Auth:** el subproceso utiliza la propia autenticacion de Claude Code — una sesion iniciada (`claude /login`) o `ANTHROPIC_API_KEY`. La funcion `cli-executor` esta activada por defecto.

### Gemini CLI

```bash
# Install extension
gemini extensions install https://github.com/thirdkeyai/symbi-gemini-cli
```

La extension de Gemini CLI proporciona una defensa en profundidad adicional mediante el bloqueo del manifiesto `excludeTools` y la aplicacion nativa de `policies/*.toml` a nivel de plataforma.

Consulta [symbi-gemini-cli](https://github.com/thirdkeyai/symbi-gemini-cli) para mas detalles.

---

## Configuracion

### Variables de Entorno

Configura tu entorno para rendimiento optimo:

```bash
# Required: 32-byte hex key used to encrypt persistent state.
# Generate with: openssl rand -hex 32
# `symbi init` writes one into .env automatically.
export SYMBIONT_MASTER_KEY="..."

# Basic configuration
export SYMBI_LOG_LEVEL=info
export SYMBI_RUNTIME_MODE=development

# La busqueda vectorial funciona de inmediato con el backend LanceDB integrado.
# Para usar Qdrant en su lugar (opcional, habilita la feature `vector-qdrant`):
# export SYMBIONT_VECTOR_BACKEND=qdrant
# export QDRANT_URL=http://localhost:6333

# MCP integration (optional)
export MCP_SERVER_URLS="http://localhost:8080"
```

#### Variables de Entorno Relacionadas con Seguridad (auditoria posterior a v1.13.0)

| Variable | Por defecto | Efecto |
|---|---|---|
| `SYMBI_INSECURE_ALLOW_ALL` | sin establecer | Cuando se establece a `1`, `symbi up` / `symbi run` usan la compuerta de politicas permisiva (toda llamada a herramienta y toda delegacion se permite). Equivalente al flag `--insecure-allow-all`. Se imprime un banner ruidoso en stderr. **Solo para desarrollo local.** Sin esto, el bucle de razonamiento es fail-closed y rechaza llamadas a herramientas y delegaciones hasta que se conecte un backend de politicas explicito. |
| `SYMBI_REJECT_LEGACY_API_KEYS` | sin establecer | Cuando se establece a `1`, el validador de claves de API corta circuito el escaneo Argon2 O(n) obsoleto para las claves sin prefijo. Uselo inmediatamente despues de reemitir cada clave en formato `keyid.secret`. La ruta heredada se eliminara en la proxima release menor de todos modos. |
| `SYMBI_UNSAFE_NATIVE_SANDBOX` | sin establecer | Requerido (ademas de `SYMBI_ENV=production`-no-establecido) para construir el runner de sandbox `native`. El feature Cargo `native-sandbox` ademas falla al compilar en builds release. El runner nativo no proporciona aislamiento y esta destinado unicamente a depuracion local. |
| `SYMBI_TRUSTED_PROXIES` | sin establecer | Lista de permitidos CIDR para proxies reversos de confianza; `X-Forwarded-For` solo se honra desde estas direcciones. |

Las siguientes variables de entorno fueron **eliminadas**:

- `SYMBIONT_ALLOW_NO_JWT_AUDIENCE` — el verificador JWT ahora siempre requiere `aud`. (Eliminada en la auditoria posterior a v1.13.0; era una escotilla de escape no segura.)
- `COMPOSIO_API_KEY`, `COMPOSIO_MCP_URL` — la integracion de Composio MCP fue eliminada por completo. Consulta `SECURITY_AUDIT.md` C3.

### Configuracion de Runtime

Crear un archivo de configuracion `symbi.toml`:

```toml
[runtime]
max_agents = 1000
memory_limit_mb = 512
execution_timeout_seconds = 300

[security]
default_sandbox_tier = "docker"
audit_enabled = true
policy_enforcement = "strict"

[vector_db]
enabled = true
backend = "lancedb"              # default; also supports "qdrant"
collection_name = "symbi_knowledge"
# url = "http://localhost:6333"  # only needed when backend = "qdrant"
```

---

## Problemas Comunes

### Problemas con Docker

**Problema**: La construccion de Docker falla con errores de permisos
```bash
# Solution: Ensure Docker daemon is running and user has permissions
sudo systemctl start docker
sudo usermod -aG docker $USER
```

**Problema**: El contenedor sale inmediatamente
```bash
# Solution: Check Docker logs
docker logs <container_id>
```

### Problemas de Construccion con Rust

**Problema**: La construccion de Cargo falla con errores de dependencias
```bash
# Solution: Update Rust and clean build cache
rustup update
cargo clean
cargo build
```

**Problema**: Faltan dependencias del sistema
```bash
# Ubuntu/Debian
sudo apt-get update
sudo apt-get install build-essential pkg-config libssl-dev

# macOS
brew install pkg-config openssl
```

### Problemas de Runtime

**Problema**: El agente falla al iniciar
```bash
# Check agent definition syntax
cargo run -- dsl parse your_agent.symbi

# Enable debug logging
RUST_LOG=debug cd crates/runtime && cargo run --example basic_agent
```

---

## Obtener Ayuda

### Documentacion

- **[Guia DSL](/dsl-guide)** - Referencia completa del DSL
- **[Arquitectura del Runtime](/runtime-architecture)** - Detalles de arquitectura del sistema
- **[Modelo de Seguridad](/security-model)** - Documentacion de seguridad y politicas

### Soporte de la Comunidad

- **Issues**: [GitHub Issues](https://github.com/thirdkeyai/symbiont/issues)
- **Discusiones**: [GitHub Discussions](https://github.com/thirdkeyai/symbiont/discussions)
- **Documentacion**: [Referencia Completa de API](https://docs.symbiont.dev/api-reference)

### Modo de Depuracion

Para solucion de problemas, habilitar logging detallado:

```bash
# Enable debug logging
export RUST_LOG=symbi=debug

# Run with detailed output
cd crates/runtime && cargo run --example basic_agent 2>&1 | tee debug.log
```

---

## ¿Que Sigue?

Ahora que tienes Symbi ejecutandose, explora estos temas avanzados:

1. **[Guia DSL](/dsl-guide)** - Aprende funciones avanzadas del DSL
2. **[Guia del Bucle de Razonamiento](/reasoning-loop)** - Entiende el ciclo ORGA
3. **[Razonamiento Avanzado (orga-adaptive)](/orga-adaptive)** - Curacion de herramientas, deteccion de bucles atascados, pre-hidratacion
4. **[Arquitectura del Runtime](/runtime-architecture)** - Entiende los internos del sistema
5. **[Modelo de Seguridad](/security-model)** - Implementa politicas de seguridad
6. **[Contribuir](/contributing)** - Contribuye al proyecto

¿Listo para construir algo increible? Comienza con nuestros [proyectos de ejemplo](https://github.com/thirdkeyai/symbiont/tree/main/crates/runtime/examples) o sumergete en la [especificacion completa](/dsl-specification).
