# for-ai-agents
Gestión de tareas
para agentes de IA.
Las decisiones y las tareas quedan en tu dispositivo como registros enlazados, así la IA sigue solo el contexto que necesita, y lo hace rápido.
// for humans — GUI
Tú lo abarcas de un vistazo: tablero, línea de tiempo, grafo de dependencias. La IA conduce; tú vigilas.
# the-problem
El contexto que construyes con una IA queda encerrado dentro de esa IA.
Los agentes de IA sí tienen memoria. Pero vive dentro de esa única IA: nunca llega a ser tuya.
// no se ve
No puedes comprobar qué guardó
En qué decisiones se apoyó, qué descartó: desde fuera no hay forma de comprobarlo, así que tampoco puedes seguir su razonamiento.
// se difumina
Cuanto más largo el trabajo, más pierde
A medida que el trabajo crece, el contexto se hincha y la IA lo suelta por los bordes. Vuelves a atascarte en el mismo punto.
// no se lleva
Si cambias, empiezas de cero
Cambia de IA o termina la sesión, y el contexto que construiste no te sigue. Toca explicarlo todo otra vez.
→ Por eso el registro tiene que vivir fuera de la IA.
# the-answer
Por eso, amenbo.
amenbo guarda las decisiones, las tareas y las dependencias que va acumulando una IA como registros enlazados en tu dispositivo, no dentro de la IA. La IA escribe; tú supervisas.
// visible
Tú también puedes leerlo
Los registros son tuyos y puedes leerlos. Después puedes rastrear en qué se apoyó la IA para trabajar.
// permanece
No se difumina
Vive en tu dispositivo, no dentro de la IA, así que aguanta trabajos largos.
// cualquier IA
Cualquier IA lo retoma
Todos los agentes de IA leen y escriben los mismos registros. Cambia de agente y sigue adelante.
# hands-off
Las tareas no las escribes tú.
La IA va dejando registro mientras trabaja. Nunca tienes que abrir una tarea ni cerrarla.
// pruébalo
Avanza hasta la mitad, abre una sesión nueva y sigue con la misma tarea.
# parallel-sessions
Lánzalas a la vez: el mismo trabajo nunca se hace dos veces.
Corre tantas sesiones de IA en paralelo como quieras: dos nunca cogen la misma tarea. La que llegó primero sigue con ella; la otra se pasa a otro trabajo.
La que pierde no duplica el trabajo en silencio: se le dice claramente que no y pasa a otra cosa.
# portable-context
Cambia de agente, corre varios a la vez: el contexto se queda.
El contexto no vive dentro de la IA, vive en registros en tu dispositivo. Por eso eres libre de cambiar de agente: pásate a otro, o corre varios en paralelo, y todos leen y escriben el mismo y único conjunto de registros.
// pruébalo
Avanza hasta la mitad en Claude Code y pásaselo a Codex.
# your-data
Tus datos son tuyos.
De lo que produce una IA responde una persona, así que el espacio de trabajo se queda contigo. amenbo funciona sin servidor: tus decisiones y tus tareas viven solo en tu dispositivo.
- Solo en local. Tus datos no salen del dispositivo: sin telemetría, sin seguimiento de uso, sin servidor central. (Únicamente comprueba si hay una versión nueva, y eso también puedes apagarlo.)
- Quienes escriben sois la IA y tú. amenbo nunca toca tus datos.
- Exporta todo en JSON, adjuntos incluidos, cuando quieras.
- Nada se pierde, nada se rompe, siempre se puede recuperar.
# measured
La misma respuesta, en casi la mitad de pasos.
Como el contexto es un grafo enlazado, la IA llega a la respuesta siguiendo unas pocas aristas, sin releer todo el historial.
Pasos hasta responder la misma pregunta (medido, mediana)
Las dos llegan a la misma respuesta, y leen entre 1,4 y 1,9 veces menos. Cuanto más enredado el código, mayor la diferencia.
# project-boundaries
El proyecto de al lado queda fuera de su alcance.
Si le das varios proyectos a una IA, el contexto de uno puede filtrarse en otro. amenbo mantiene cada proyecto aparte: más allá de aquel en el que trabaja, no puede ni leer ni escribir.
# two-pillars
No solo la tarea: también el «por qué».
Una persona y la IA acuerdan una dirección, y de ahí salen las tareas. amenbo guarda no solo qué hacer, sino por qué se decidió, y los enlaza. Así cada tarea se remonta a su motivo.
la decisión
Guardar automáticamente lo escrito como borrador
las tareas que generó
# open-source
¿Es seguro adoptarlo? Puedes comprobarlo tú.
«¿Estará haciendo algo que no debe?» «¿Se puede meter en una empresa?» amenbo responde a eso con código abierto. En vez de pedirte confianza, te deja verificar: el código y de dónde salió cada compilación.
// read it
Nada oculto
Todo el código es público bajo Apache-2.0. Tú, o el equipo de seguridad de tu empresa, podéis leer exactamente qué hace y qué no. El nombre y el logotipo no entran en la licencia.
// verify the build
Confirma que la compilación es auténtica
Cada versión la compila una CI pública con una atestación de GitHub. Ejecuta tú mismo gh attestation verify para confirmar que lo que descargaste se compiló desde un commit conocido de este código y no se sustituyó por otra cosa.
// adopt with confidence
Defendible para adoptarlo en una empresa
Se queda en tu máquina: los datos no salen del dispositivo. Licencia Apache-2.0 y procedencia verificable. Decide si lo adoptas por hechos, no por impresiones.
El desarrollo ocurre a la vista. Las issues son bienvenidas; para las pull requests, escríbenos antes.
