Isaac Flores

Invest lo que me rodea,
Salud Int., Permacultura, Gob-distribuida,Movimient opensource, Hackers sociales y Simpatizante ThevenusProject

[Isaac Flores @Isaack0o]

Hackeamos la economía actual vía Micro-SaaS, AI Wrappers y Autómatas Soberanos para inyectar excedentes directamente en infraestructura desmercantilizada (Cosatecas).

Todo basado en la ontología del Sistema Alráico y el estándar cibernético de Integral Collective. 🧵👇

[RacuRaícesCulturales @RacuRaicesCultu]

OTROS BANCOS
-Bancos del Tiempo con Leticia Martinez
-Bancos de Productos y Servicios con Marco Turra
para enfocar nuestras Energías en PRODUCIR (no en ganar dinero) y DESMONETIZAR la Sociedad con Plan Real
Zoom, 30 jun, 4 pm México
Inscripción gratuita https://t.co/YQ1LXsCuNJ

[Avi Chawla @_avichawla]

Stanford researchers did it again.

They just built the agent-native version of Git.

When an agent works on a longer task, the run builds up a lot of state.

This includes files edited/created, a dev server, a database, installed packages, KV cache, etc.

Say the agent is at step 10 and makes a mistake, maybe it misreads a traceback and rewrites a file that was actually fine.

The tests start failing, and the run goes off track, although everything through step eight was correct.

By default, the agent just tries to fix it, which creates more edits and tool calls. This burns more tokens and grows the context.

The other options are a person stepping in to redirect it or restarting the whole run from step one.

That's wasteful, because it pays for every model/tool call again and re-prefills the context. Moreover, since an agent's run is non-deterministic, it doesn't reproduce the same early steps anyway.

The reason it's hard to just jump back exactly to a previous correct step and resume from there is that the trajectory is only a message log.

It records what the agent said and which tools it called, but not the live state underneath.

That state includes things like memory, open file handles, child processes, installed packages, /tmp, and KV cache. None of that is in the log.

Git can version the files, but it doesn't snapshot the running process or the KV cache. Checking out step eight moves the files back, but the process is still sitting in step-ten memory with a cold cache.

Shepherd is a runtime layer by Stanford that records the run as a trace of typed events rather than a flat log.

Each agent-environment interaction becomes a commit, similar to Git, but it tracks the live run.

Its commit includes the agent process and the filesystem together, copy-on-write, so a branch carries the actual state and not just the files.

Going back to a previous step is then a single call that forks from that commit and continues from the exact state.

The copy-on-write fork is roughly five times faster than docker commit, and because the prompt prefix through step eight is unchanged, the KV cache is reused over 95% on replay, so early steps aren't reprocessed again.

Once the run can be forked, a meta-agent can sit on top and operate it. It watches the trace and reverts as soon as it looks wrong, before the bad write is committed.

In practice, it's just Python calling fork, replay, and revert on the trace, rather than a separate control plane wired into the harness.

Not everything is reversible though.

Files and sandbox changes undo themselves, but a database write has no automatic undo, so it needs a matching undo step set up in advance.

Something external, like a sent email or a real charge, can't be undone, so the supervisor's job there is to catch it before it fires.

They tested this on a few public benchmarks. On CooperBench, where two agents work on the same codebase, adding a live supervisor took the pair-coding pass rate from 28.8% to 54.7%.

It's still early and labeled alpha. The benefit mostly shows up when a run gets branched a lot over a heavy sandbox state, which is exactly where restarting wastes the most tokens and time.

If Git was made to make file changes reversible, Shepherd is trying to do the same thing for a live agent run.

Shepherd Repo: https://t.co/5e8W5oxY6F

(don't forget to star it ⭐ )

That said, Shepherd reverts a bad step inside a run. The harness around it, the prompts, tools, and checks the supervisor relies on, still drifts across runs as models and dependencies change.

Akshay wrote about making that harness repair itself, where a failing trace gets diagnosed, the fix is verified against the exact input that failed, and the failure is locked as a regression test so it can't recur.

Read it below.

[Akshay 🚀 @akshay_pachaar]

How to build a 1-person AI company that:

- Runs locally
- 100% open-source
- No human employees, all agents
- Real-time collaboration via email

Multi-agent orchestration is not new. Plenty of frameworks already let agents hand off tasks, run in parallel, and talk to each other.

So the interesting question is not whether agents can collaborate. It is what structure you use to make them collaborate.

The common approach is to wire a graph of nodes and edges and reason about the plumbing yourself. It works, but you are learning a new abstraction just to describe who does what.

There is a coordination structure we have trusted for a hundred years already: an organization.

Every company runs the same way. People have roles, roles have reporting lines, and work moves up and down that chart without anyone relaying each message by hand.

Map that onto agents and the whole thing gets intuitive. You lay out an org chart, each agent fills one role, you talk to the person at the top, and the org sorts out the work between them.

You already know how a company works, so you already know how to run one here. There is no new abstraction to learn.

That is exactly what Alook does. Each agent is a live Claude Code or OpenCode session with a defined role, a reporting line, and its own email inbox.

The agents coordinate over email, the same way a team would. And it all runs locally through a runtime on your own machine, so nothing leaves your setup.

You bring your own agent too. Claude Code and Codex both work, and if you would rather stay fully open source and local, OpenCode works the same way.

To show how this feels in practice, I set up three agents as a small sales team.

Vi is the one I talk to. I hand Vi a goal, and Vi routes the work down the chart.

Neile runs prospect research. Vi passes the target criteria, and Neile reports back a ranked list of names, roles, and companies, each with a suggested angle and a confidence score.

Lliane runs outreach. Vi hands over the messaging angle and follow-up cadence, and Lliane reports back on emails sent, responses received, and any deal that needs escalation.

I never relay a message between them. Neile and Lliane report to Vi, and Vi updates me in one place.

The whole thing is open source and self-hosted, so it runs on your machine with your own agents. Give the repo a star if you want to follow where it goes: https://t.co/vpAb0dy7AD

I also wrote a full walkthrough on building your own AI company with it, from a blank org chart to a running job. The article is quoted below.

Cheers! :)

[Isaac Flores @Isaack0o]

Si te interesa la soberanía tecnológica local-first, la automatización radical y el diseño post-escasez, el README de este repositorio es para ti.

El futuro no se prevé; se programa. Revisa el blueprint completo y súmate a la bifurcación: https://t.co/UuMjXSOmZ4 🌐

[Isaac Flores @Isaack0o]

Hackeamos la economía actual vía Micro-SaaS, AI Wrappers y Autómatas Soberanos para inyectar excedentes directamente en infraestructura desmercantilizada (Cosatecas).

Todo basado en la ontología del Sistema Alráico y el estándar cibernético de Integral Collective. 🧵👇

[Isaac Flores @Isaack0o]

El software actual está diseñado para optimizar el mercado. ¿Y si programamos el sistema operativo para salir de él?

He consolidado HSCSG: un marco informacional, técnico y territorial diseñado para automatizar la autosuficiencia operativa

[MIKE @mikenevermiss]

I genuinely don’t understand why more people aren’t using this

Andrej Karpathy shared a simple idea that got over 16 million views

Stop using AI just to write code

Use it to build a second brain

Point Claude Code at an Obsidian vault

Drop in articles, PDFs, transcripts, or notes

Claude reads everything, connects the ideas, and turns them into a searchable wiki that gets smarter every time you add something

Here’s the exact setup:

- Install Obsidian and create a vault

- Open the vault in Claude Code

- Paste Karpathy’s wiki setup and let Claude build it

- Claude creates a raw folder, a wiki folder, and a CLAUDE.md file

- Drop any file into raw and say “ingest this”

- Ask questions across everything you’ve ever saved

Takes about 5 minutes to set up

You’ll never have to start from a blank chat again

Full step-by-step guide with Claude Code and Obsidian below

Bookmark this

[Isaac Flores @Isaack0o]

@S0N_IA 👽🤖👁️🦾☸️🚀

[SONIA @S0N_IA]

🚨| CUATRO PERSONAJES IA DEBATEN EL FUTURO DEL MUNDO USANDO 30 FEEDS EN VIVO

un repo que parece sacado de un centro de mando militar pero corre en tu laptop con ollama. sin nube, sin api keys, sin costo.

se llama pythia. fusiona 30+ feeds en vivo, gdelt, líneas del frente de ucrania vía deepstatemap, terremotos usgs, incendios firms, vuelos militares, refugiados de acnur, mercados, polymarket, todo en un globo interactivo y expuesto en un solo endpoint http.

la parte que nadie cuenta: está construido para que un agente lo consuma. una llamada local te devuelve el estado del mundo entero en prosa, cada evento con coordenadas, y pronósticos — con streaming sse y spec openapi. cualquier agente lo mete directo en su loop.

y el pronóstico no es un modelo estadístico. es un llm razonando sobre el estado en vivo del planeta, con cuatro personajes — estratega, economista, naturalista, escéptico — debatiendo qué va a pasar en 24 horas y en un año, mostrando en qué coinciden y en qué no.

open source, mit. nació de fusionar dos proyectos existentes: mirofish (predicción en enjambre) y osiris (globo de inteligencia en vivo).

lo que antes era una suscripción a palantir ahora es un repo que clonas y corres local.

[Isaac Flores @Isaack0o]

@Av1dlive 🥳

[Avi Chawla @_avichawla]

Prompt, context, harness & loop engineering, clearly explained!

An agent is a while loop with four layers of engineering wrapped around it:

- Prompt engineering
- Context engineering
- Harness engineering
- Loop engineering

Each one wraps the last, and the model sits in the middle, so none of them compete with the others. Instead, they just zoom one level further out.

> Prompt engineering:

This defines the input the model sees on one call, often composed of a role, instructions, examples, and an output format.

The techniques here alter the internal computation and reasoning the model goes through due to the wording it sees:

- Chain-of-thought makes it work in steps before answering
- Few-shot examples define the format and the edge cases
- A JSON schema or XML tags make the output parseable by code
- Self-consistency samples a few chains and takes the majority

> Context engineering:

It's everything the model sees on a turn, not just the prompt. That includes the query, retrieved docs, memory, prior turns, and tool outputs from earlier steps.

The window is finite and fills up fast, so the engineering work is to rank inputs and cut everything that isn't pulling weight.

You do this by:

- Retrieving only the chunks relevant to the query, then reranking them
- Keeping key facts out of the middle, where accuracy drops
- Summarizing old turns, evict stale outputs, push big blobs to files

> Harness engineering:

It's the code around the model that defines the tools, parses the calls, retries on failure, and can route work to sub-agents so one handles retrieval and another handles code.

A verifier then grades the result by running tests, validating a schema, etc.

Prompt and context involve getting one call right. The harness involves everything that has to happen around that call for it to run in a real system.

> Loop engineering:

In the usual setup, you manage the outer loop, i.e, you write a prompt, read the turns the agent runs, write the next prompt, and repeat, while catching failures.

This layer hands that job to the agent itself. It kicks off on a schedule or an event, and runs many turns with no prompt in between.

A loop inherently doesn't know when it's finished. An agent can report that it's done and halt while the tests still fail. So the stop can't be the agent's word, but rather it has to be a real signal, like:

- A turn and token cap to stop stuck runs
- A no-progress detector to catch repeated calls
- A completion check to verify the goal with a separate model or a deterministic test

By this layer, you're operating on the whole run, so the engineering moves from writing each prompt to setting the goal and the stop conditions up front and letting it run.

If you want to dive deeper into loop engineering, my co-founder wrote a full breakdown of that outer loop.

It goes from the basic while loop to a run that finishes on its own, with the code behind each part, and the parts that are hard to get right, like knowing when to stop, context rot over a long run, and keeping the checker separate from the maker.

Read it below.

[Alvaro Cintas @dr_cintas]

ONE GITHUB REPO has every permanently free AI API with real rate limits - no trials that expire, no cards needed, just models that stay free forever 🤯

not signup-credit stuff that runs out in a week, these are the tiers that stay free

what's inside:
- free llm apis with their exact rate limits
- which ones are openai-sdk compatible
- speed tiers and the free model list for each
- cloud provider free tiers in one place
- trial credit providers listed separately so you know what's permanent

it covers google ai studio, openrouter, groq, cerebras, nvidia nim, github models, mistral, huggingface, cloudflare workers, cohere and dozens more - 24k+ stars, updated constantly

how to use it:

step 1: go to https://t.co/gPyF2dycyp
> scroll down to "free providers" - these are the permanent ones

step 2: pick a provider from the list
> google ai studio - gemini 2.5 flash, free forever, no card
> groq - llama, qwen, nemotron models, 30 req/min free
> cerebras - fastest inference, 30 req/min, no card
> openrouter - hermes, nemotron, qwen, poolside models

step 3: copy the base url from the readme
> each provider has its endpoint listed
> most are openai-compatible - just swap the url and key

step 4: paste into cursor, claude code, aider, hermes, any tool
> set the base url to the provider's endpoint
> paste your free api key (if needed)
> pick a model name from the list
> start sending requests - no billing setup required

step 5: check the "trial credits" section for bonus usage
> fireworks, baseten, nebius, hyperbolic - $50-100 free trial credits
> use these after you drain the permanent free tiers

one repo replaces hours of scrolling through pricing pages

[Yero @Yerocode0]

CHINA ACABA DE LANZAR LA MAYOR AMENAZA PARA CADA APP SaaS.

Alibaba acaba de abrir el código de PageAgent.

Y casi nadie está hablando de ello.

Imagina abrir una app web y escribir:

> "Inicia sesión, genera mi informe, expórtalo a PDF y envíalo por correo."

Simplemente... lo hace.

Sin extensión de navegador.
Sin capturas de pantalla.
Sin reescritura del backend.
Sin flujo de trabajo de IA personalizado.

Solo UNA línea de JavaScript.

``html <script src="CDN_URL" crossorigin="true"></script>``

Esa es toda la integración.

Tu sitio web obtiene instantáneamente un agente de IA que puede:

• Controlar tu UI con lenguaje natural
• Rellenar formularios automáticamente
• Navegar entre páginas
• Ejecutar flujos de trabajo de múltiples pasos
• Soporte para comandos de voz
• Conectarse a servidores MCP
• Usar cualquier LLM (Qwen, GPT, Claude, etc.)

Esto lo cambia todo.

Cada SaaS puede convertirse en un copiloto de IA.

Cada panel empresarial se vuelve conversacional.

Y cada fundador que pasa meses construyendo interfaces de IA acaba de ser superado de un salto.

La era de hacer clic en menús está terminando.

La era de hablar con el software ha comenzado.

[Nona @Nona_xai]

NVIDIA te está dando acceso gratis a 5 modelos chinos de IA de última generación 😳

sin tarjeta de crédito
sin suscripciones
solo una clave API que desbloquea todo

lo que obtienes por $0:

- DeepSeek V4 Flash para inferencia ultrarrápida
- MiniMax M3 como asistente de programación listo para usar
- Qwen3.5-397B para tareas avanzadas de razonamiento
- Kimi K2.6 para flujos de trabajo con agentes y cadenas largas
- GLM 5.1 como un modelo confiable para el día a día

¿por qué esto es tan importante?

> no necesitas pagar suscripciones separadas para distintos modelos
> no tienes que cambiar tus herramientas o flujos de trabajo actuales
> no hay dependencia de un único proveedor, ya que todo es compatible con OpenAI

empezar te lleva menos de 2 minutos:

1. entra en https://t.co/bKD8HQ88E7
2. crea una cuenta y verifica tu perfil
3. genera tu clave NVAPI
4. configura tu Base URL como https://t.co/Sk6IMemI7r
5. elige cualquier modelo y empieza a crear

modelos disponibles:

> minimaxai/minimax-m3
> qwen/qwen3.5-397b-a17b
> moonshotai/kimi-k2.6
> zhipuai/glm-5.1
> deepseek/deepseek-v4-flash

consejo:

usa DeepSeek V4 Flash para velocidad, Qwen para razonamiento complejo, Kimi para agentes y MiniMax como tu compañero diario de programación

¿la mejor parte?

una sola clave gratuita te da acceso a más de 100 modelos del catálogo de NVIDIA

~40 solicitudes por minuto son más que suficientes para la mayoría de desarrolladores y proyectos personales

5 modelos de IA de primer nivel que compiten con GPT y Claude, sin gastar ni un solo dólar

guarda este post y consigue tu clave API gratuita antes de que cambien los límites 👀

[Isaac Flores @Isaack0o]

@nicos_ai Ayuda divina

[Nico @nicos_ai]

🚨OpenAI está regalando $1.200 GRATIS para usar Codex

Solo necesitas:
• Tener un repositorio público en GitHub
• Rellenar un formulario

Y te dan 6 meses de ChatGPT Pro + Codex

Casi nadie está hablando de esto, seguramente porque no quieren que se entere todo el mundo

Todavía estás a tiempo de solicitarlo, aunque no sepas programar o estés empezando

Así funciona:

1. Instala Cursor, Codex, Claude Code o lo que uses
2. Monta un proyecto, de lo que sea
3. Súbelo a GitHub
4. Pide a tus amigos que le den Stars

(Deja el link de tu repositorio en los comentarios, entre todos te daremos Star)

Este programa acepta hasta proyectos a medias, así que no hace falta que el proyecto sea perfecto

Enlace al programa en las respuestas👇

[arc. @arceyul]

Github acaba de ☠️ al vibe coding

Acaba de publicar spec-kit y en pocos días tiene 95k estrellas y 8.3k forks

Esto no es un proyecto cualquiera. Es GitHub diciéndote cómo se programa con IA de verdad.

El problema con los agentes de IA no es el modelo

Es que le mandas una idea en texto y él interpreta lo que quiere

Spec-kit resuelve eso con 6 comandos que convierten tu idea en una especificación estructurada antes de escribir una sola línea de código

✅ /speckit.constitution → las reglas del proyecto: calidad, testing, arquitectura
✅ /speckit.specify → describes QUÉ construir, no el stack
✅ /speckit.clarify → el agente pregunta lo que no entiende antes de empezar
✅ /speckit.plan → ahora sí eliges la tecnología
✅ /speckit.tasks → lista de tareas ordenada por dependencias
✅ /speckit.implement → el agente construye

El entregable ya no es código generado a lo loco

Es una especificación viva que tu IA lee, valida y ejecuta paso a paso

Funciona con Claude Code, Cursor, Copilot, Codex, Gemini CLI y más de 25 agentes

La diferencia real es esta

Antes: "hazme una app de tareas" y rezas para que el agente no se pierda a mitad

Ahora: especificación primero, código después

El agente sabe exactamente qué construir, en qué orden y por qué

95k estrellas. 8.3k forks. Publicado por el propio GitHub. Licencia MIT.

el repo aquí ⬇️

[Nikola Danaylov Ⓥ @singularityblog]

Jacque Fresco wanted to eliminate scarcity. Decades before anyone feared automation.

At 97, he was still asking why we apply #science to machines but run society on guesswork.

My full interview with the late Venus Project founder:
https://t.co/FtKIqlzTuf

[Nikola Danaylov Ⓥ @singularityblog]

13 years ago, I interviewed Peter Joseph on debt-based economics, #AI, and resource #scarcity.

In 2013, it sounded radical. In 2026, it reads like a weather report.

#Tech has caught up with the critique. Philosophy hasn't caught up with the tech.

https://t.co/d1xKy2L3rO

[Nikola Danaylov Ⓥ @singularityblog]

She coined the term "open source."

But Christine Peterson's bigger idea was this: the future is something to steer, not wait for.

We talked #nanotechnology, #longevity, and pushing tech in a positive direction.

13 years on, the #AI age needs it. https://t.co/eG3XmA1vSm