Aleph Scriptorium — Entorno Integrado Agéntico

Del procesador de textos tradicional (Word + Clippy) al entorno de escritura asistida (Aleph Scriptorium + @ox).

Tipo: Blueprint de Producto (Opportunities)
Versión: 1.1.0 — integration/beta/scriptorium
Última revisión: 2026-01-06

Índice de Contenidos

• Parte I: El Escritorio — Infraestructura y configuración
• Parte II: La Escritura — Diseño y lógica
• Parte III: El Escribir — Producción y publicación
• Parte IV: El Escritor — Operativa diaria
• Referencias

Parte I: El Escritorio

1. Breviario

Diferencia fundamental: Clippy ofrecía tips predefinidos. Tú creas y diseñas a Ox para que orqueste a los agentes según tus flujos y procesos cotidianos.

💡 Una herramienta de escritura que se adapta al escritor, no al revés.

Para aprender a hablar con los agentes: VS Code Copilot Guides, :-D.

2. Producto Mínimo Viable: Scriptorium

La elección de VS Code no es arbitraria. Es un editor FOSS extensible que también funciona como servidor web (code-server), permitiendo el mismo entorno en escritorio o navegador. Su marketplace de extensiones es el ecosistema más grande para herramientas de desarrollo.

→ VS Code API

Motor Conversacional

La extensión GitHub Copilot Chat aporta el motor conversacional. Internamente, Copilot construye un system message que combina las instrucciones del sistema (copilot-instructions.md) con las del contexto del workspace y el prompt de usuario.

El submódulo CopilotEngine es una captura de la extensión mantenida por Microsoft para que puedas entender —y eventualmente modificar— cómo piensa tu asistente. Y, además, para que el asistente pueda ver cómo es por dentro.

→ Copilot Overview

Sobre esta base, Scriptorium añade otras extensiones:

Extensión Arrakis

Arrakis Extension es la interfaz visual del Scriptorium. Sus tres paneles (Settings, CMD, MENU) exponen la configuración, comandos y servicios.

Para amantes de lo que “surge” cuando lo invocas: lo mejor de las UIs que “aparecen”; y para los amantes de deslizarse en miles de menús anidados: añade y refactoriza los paneles que necesites para tu día a día.

La extensión se puede personalizar con “flavours” según el tipo de proyecto y el área técnica.

→ Creating Extensions

Curva de aprendizaje: Si usas VS Code, ya tienes el 70% del camino recorrido. Scriptorium añade agentes y paneles, no reemplaza el editor.

3. Arquitectura de SDKs

Aleph Scriptorium distribuye su código en distintos ámbitos:

La tendencia es mover el máximo código posible a librerías npm modulares en MCPGallery:

4. Instalación y Estructura

Scriptorium es un repositorio Git con submódulos opcionales:

# Instalación completa
git clone https://github.com/escrivivir-co/aleph-scriptorium
git submodule update --init --recursive

# O añadir capacidades progresivamente
git submodule update --init MCPGallery

Filosofía central: El editor se adapta al escritor, no al revés.

Estrategia de ampliación ad hoc:

• a) Trae una herramienta agregándola como submódulo. Ponla a punto.
• b) Mapea con un plugin la funcionalidad para sumarla al scriptorium. Sigue pautas generales o crea tu propio camino.

Flujo: Submódulo → Plugin → Tu Scriptorium

┌─────────────────────────────────────────────────────────────────────┐
│  1. IDE VS Code                                                     │
│     ├── workspace-config.json                                       │
│     └── scripts/setup-workspace.sh                                  │
├─────────────────────────────────────────────────────────────────────┤
│  2. Submódulo (herramienta externa)                                 │
│     ├── Prompt: .github/prompts/as_instalar_submodulo.prompt.md     │
│     └── Git: .gitmodules                                            │
├─────────────────────────────────────────────────────────────────────┤
│  3. Plugin (mapea la herramienta)                                   │
│     ├── Prompt: .github/prompts/as_plugin-install.prompt.md         │
│     └── Registro: .github/plugins/registry.json                     │
├─────────────────────────────────────────────────────────────────────┤
│  4. Configuración                                                   │
│     ├── Agente bridge (@plugin_ox_*)  → .github/agents/             │
│     ├── Copilot Locations             → .vscode/settings.json       │
│     ├── Datos                         → ARCHIVO/PLUGINS/{ID}/       │
│     └── Sistema                       → .github/plugins/{id}/       │
│         ├── manifest.md                                             │
│         ├── instructions/                                           │
│         ├── prompts/                                                │
│         ├── agents/                                                 │
│         └── schemas/                                                │
├─────────────────────────────────────────────────────────────────────┤
│  5. UI (opcional)                                                   │
│     └── Hacker Panels → VsCodeExtension/src/views/                  │
├─────────────────────────────────────────────────────────────────────┤
│  6. Tu Scriptorium (único)                                          │
└─────────────────────────────────────────────────────────────────────┘

Cada submódulo es una herramienta externa (un editor, un servidor, una librería). El sistema de plugins la integra al ecosistema de agentes. El scriptorium-pack viene preinstalado. A partir de ahí, tú decides qué añadir:

Con el tiempo, tu instalación refleja tu forma de trabajar.

Arquitectura DRY

Dos principios organizan el contenido:

Separación de memorias:

• ARCHIVO: Texto clasificado y permanente (enciclopedias, novelas, documentación)
• DISCO: Datos crudos y trabajo en progreso (sesiones, borradores, snapshots)

Índices únicos:

• Funcional.md: Qué puede hacer el sistema (visión usuario)
• Tecnico.md: Dónde está cada componente (visión desarrollador)

Criterio Don’t Repeat Yourself: Los plugins y agentes consultan estos índices en lugar de duplicar información.

5. GitHub Copilot Chat y Context Bloat

Flujo de Trabajo con el Modelo

El trabajo agéntico pasa por 3 momentos. Ver blueprint-copilot.md.

Al enviar un mensaje:

• Herramientas MCP disponibles
• Mensajes de sistema
• Datos de contexto
• Caché
• Intención de usuario

Mientras el modelo trabaja:

• Consola de Copilot Chat en OUTPUT → Debugging
• Output en ventana de chat → Smart Actions
• Cambios en codebase → Source Control

Gestión del Context Bloat

Cada modelo tiene un coste y también un tamaño máximo de contexto. Cuando más contexto se añade a una consulta más tarda, más cuesta pero más precisas y certera será.

Microsoft ya agrega un capa de contexto con mensajes de sistema. Este es un primera handicap para Aleph Scriptorium que está pendiente: fork de la extensión (CopilotEngine) para poder customizar con “flavours” de mensajes-sistema no especificos de coding. Falta investigar si también hay que cambiar el endpoint de los modelos porque sea uso no autorizado.

Cuando se hace una consulta y el modelo responde, empieza un hilo: “conversación”. Vs Code implementa una función de “resumir y continuar”. Esto hace que la ventana de contexto se vaya moviendo comprimiendo el pasado y dejando sitio para el presente. Aquí Microsoft también agrega para mensajería de sistema para la operativa, dando preferencia al final de la conversacion, y operando con los “restore” y “edit” que el usuario puede hacer en el chat. Instrucciones de sistema para guardar lo deshecho como ejemplo de “qué no hacer”. Internamente, cachea documentos frecuentes que suelen acompañar todas las interacciones. Este es el segundo punto abierto de este proyecto, relacionado con lo anterior. ¿Hasta que punto es posible extraer esta lógica y exponerla para que el usuario pueda incluirla en su “flavour”?

La CopilotEngine carga en el chat todos los dominios (agentes, prompts e instrucciones) que estén en la carpeta .github de la raíz. ¡Según donde abras el workspace de Vs Code aparecerán unos u otros! No es lo mismo abrir la carpeta de la raíz que una de un plugin concreto!

Cuando se opera desde la raíz, los dominios de plugins se cargan usando las “Localizaciones” (no implementado para agentes) de .vscode/setting.json.

Aleph Scriptorium usa Don’t Repeat Yourself para cargar en el contexto índices que funcionan como las herramientas MCP. El modelo reciba una lista de “disponibles” como índice, y si quiere usarlas tendrá que pedirlo. El sistema DRY hace lo mismo con la información de contexto, enlaces en lugar de cargar ficheros enteros.

El sistema de instrucciones funciona mediante filtros de “apply” que especifican que patrones de nombres y extensiones de ficheros son objetivo. Cuando en la conversación se añade como contexto un fichero que hace saltar el filtro, Copilot carga esas instrucciones en el contexto. Según diseño, todo empieza en: copilot-instructions.md, el primer archivo de instrucciones globales. A partir de aquí, ¡tú decides qué cargas en el Contexto!

Con el uso de Scriptorium, el escritor podrá usar la capacidad de los agentes para “auto-reflexión” (.github/plugins/scriptorium-pack/instructions/auto-reflexion.instructions.md”) para aprender con el modelo qué pasa por debajo cuando el usuario y el agente hablan y así aprender cómo redirigirlo al gusto.

Model Context Protocol (MCP)

MCP es como un puerto USB-C para aplicaciones IA: un estándar para conectar sistemas externos. MCP (Model Context Protocol) is an open-source standard for connecting AI applications to external systems.

→ MCP Introduction

Protocolo estándar: tools + resources + templates + prompts + sampling

Mantener el contexto pequeño es responsabilidad del usuario:

• Arrancar servidores MCP necesarios
• Configurar .vscode/mcp.json
• Mantener lista de herramientas mínima

6. Configuración y Acceso

Capas de Personalización

Hacker Panels

Paneles personalizables para el Scriptorium:

Base: BaseHackerPanelProvider.ts

7. Entorno Híbrido: Usuario + Agentes

Operar un sistema dinámico es una cuestión pandemónica. Crear un sistema que pueda usar tanto el usuario como el agente permite delegar o asumir al gusto la gestión.

Los handoffs permiten navegación entre agentes especializados.

8. Panel de Servicios y Apps

Tasks de VS Code

El sistema de Tasks permite arrancar servicios desde .vscode/tasks.json.

Ejecución:

• Manual: Ctrl+Shift+P → “Tasks: Run Task”
• Agente: Pedir al agente que ejecute y monitorice

Catálogo de Tasks por Stack

9. Servidores MCP

Servidores en mcp-mesh-sdk

Ubicación: MCPGallery/mcp-mesh-sdk/src/

Configuración: .vscode/mcp.json

Operaciones MCP

Parte II: La Escritura

1. Diseño Ontológico

OnthologyEditor para modelar dominios:

2. Tipos y Presets

Los diseños del punto anterior se transforman en un flujo de diseño en ScriptoriumPacks:

1. TypedPrompting  →  Creación de esquemas y validadores
         ↓
2. MCPPresets      →  Catálogo y configuración de packs
         ↓
3. HypergraphEditor → Integración de Tipos y Packs en operativas

3. Especificación de APIs

OpenAsyncAPI Editor para especificar lógica de negocio y comunicación:

Generación de código: Desde especificaciones a implementaciones tipadas.

4. Editores de Lógica

Los ScriptoriumPacks pueden exportarse a editores especializados con paletas tipadas compatibles con todo el ecosistema:

5. Pipeline de Compilación

┌────────────────────────────────────────────────────────────────────┐
│                    SCRIPTORIUM BRAINS PIPELINE                     │
├────────────────────────────────────────────────────────────────────┤
│                                                                    │
│  OnthologyEditor ──→ TypedPrompting ──→ MCPPresets                 │
│        │                   │                 │                     │
│        ▼                   ▼                 ▼                     │
│  ┌──────────┐       ┌───────────┐     ┌───────────┐                │
│  │  FLOVE   │       │  Schemas  │     │  Presets  │                │
│  │  MMCO    │       │  .json    │     │  .yaml    │                │
│  └──────────┘       └───────────┘     └───────────┘                │
│                            │                 │                     │
│              ┌─────────────┴─────────────────┘                     │
│              ▼                                                     │
│  ┌─────────────────────────────────────────────────┐               │
│  │              EDITORES DE LÓGICA                 │               │
│  ├─────────────────────────────────────────────────┤               │
│  │ BlocklyEditor │ PrologEditor │ WiringEditor     │               │
│  │      ↓              ↓              ↓            │               │
│  │   Bloques      Predicados      Flujos           │               │
│  └─────────────────────────────────────────────────┘               │
│                            │                                       │
│                            ▼                                       │
│              ┌─────────────────────────┐                           │
│              │  ScriptoriumBrainsPacks │                           │
│              └────────────┬────────────┘                           │
│                           │                                        │
│         ┌─────────────────┼─────────────────┐                      │
│         ▼                 ▼                 ▼                      │
│  ┌────────────┐   ┌────────────┐   ┌────────────┐                  │
│  │AgentCreator│   │ ARG Board  │   │  Novelist  │                  │
│  │ Personajes │   │   Apps     │   │ Narrativa  │                  │
│  └────────────┘   └────────────┘   └────────────┘                  │
│                                                                    │
└────────────────────────────────────────────────────────────────────┘

Flujos de compilación:

• Editor → Runtime: Blockly genera código ejecutable en 2 UIs: a) editor, b) runtime manager
• Agente → Servicio: PrologAgentBrainPack en personajes como Lucas que permite inferencias en directo ya sea para alterar “hechos” o para pedir “asserts”.

6. Creación de Agentes

AgentCreator multiplexa fuentes para crear personajes y los exporta a otros plugins como NovelistEditor o ARG-Board:

Output: Personajes en TALLER/ELENCO

Parte III: El Escribir

Aleph Scriptorium es un sistema ideal para “streamers” e “influencers” permitiéndoles gozar de la solidez e inmediatez del versionado semántico del bucle DevOps de CD/CI con sus obras y actuaciones o presencia en la red. Pudiendo diseñar sesiones en el escritorio y reproducirlas en directo. El scriptorium cubre las fases del proceso desde la “idea” hasta “los aplausos” o “likes”. Aleph Scriptorium es un sistema ideal para “streamers” e “influencers” permitiéndoles gozar de la solidez e inmediatez del versionado semántico del bucle DevOps de CD/CI con sus obras y actuaciones o presencia en la red. Pudiendo diseñar sesiones en el escritorio y reproducirlas en directo.

1. Producción Narrativa Agéntica

NovelistEditor es el sistema de producción narrativa:

💡 Ideal para streamers e influencers: DevOps de CD/CI aplicado a obras y presencia en red.

2. Conversión de la narrativa agéntica en transmedia

Teatro ARG + ARG Board App para narrativa interactiva:

3. Proyección de narrativa transmedia en linea

Exporta desde el Scriptorium por vias naturales como GitHub Pages u otras integraciones para levantar series temáticas y temporales como noticias, obras, columnas etc manteniendo sincronizada tu codebase y los portales donde los usuarios las visitan:

4. Uso de narrativa transmedia en Streaming con Apps conectadas

Lo difícil es hacer la obra. Una vez se ha montado el corpus: ¡con Aleph Scriptorium da gusto desplegarlo y escrivivirlo, :-D!

Herramientas para diseñar sesiones en escritorio y reproducirlas en directo:

Parte IV: El Escritor

1. IDE Clásico

Operaciones estándar de VS Code:

Configuración: workspace-config.json

→ VS Code Setup

2. Sistema de Agentes

Agentes principales:

• @ox — Oráculo y coordinador técnico
• @indice — Gestor de coherencia DRY
• @aleph — Como Ox pero “funcional”
• @scrum — El master Agile
• …

→ Copilot Agents

Locations (activar/desactivar):

En .vscode\settings.json:

• chat.promptFilesLocations
• chat.instructionsFilesLocations

3. Protocolos Multi-Agente

Coordinación de agentes en tareas complejas:

Sesiones activas: SESIONES_COTRABAJO

4. Auto-Reflexión y Métricas

El flujo agéntico pasa por etapas (ver referencia: blueprint-copilot.md) donde la conversación se transforma en etapas y niveles. El feature “auto-reflexión” en Aleph Scriptorium consiste en un mecanismo que conecta a los agentes con su actividad interna con Copilot Chat de modo que puedan observar sus propias conversaciones no ya desde le plano usuario-agente sino agente-LLM. Esta información es vital para evolucionar el scriptorium e incluso para coger ideas de ingeniería de prompting observando en vivo cómo dialoga consigo mismo el agente construyendo secuencias de llamadas a herrammientas y manejo del contexto de forma performante y como performance.

→ auto-reflexion.instructions.md

5. Plugins Instalados

22 plugins instalados, accesibles via bridges @plugin_ox_*:

Registro: registry.json

6. Despliegue de Servicios

Tasks organizadas por stack:

Ejecución: Ctrl+Shift+P → “Tasks: Run Task” → Seleccionar

Referencias

Requisitos

Planes GitHub Copilot

Escrivivir.co NO cobra por Aleph Scriptorium ni ofrece servicios de pago. Solo pagas tu suscripción a GitHub Copilot y a ellos.

Optimización de costes:

• Usa modo Auto para rutinas (-10%)
• Claude Sonnet para análisis complejos
• o1-preview solo cuando sea imprescindible

→ Licencia completa

← Inicio · Ecosistema · Archivo