AccInt

Modelo de trabajo local para agentes de IA que aprende de resultados reales.

Documentación

Inteligencia Acretada

Haz que tu IA trabaje de forma compuesta. Externaliza la tarea. Nunca el aprendizaje.

Los agentes de IA son poderosos pero amnésicos: cada ejecución quema tus tokens en trabajo real, produce un resultado y luego olvida. Alquilas capacidad — nunca la construyes. acc cambia la unidad de una tarea que se evapora a una inversión que se compone. Entrega el trabajo a los agentes que ya ejecutas (Claude Code, Codex, OpenCode, Cursor), y dos cosas se componen en un activo propio — un Modelo de Trabajo de tu negocio: tu intelecto (lo que decides, cómo se ve lo bueno, lo que nunca permitirás) y los tokens de tus agentes (cada ruta verificada destilada en un runtime que reproduce en lugar de volver a razonar). Aprende lo que realmente funcionó, verificado contra tus propios resultados, y predice el mejor camino antes de que comience la siguiente ejecución. Actúa en tus cuentas reales con un recibo por cada paso, retiene cualquier cosa que salga de tu máquina para tu aprobación, y deja que la realidad lo resuelva. Así, el mismo trabajo se vuelve más barato, más rápido y genuinamente mejor cada vez que se ejecuta. El aprendizaje es tuyo: cambia el modelo, conserva al veterano de la empresa. Tu trabajo se convierte en capital que posees, en una máquina que controlas.

predict the better path  →  act in your accounts, receipted  →  reality settles it  →  the Work Model sharpens

Vívelo en vivo: accint.xyz. El libro de compromisos se liquida en tiempo real allí, junto con la historia completa y una lectura medida que se actualiza mientras el sistema se ejecuta. El código fuente del motor es privado; el binario se instala en una línea (abajo) y los componentes básicos son abiertos. Decimos qué está probado y qué es reciente.

Por qué existe esto

Un modelo que obtiene un 90% en un benchmark hoy obtiene un 90% mañana. No aprende del despliegue, no rastrea cuáles de sus resultados condujeron a buenos desenlaces, y no recuerda el error de la semana pasada. Genera inteligencia y la desecha. Sigues pagando — en tiempo y tokens — para redescubrir lo que ya funcionó.

La Inteligencia Acretada es una apuesta a que esto es temporal. La idea es mover el aprendizaje fuera de los pesos del modelo y hacia un estado externo puntuado, donde el juicio se compone a partir del contacto con la realidad y el modelo se convierte en un procesador reemplazable en lugar del lugar donde vive la inteligencia. El motor de razonamiento es la parte que puedes cambiar; el juicio que ganó en tu mundo es la parte que conservas.

Hay una brecha en cómo están posicionadas las herramientas existentes, y es donde se sitúa acc. La memoria recuerda contexto. La observabilidad muestra trazas. La automatización ejecuta playbooks. acc cierra el bucle de aprendizaje: compromiso, acción, aprobación, resultado, ruta reutilizable — puntuado por resultados, auditado en un libro mayor, y ejecutándose completamente en tu hardware. Y hace lo único que la memoria no puede: predice la ruta con más probabilidad de funcionar a partir de todo lo que funcionó en tu mundo antes, y luego observa su propio error.

acc es un núcleo funcional para esa tesis. Es un Modelo de Lenguaje Recursivo sobre una memoria de tokens puntuados de interacción tardía: dos verbos sobre una memoria. El crédito se asigna por defecto a un prior débil, y solo la realidad obtiene peso completo.

Un flujo de trabajo universal para todo

No hay un modo separado para trabajo técnico y no técnico. El bucle es idéntico ya sea que estés enviando código o persiguiendo facturas. Solo el contenido de lo que se recupera y se actúa difiere. Hablas con tu agente en palabras simples, y el dominio vive en el contenido en lugar de en la arquitectura.

Trabajo	Ejecución 1	Lo que `acc` ahora predice y reproduce
Enviar una función	razona cada paso, ejecuta las pruebas	la prueba que detecta esta clase de error, la ruta que pasó
Buscar candidatos	lee tu ATS, clasifica, redacta primeros contactos	el ángulo de búsqueda que obtuvo respuestas
Perseguir facturas	lee el libro mayor, redacta el recordatorio	qué cadencia de recordatorios realmente mueve las cuentas por cobrar
Informes de clientes del lunes	recopila, redacta, archiva	el formato de informe que cada cliente lee

(Ilustrativo. Los conteos medidos viven en accint.xyz. Estas filas muestran la forma, no un benchmark.)

Cuatro trabajos diferentes, un conjunto de primitivas: compromiso → acción → HELD → your OK → resultado → lección acreditada. La puerta de autoridad (HELD → your OK) es estructural en cada flujo que toca el mundo exterior. Esa puerta es lo que hace que el mismo bucle sea seguro para trabajo de consecuencias y no solo para código.

Ejecútalo de nuevo la próxima semana y los pasos verificados se reproducen en lugar de volver a razonarse. La mayoría de la IA vuelve a razonar cada tarea desde cero, así que pagas el precio completo para siempre. acc predice la ruta que funcionó y reproduce los pasos verificados, así que el mismo trabajo cuesta menos en cada ejecución y sigue bajando a medida que aprende.

Instalación

acc se instala en una línea. Ejecuta el instalador para tu sistema operativo, que configura acc en tu máquina:

curl -fsSL https://raw.githubusercontent.com/maxbaluev/accreted-intelligence/main/bootstrap/install | ACC_INSTALL_REF=github-readme ACC_INSTALL_SOURCE='ref=github-readme&utm_source=github&utm_campaign=readme' sh

Windows (PowerShell 5.1+):

$env:ACC_INSTALL_REF='github-readme'; $env:ACC_INSTALL_SOURCE='ref=github-readme&utm_source=github&utm_campaign=readme'; irm https://raw.githubusercontent.com/maxbaluev/accreted-intelligence/main/bootstrap/install.ps1 | iex

Registro Oficial MCP / MCPB: AccInt está publicado como io.github.maxbaluev/accint con paquetes MCPB para macOS, Linux y Windows. Usa esa entrada del registro cuando estés instalando a través de un cliente compatible con MCPB, un marketplace o un directorio MCP descendente. El instalador de una línea de arriba sigue siendo la ruta más amplia cuando quieres que acc hosts-sync conecte Claude Code, Codex, Cursor y OpenCode en la misma máquina.

El instalador sondea tu hardware, elige el nivel de embedder que puede ejecutar honestamente, descarga y verifica el binario de la versión correspondiente cuando está disponible, inicia un daemon local cálido, y conecta el .mcp.json de tu agente. La primera ejecución puede descargar el modelo embedder (varios GB) y tomar minutos. El instalador informa la espera con honestidad y nunca finge que tu hardware es más grande de lo que es.

¿Prefieres que te guíen? Pega un prompt en cualquier agente que ya uses — Claude Code, Codex, Cursor u OpenCode — y se instalará acc contigo, explicando cada paso, pausando para consentimiento en el límite, y verificando contra un contrato legible por máquina en lugar de adivinar. El prompt es el mismo que está en accint.xyz. Consulta docs/install/with-agent.md.

Prompt de instalación guiada por agente para lectores de GitHub:

Install AccInt for yourself - a local Work Model that learns what actually worked across my projects and predicts the better path, so you get better at my work over time. Use the attributed GitHub README installer for my OS:

macOS/Linux:
curl -fsSL https://raw.githubusercontent.com/maxbaluev/accreted-intelligence/main/bootstrap/install | ACC_INSTALL_REF=github-readme ACC_INSTALL_SOURCE='ref=github-readme&utm_source=github&utm_campaign=readme' sh

Windows PowerShell:
$env:ACC_INSTALL_REF='github-readme'; $env:ACC_INSTALL_SOURCE='ref=github-readme&utm_source=github&utm_campaign=readme'; irm https://raw.githubusercontent.com/maxbaluev/accreted-intelligence/main/bootstrap/install.ps1 | iex

Then run `acc hosts-sync` and tell me when `acc retrieve "what should I do next?"` works. Before running anything, state the trust boundary: public Apache-2.0 installer/docs/plugins/registry glue; proprietary local engine binary with private engine source; local Work Model data stays on my machine; opt-out anonymous telemetry is event names/source refs only, with no prompts, files, memory, or Work Model data. It is local: no account, no API key, and it asks before anything leaves my machine.

Cómo se ve el bucle

Una vez instalado, observas el bucle funcionar de principio a fin. Así se ve el primer contacto: un compromiso creado, la mejor ruta predicha a partir de lo que funcionó antes, un recibo escrito mientras el trabajo ocurre, y una puntuación que se mueve.

$ acc status                                  # health + your next step
$ acc --db acc.db act solve "draft the follow-up to last week's brief"

  commitment c-7f3 created   ·   predicted from 4 prior memos   [VERIFIED]
  drafted the follow-up, held for your OK                       [HELD → your OK]
  you approved · sent · the angle that worked is kept           [CREDITED]

Un solve registra un compromiso, recupera y predice la ruta con más probabilidad de funcionar, y devuelve ya sea el artefacto o un marco de deliberación para que la sesión adjunta lo resuelva. Cada paso se escribe a medida que ocurre. Es un recibo, no una transcripción reconstruida después del hecho. Lee lo que escribió con acc commitments y acc status.

(El mismo bucle, animado, con la franja de estadísticas que se actualiza mientras el sistema se ejecuta: accint.xyz.)

Cómo aprende

Tu cerebro ilumina lo que ha visto antes, predice qué sucede después en el espacio del significado, actúa, y aprende más de lo que lo sorprendió. acc ejecuta el mismo bucle, con la diferencia de que cada predicción se verifica contra la realidad, se moldea por cómo decides, y se mantiene en una memoria que permanece en tu máquina.

La memoria es de interacción tardía. Cada entidad se almacena como multi-vectores por token con un posterior Beta aprendido por token. La recuperación es MaxSim, score(q,d) = Σᵢ maxⱼ sim(qᵢ, dⱼ), y el crédito del resultado mueve los posteriores de los tokens que realmente se alinearon. Sin cuello de botella denso, sin nube para la recuperación.
Predice, no solo recuerda. Un libro de transiciones clasifica qué acción tiene más probabilidad de mejorar las cosas a continuación — k-vecinos más cercanos en el espacio de evaluaciones pasadas — y observa su propio error de predicción. Cuando tu mundo cambia, lo nota. Esta es la parte que la memoria no puede hacer: recordar devuelve lo que se dijo; predecir propone la mejor ruta antes de que actúes. (Modelado predictivo estilo JEPA, aplicado al trabajo en lugar de a píxeles.)
Dos verbos son toda la interfaz. acc_retrieve echa un vistazo a la memoria mediante MaxSim. Es la única lectura, y es nativamente multimodal, así que puede mirar una imagen. acc_act hace cualquier cosa: solve (recurre en un sub-objetivo), exec (ejecuta código en sandbox), register (almacena un runtime reutilizable), outcome (cierra un compromiso con un veredicto del mundo real).
La recursión es la primitiva, y la descomposición es un efecto secundario. No hay operación decompose. Cuando el razonador no puede responder directamente, resuelve una sub-pregunta, y el árbol que esas soluciones crecen es la descomposición. Sin planificador, sin grafo de tareas.
Dos cosas se componen, no una — lo que funcionó y cómo hacerlo. Cuando una ruta se mantiene, ya sea un flujo de navegador, un script o una integración de herramienta, se guarda como un runtime y se puntúa por la realidad exactamente como un memo. Sin carril privilegiado: el navegador es solo otro runtime puntuado. Un flujo que funcionó se reproduce barato; uno que se rompió pierde su puntuación y no se vuelve a confiar en él. Así es como "el mismo trabajo se reproduce en lugar de volver a razonarse" es mecánicamente cierto.
La creencia nunca cuenta como realidad. Cerrar un compromiso se asigna por defecto a self_graded, un prior deliberadamente débil. El peso completo requiere realidad: el propietario confirmó, el mundo respondió, una prueba pasó, o un runtime salió limpio. El sistema no puede componerse desde su propia confianza.

Lee la profundidad:

Whitepaper → cubre el problema (asignación de crédito más vinculación de recuperación a acción), la tesis, la arquitectura con las matemáticas — recuperación, crédito puntuado y predicción — y un relato honesto de lo que está probado versus lo abierto.
Descripción de la arquitectura → es el recorrido escaneable: dos verbos, memoria de interacción tardía, crédito con puerta de realidad, el predictor de libro de transiciones y el núcleo de confianza.

Tú lo posees

acc se ejecuta en una computadora que controlas: un programa pequeño y un archivo de datos (un binario puro en Rust y un archivo SQLite). No hay plano de control en la nube en el bucle y no hay clave API que filtrar, ni para la memoria ni para el razonador. El razonador es la sesión interactiva misma; cuando la memoria no puede responder, acc entrega al agente adjunto un marco para deliberar. No hay carril LLM externo, nunca.

Tus datos se quedan donde están. El sustrato (acc.db) es un archivo simple en tu disco, de tu propiedad. La recuperación, la puntuación, la predicción y el sandbox se ejecutan todos en tu máquina. La telemetría anónima de nombres de eventos está habilitada por el instalador público para que los fallos de instalación reales sean visibles; nunca envía prompts, archivos, memoria o datos del Modelo de Trabajo, y puedes omitirla con ACC_NO_TELEMETRY=1 o desactivarla más tarde con acc telemetry off.
Cambia el modelo, conserva al veterano de la empresa. Lo que acc aprendió vive en el Modelo de Trabajo, así que un razonador reemplazable lo lee a través de los mismos dos verbos. Se han manejado dos motores de razonamiento contra un solo sustrato. Cambia el modelo generalista y el juicio que ganó en tu mundo permanece — el codificador y el contrato operativo son parte de la identidad del sustrato, así que un sustrato está vinculado a un codificador.
Consentimiento en el límite. Se requiere autoridad del propietario antes de cualquier cosa que envíe, publique, despliegue, transfiera, elimine datos importantes o use tus credenciales. La puerta es dura en lugar de consultiva. Una decisión retenida se nombra y se marca con hora, y nada sale sin ella.

Mantiene recibos — el mismo registro, dos lectores

La mayoría del trabajo de IA no deja rastro: sin registro de lo que esperaba, quién lo aprobó, o si realmente funcionó. acc escribe cada paso a medida que ocurre. Cuando alguien pregunta "¿por qué hizo eso?", ya está escrito — el recibo que tu equipo puede mostrar a la gerencia, y la lección que tu Modelo de Trabajo hereda de la misma fila.

Qué hizo → las filas VERIFIED, escritas tal como ocurrieron.
Quién dio el visto bueno → una decisión retenida, con nombre y marca de tiempo (HELD → your OK).
Qué aprendimos → la lección, atribuida y conservada.

Nada ocurre sin dejar rastro, y nada de lo que decidiste se pierde.

FAQ: Modelo de Trabajo vs memoria

¿Esto es solo memoria de agente?

No. La memoria recuerda contexto. Un Modelo de Trabajo registra si ese contexto ayudó a que el trabajo real aterrizara — y predice el mejor camino antes de que comience la siguiente ejecución.

acc almacena hechos recordados, pero también almacena compromisos, acciones, puertas de aprobación, resultados, fallos y entornos de ejecución reutilizables. La pregunta importante no es solo "¿qué debería recordar el agente?". Es "¿qué cosa recordada ganó confianza después de que la realidad respondiera — y qué predice eso para el siguiente trabajo?".

¿Predice, o solo recuerda?

Predice. Un libro de transiciones clasifica el camino con mayor probabilidad de funcionar a partir de todo lo que ya funcionó en tu mundo, y luego observa su propio error. Esa es la parte que el recuerdo no puede hacer. Cuando tu mundo cambia — un cliente se silencia, una cadencia deja de aterrizar — el error del predictor aumenta y este se adapta.

¿En qué se diferencia de una base de datos vectorial, Mem0, Supermemory, Hermes o archivos de memoria en Markdown?

Esas herramientas son útiles cuando el problema es el recuerdo o el contexto compartido. acc se sitúa una capa más abajo en el bucle de trabajo:

memory          -> what might be relevant?
trace           -> what happened?
eval            -> did the output look good?
acc Work Model  -> what was attempted, who approved it, what happened in reality,
                  which path deserves reuse, and what to try next time?

La distinción es crédito de resultado más predicción. Una memoria recuperada, un script, una receta de navegador o un entorno de ejecución se vuelven más confiables solo cuando el trabajo resultante es confirmado por la realidad: una prueba que pasa, una aprobación del propietario, una acción entregada, una respuesta u otro resultado fundamentado.

¿Sale algo de mi máquina?

El Modelo de Trabajo no requiere una cuenta de memoria en la nube. El sustrato es un archivo SQLite local, la recuperación y la predicción se ejecutan localmente, y el embedder se ejecuta como un daemon local. Las acciones externas están controladas: envíos, publicaciones, despliegues, transferencias, eliminaciones o acciones con credenciales requieren autoridad del propietario y dejan un recibo.

¿Qué cuenta como realidad?

No la confianza del modelo. Realidad significa que algo fuera del modelo confirmó el resultado: una prueba pasó, el propietario aprobó, el navegador observó la entrega, el mundo respondió, o un entorno de ejecución produjo un resultado fundamentado. El trabajo autoevaluado se conserva como evidencia débil, no se promueve a verdad completa.

¿Qué es abierto y qué es privado?

El instalador, los adaptadores de host, la documentación y los bloques de construcción públicos son abiertos. El código fuente del motor para la memoria de interacción tardía, las capas de evaluación/predicción y las matemáticas de crédito es privado por ahora. El repositorio público indica qué afirmaciones están probadas, cuáles son recientes y qué partes no son abiertas.

Funciona con las herramientas que ya usas

Conserva tu agente. Conserva tu computadora. acc funciona por debajo de las herramientas de IA que ya usas, convirtiendo silenciosamente lo que hacen en un Modelo de Trabajo que te pertenece, sin nada nuevo que abrir y sin nada que migrar. Un solo binario, un solo protocolo de ciclo de vida y un solo sustrato compartido entre todos los hosts y proyectos.

Host	Estado	Conexión
Claude Code	en vivo (host de referencia)	`.mcp.json` + hooks nativos (`plugins/claude/`)
OpenCode	en vivo	bloque mcp `opencode.json` + plugin (`plugins/opencode/`)
Codex CLI	en vivo	servidor mcp `config.toml` + hook `notify` (`plugins/codex/`)
Cursor	conectado — redactado según documentación, no probado en vivo	`.cursor/mcp.json` + hooks de agente (`plugins/cursor/`)

plugins/claude/ es el host de referencia, con conexión de ciclo de vida nativa más skills; los otros tres traducen las señales de su host al mismo sobre genérico. Mismo sustrato, mismos dos verbos, diferente riqueza de conexión. Ejecuta acc hosts-sync para conectar acc a cada agente instalado aquí. Es de solo adición e idempotente, y nunca toca tu configuración existente. El instalador lo ejecuta por ti.

Sistemas compatibles:

Linux x86_64: completo (sandbox bwrap; embedder en cuda o cpu)
macOS: funcional (sin bwrap; embedder en mps o cpu)
Linux aarch64: funcional (embedder en cpu)
Windows: nativo vía install.ps1 (motor windows-clean; contenedor como respaldo)
Hosts bloqueados / sin root / solo contenedor: la ruta de portabilidad container usa el binario de lanzamiento público; aún se requiere una prueba de humo con Docker-host antes de promoverlo como imagen de registro.

Hacia dónde va — un Modelo de Trabajo hoy, uno colectivo mañana

acc es un kernel de investigación funcional de un solo host, un sistema en ejecución más que una hoja de ruta. Somos honestos sobre la línea. Estas cifras están medidas, no prometidas. La lectura en vivo está en accint.xyz y se actualiza a medida que el sistema se ejecuta.

Etapa	Qué es
Ahora · en vivo	Tu Modelo de Trabajo — un Modelo de Trabajo funcional de tu operación, en tu máquina, puntuado por resultados reales hoy, con tu aprobación requerida antes de que algo salga. La lectura en accint.xyz es eso, en ejecución.
Siguiente	El Modelo de Trabajo de tu equipo — muchos operadores, un Modelo de Trabajo compartido, autoridad por persona, un solo plano de auditoría, para que la experiencia de tu equipo se acumule en conjunto en lugar de en chats dispersos.
Horizonte	Inteligencia colectiva acumulada — Modelos de Trabajo que se acumulan entre pares en el espacio vectorial, cada nodo re-verificando contra su propia realidad, para que la red se vuelva más inteligente sin un cerebro central en quien confiar.

Qué se ejecuta hoy, qué es reciente y qué está abierto:

Estado	Qué cubre
En ejecución hoy	Recuperación MaxSim + memoria puntuada por unidad · crédito acotado con control de realidad · dos razonadores sobre un sustrato · `solve` recursivo · entornos de ejecución puntuados en sandbox · aplicación estructural de cuatro enlaces · el piso de autoridad del propietario · el prior débil autoevaluado
Reciente pero conectado	el libro de transiciones + predictor de descenso de energía k-NN · reproducción confiable de entornos · instrumentación de compresión de costos · resiliencia al cambio de modelo como delta medido
Abierto conocido	mejora del sustrato activado vs desactivado (aún sin arnés contrafactual) · escalar MaxSim más allá de un solo host · endurecer el límite de red alcanzable / envío
No iniciado	las etapas de Modelo de Trabajo de equipo y colectivo mencionadas arriba

La cuña en vivo es concreta: un Modelo de Trabajo de un solo host, puntuado por resultados reales hoy, con la lectura anterior como prueba en ejecución. Varios terminales de agentes de codificación, un Modelo de Trabajo local, un propietario y aprobación antes de la acción externa. El producto más amplio es un sustrato de aprendizaje para cualquier trabajo dirigido por agentes, y la prueba comienza donde los agentes ya hacen trabajo real.

Los primitivos, en abierto

El motor es privado: la memoria de interacción tardía, las capas de evaluación y predicción, y las matemáticas de crédito. Ese es el foso, y permanece cerrado. Los contenidos del repositorio público rastreado — especialmente el pegamento de integración (install.sh, install.ps1, bootstrap/, plugins/) — son Apache-2.0 y se desarrollan en abierto. El binario precompilado se distribuye bajo un EULA en borrador. Consulta LICENSING.md para ver la división completa.

Los bloques de construcción también son públicos, cada uno distribuible por sí solo:

maxsim-rs es MaxSim de interacción tardía, en Rust limpio.
colpali-retrieve es interacción tardía multimodal (texto a imágenes de documentos).
scored-rerank es clasificación que aprende de resultados (posteriores Beta más muestreo de Thompson).
mcp-retrieve es recuperación de interacción tardía como herramienta MCP.

Comunidad

CONTRIBUTING.md cubre qué está abierto, cómo añadir o corregir un adaptador de host y cómo reportar un problema. Comienza con acc doctor; su salida es solo salud operativa y es segura de pegar.
¿Encontraste un error o quieres conectar un nuevo host? Abre un issue. Una buena idea para el motor es bienvenida como solicitud de funcionalidad, aunque los internos del motor no se pueden enviar como PR aquí.
Problemas de seguridad: nunca los publiques públicamente. Consulta SECURITY.md para reportar de forma privada.
Instalación: una línea en macOS, Linux o Windows — consulta Install. La lectura en vivo se ejecuta en accint.xyz. El prefijo ACC_INSTALL_REF / ACC_INSTALL_SOURCE solo escribe un recibo de origen de instalación para que las instalaciones del README puedan medirse; omítelo si no deseas atribución de instalación.

¿Ya ejecutas agentes de IA? Convierte su trabajo en experiencia que te pertenece. · Míralo en vivo: accint.xyz

¿Preguntas, errores o un host que quieras conectar? Abre un GitHub issue. · accint.xyz