Claude Code Automatización MacOS Agentes Productividad

Cómo convertir tu Mac en un agente autónomo con Claude Code y Codex

5 min de lectura

El concepto

La idea es simple: una Mac Air M1 corriendo Claude Code de forma permanente, funcionando como un agente personal que podés controlar desde el celular. Le mandás tareas desde Telegram o la app de Claude, y mientras vos caminás, el agente lee tu backlog, ejecuta código, crea PRs en GitHub, sincroniza con Notion, y te avisa cuando termina.

No es ciencia ficción. Con las herramientas que Anthropic lanzó en los últimos meses — Remote Control, Channels, Skills, Subagentes, y Hooks — esto se puede armar en una tarde.

Este tutorial documenta el setup completo que armamos paso a paso, incluyendo la integración con Obsidian para gestionar tareas, Notion como backup, GitHub para repos, y Codex CLI de OpenAI como segundo agente para code review.

Qué vas a necesitar

Hardware:

  • Mac con Apple Silicon (M1 o superior). Usamos una Mac Air M1 pero funciona con cualquier Mac moderna.
  • La Mac tiene que estar encendida y conectada a corriente 24/7.

Suscripciones:

  • Claude Pro ($20/mes mínimo) o Max ($100-200/mes para más headroom). Remote Control requiere Pro como mínimo.
  • Cuenta de GitHub con un Fine-grained Personal Access Token.
  • Cuenta de Notion (el free tier funciona).
  • Cuenta de ChatGPT (Plus o superior) si querés usar Codex CLI.

Software que vamos a instalar:

  • Claude Code CLI (npm)
  • tmux (brew)
  • Bun (para plugins/channels)
  • Codex CLI (npm, opcional)
  • Obsidian (para visualizar el backlog)

Arquitectura del sistema

El sistema tiene tres capas:

Capa de control — cómo le das instrucciones al agente:

  • App de Claude en el teléfono (Remote Control)
  • Telegram (Channels)
  • Terminal directa (tmux)
  • Crons del sistema operativo (automático)

Capa de agentes — quién ejecuta el trabajo:

  • Claude Code como agente principal (tareas, PRDs, código, comunicación)
  • Codex CLI como agente secundario (code review, tests, segunda opinión)

Capa de herramientas — dónde se conecta:

  • Obsidian vault (backlog local en markdown)
  • Notion (backup y visibilidad)
  • GitHub (repos, PRs, issues)
  • Gmail y Google Calendar (conectores nativos de claude.ai)

Paso 1: Instalar los prerequisitos

Terminal window
# Homebrew (si no lo tenés)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"


# Node.js, tmux, y Bun
brew install node tmux
curl -fsSL https://bun.sh/install | bash
exec /bin/zsh


# Verificar
echo "Node: $(node --version) | tmux: $(tmux -V) | Bun: $(bun --version)"

Si zsh intenta corregir tmux a _tmux, solucionalo con:

Terminal window
echo 'alias tmux="nocorrect tmux"' >> ~/.zshrc
source ~/.zshrc

Paso 2: Instalar Claude Code y autenticarse

Terminal window
npm install -g @anthropic-ai/claude-code
claude --version  # Necesitás v2.1.80+

Abrí una sesión para loguearte:

Terminal window
cd ~
claude

Dentro de Claude Code:

/login          # Abre el navegador para OAuth con tu cuenta Pro/Max
/config         # Habilitar "Enable Remote Control for all sessions" → true
/exit

Paso 3: Crear la estructura de carpetas

Todo el workspace vive dentro de una sola carpeta. Claude Code solo trabaja acá.

Terminal window
# Workspace contenedor
mkdir -p ~/claude-setup/{vault/backlog/{pending,in-progress,done},vault/prd,vault/daily-logs,projects}


# Configuración de Claude Code (skills, agentes, scripts)
mkdir -p ~/.claude/skills/{backlog-manager,notion-sync,daily-standup,pr-creator,run-codex}
mkdir -p ~/.claude/{agents,scripts}

Paso 4: El CLAUDE.md global

Este es el archivo más importante del setup. Claude lo lee al inicio de cada sesión y contiene todas las reglas, convenciones, y contexto que necesita para trabajar como vos querés.

Terminal window
cat > ~/.claude/CLAUDE.md << 'EOF'
# Global Configuration


## Workspace
Everything lives inside ~/claude-setup/
- Vault (Obsidian backlog): ~/claude-setup/vault/
- Projects: ~/claude-setup/projects/
- Do NOT access files outside ~/claude-setup/ unless explicitly asked


## Task system
- Backlog lives in ~/claude-setup/vault/backlog/
- Tasks are markdown with YAML frontmatter (status, priority, project, type, assigned_to)
- Statuses: pending → in-progress → done
- Priorities: critical > high > medium > low
- When completing a task, move file to done/ and update frontmatter
- Write daily log in ~/claude-setup/vault/daily-logs/YYYY-MM-DD.md


## Code conventions
- TypeScript strict mode
- Functional components
- Conventional commits (feat:, fix:, chore:)
- Run tests before committing
EOF

Adaptá este archivo con tus propias convenciones, stack tecnológico, y nombre.

Paso 5: Crear los Skills

Los skills son archivos SKILL.md que enseñan a Claude cómo hacer tareas específicas. Se cargan on-demand y consumen solo 30-50 tokens cada uno hasta que se activan.

El skill más importante es el gestor de backlog:

Terminal window
cat > ~/.claude/skills/backlog-manager/SKILL.md << 'EOF'
---
name: backlog-manager
description: Use when managing tasks, reading the backlog, creating or updating tasks in the Obsidian vault
allowed-tools: Read, Write, Edit, Bash, Grep, Glob
---


# Backlog Manager


## Vault location
~/claude-setup/vault/backlog/


## Task file format
Files named YYYY-MM-DD-short-description.md with YAML frontmatter:
status, priority, project, type, assigned_to, created, completed


## Rules
1. Pick highest priority pending task with assigned_to: claude-code
2. Change status to in-progress before starting
3. After completing, move to done/ and add completed date
4. Write log entry in daily-logs/
EOF

Creá skills adicionales para sincronización con Notion, generación de standups, creación de PRs, y delegación a Codex. El formato siempre es el mismo: frontmatter YAML con nombre y descripción, seguido de instrucciones en markdown.

Paso 6: Crear los Subagentes

Los subagentes son instancias especializadas de Claude que corren en su propio contexto. A diferencia de los skills (instrucciones), los subagentes son workers independientes.

Terminal window
cat > ~/.claude/agents/task-runner.md << 'EOF'
---
name: task-runner
description: Autonomous task executor for processing the backlog
tools: Read, Write, Edit, Bash, Grep, Glob
model: sonnet
memory: project
permissionMode: acceptEdits
---


You are an autonomous task execution agent.
Read ~/claude-setup/vault/backlog/pending/, pick the highest
priority task, execute it, update status, and write a log.
EOF

Paso 7: Configurar los Hooks

Los hooks ejecutan código automáticamente en momentos específicos del ciclo de vida de Claude Code. Se configuran en ~/.claude/settings.json:

{
  "hooks": {
    "SessionStart": [{
      "hooks": [{
        "type": "command",
        "command": "~/.claude/scripts/inject-date.sh"
      }]
    }],
    "Notification": [{
      "hooks": [{
        "type": "command",
        "command": "~/.claude/scripts/notify.sh \"$CLAUDE_NOTIFICATION\""
      }]
    }]
  }
}

Los scripts de soporte:

Terminal window
# inject-date.sh — le dice a Claude qué día es hoy
echo "Today is $(date '+%A, %B %d, %Y'). Current time: $(date '+%H:%M %Z')."


# notify.sh — notificación nativa de macOS
osascript -e "display notification \"$1\" with title \"Claude Code\" sound name \"Glass\""

Paso 8: Conectar los MCP Servers

Los MCPs conectan a Claude con servicios externos. Solo necesitás MCPs para cosas que no están en tu filesystem local.

Terminal window
# Notion (oficial, hosteado por Notion)
claude mcp add --transport http notion https://mcp.notion.com/mcp --scope user


# GitHub (necesita un Fine-grained Personal Access Token)
claude mcp add --transport stdio github --env GITHUB_TOKEN=tu_token -- npx -y @modelcontextprotocol/server-github --scope user


# Slack (oficial, si lo usás)
claude mcp add --transport http slack https://mcp.slack.com/mcp --scope user

Para Obsidian no necesitás MCP. El vault son archivos markdown en tu disco — Claude los lee directamente con sus herramientas nativas (Read, Write, Edit, Bash).

Para GitHub, usá un Fine-grained Personal Access Token (no classic) que limite el acceso a repos específicos. Crealo en GitHub → Settings → Developer Settings → Fine-grained tokens, seleccionando “Only select repositories” y dándole solo permisos de Contents, Pull Requests, e Issues.

Los MCPs que requieren OAuth (Notion, Slack) se autentican la primera vez que los usás dentro de Claude Code.

Paso 9: La sesión always-on con tmux

tmux es un multiplexor de terminal que mantiene procesos corriendo aunque cierres la ventana. Es la pieza que hace posible el “always-on”.

Script de arranque:

cat > ~/.claude/scripts/start-agent.sh << 'EOF'
#!/bin/bash
SESSION_NAME="claude-agent"


if tmux has-session -t $SESSION_NAME 2>/dev/null; then
    echo "Session '$SESSION_NAME' already running."
    exit 0
fi


tmux new-session -d -s $SESSION_NAME
tmux send-keys -t $SESSION_NAME 'cd ~/claude-setup/projects && claude --remote-control --dangerously-skip-permissions' Enter


echo "Claude agent started in tmux session '$SESSION_NAME'"
echo "Attach: tmux attach -t $SESSION_NAME"
echo "Detach: Ctrl+B, then D"
echo "Kill:   tmux kill-session -t $SESSION_NAME"
EOF
chmod +x ~/.claude/scripts/start-agent.sh

Para usarlo:

Terminal window
~/.claude/scripts/start-agent.sh           # Lanzar
tmux attach -t claude-agent                 # Ver la sesión
# Ctrl+B, D                                # Desattacharte
tmux kill-session -t claude-agent           # Matar

Una vez corriendo, copiá la URL de Remote Control y abrila en el teléfono. A partir de ahí, todo se controla desde el celular.

Nota sobre --dangerously-skip-permissions: este flag le da a Claude acceso total sin confirmación. Es necesario para que funcione de forma autónoma (sin que se quede esperando tu OK para cada operación), pero significa que Claude puede ejecutar cualquier comando. Por eso limitamos su alcance en el CLAUDE.md a ~/claude-setup/.

Paso 10: Crons para automatización

Los crons del sistema operativo ejecutan tareas periódicamente usando Claude Code en modo headless (-p). Cada ejecución arranca una sesión limpia.

Terminal window
# crontab -e
# Ejecutar tareas del backlog cada 2 horas
0 */2 * * * ~/.claude/scripts/cron-wrapper.sh backlog


# Sincronizar a Notion cada 4 horas
0 */4 * * * ~/.claude/scripts/cron-wrapper.sh sync


# Standup diario a las 9pm
0 21 * * * ~/.claude/scripts/cron-wrapper.sh standup

En macOS, necesitás darle Full Disk Access a /usr/sbin/cron en System Settings → Privacy & Security para que los crons funcionen.

Codex como segundo agente

Opcionalmente, podés instalar Codex CLI de OpenAI como agente secundario para code review y testing:

Terminal window
npm install -g @openai/codex

El skill run-codex y el subagente codex-reviewer que configuramos lo usan así:

Terminal window
codex exec "Review these files for bugs and security issues" --sandbox read-only

Claude Code orquesta: decide cuándo delegar a Codex, le pasa el contexto, recibe el resultado, y lo integra con su propio análisis. Es un segundo par de ojos automático.

El workflow diario

  1. Al prender la Mac: ~/.claude/scripts/start-agent.sh
  2. Crear tareas: desde el teléfono vía Remote Control, o creando archivos en ~/claude-setup/vault/backlog/pending/
  3. Claude ejecuta: automáticamente (crons) o bajo demanda (cuando le pedís desde el teléfono)
  4. Revisás resultados: en Obsidian, en Notion, o preguntándole “qué hiciste hoy”
  5. Code review: Codex revisa automáticamente cuando Claude le delega

Gestión de contexto

La sesión de Remote Control acumula contexto. Para mantenerlo limpio:

  • Los crons siempre corren en sesiones aisladas (contexto limpio cada vez)
  • Los subagentes corren en su propio contexto (no ensucian la sesión principal)
  • Reiniciar la sesión: tmux kill-session -t claude-agent && ~/.claude/scripts/start-agent.sh
  • Con Opus 4.6 tenés 1M de tokens de contexto, así que tarda mucho en llenarse
  • Claude hace compactación automática cuando se acerca al límite

Limitaciones a tener en cuenta

  • La Mac debe estar encendida y despierta para que todo funcione
  • --dangerously-skip-permissions le da acceso total. Usalo solo en tu máquina personal
  • Los Fine-grained tokens de GitHub expiran (recomiendo 90 días) y hay que renovarlos
  • La sincronización Obsidian → Notion es unidireccional. Notion es solo un espejo
  • Remote Control genera una URL nueva cada vez que reiniciás la sesión
  • Cada ejecución de cron consume tokens de tu plan de Claude

Próximos pasos

  • Telegram Channel: controlar el agente desde Telegram en vez de (o además de) Remote Control
  • Agent Teams: para tareas grandes, lanzar equipos de agentes que trabajan en paralelo
  • Más MCPs: Slack, Linear, Figma, Playwright para testing visual
  • Codex Cloud: cuando OpenAI lo lance, las tareas de Codex podrían correr en la nube sin depender de tu Mac
  • Claude Code on the web: Anthropic está desarrollando sesiones cloud que no dependen de tu máquina local

Setup armado en marzo 2026 usando Claude Code v2.1.80+, Codex CLI, y macOS Sequoia en Mac Air M1.