DEV Community: David Laurenvil

If I Only Had a Brain

David Laurenvil — Wed, 07 Oct 2026 01:17:10 +0000

_The smartest thing you can do with Cortex is reduce token usage while saving money on skyrocketing AI inference costs.
_

Today, we’re releasing Cortex (www.na8ve.com), and have open-sourced the na8ve cli agent ( https://github.com/na8ve/na8ve-agent) to the general business community.

Between a model’s general intelligence and the intelligence an enterprise actually needs lies a gap of business context. Closing this gap, is at it’s core, a data problem. The next generation of enterprise AI will not be limited by model intelligence alone. It will be limited by whether enterprises can turn their data into real-time, trusted, and actionable context.

Business decisions are informed by data. Cortex gives you the context management, observability, and governance to make the right decisions.

The Scarecrow in The Wizard of Oz was not short on parts. He had straw for a body, a coat, a hat, and a face that held a smile the whole way from Munchkin land to the Emerald City. What he wanted most during the entire trip down the yellow brick road, was a brain: something that could actually think. His core pain was the belief that he lacked a brain, which made him feel foolish, inadequate, and helpless. His ultimate solution was realizing that he had been intelligent all along. Throughout their journey down the Yellow Brick Road, the Scarecrow was actually the character who consistently solved problems, devised clever plans, and displayed the most logic and resourcefulness.

Most organizational data systems are more like the Scarecrow than anyone would like to admit. They have the parts: rows, columns, indexes, and a database nailed to the rafters with straw. What most of them lack is anything that thinks with the valuable data they already have, which is different from storing and embedding search.

Some are worse off than that. They are closer to the Tin Man found rusted solid in the woods: not missing the idea of thinking, but missing the part that actually moves the organization forward; analytics and audit trails. A table with a similarity search bolted on top of a handful of embeddings, queried the same rigid way every time, is an outdated machine standing exactly where it stopped in time, waiting for someone to bring the oil can. It runs on simple SQL and simple embeddings, and it operates blindly, while machine learning and AI insights move about it with ease and rapid speed.

Cortex, an AI-native streaming datastore that thinks

Like the Wizard offering the Scarecrow a diploma to validate his intelligence, or the Tin Man a ticking heart to validate his capacity, na8ve provides organizations with Cortex, an AI-native streaming datastore for institutional memory, analytics, and auditability on top of their AI stack.

Video: https://youtu.be/zGBlLbUSo_U?si=8Fi37XlfpImbMmgz

Most institutional analytics is built the same way regardless of what it measures: something is logged, the logs are exported on a schedule into a database of static tables, and a dashboard runs search queries against those tables to answer questions about what already happened, sometimes hours after it happened.

Cortex is built differently at the foundation. Its memory is reactive: when a fact changes, anything watching that fact, the live console, an aggregate view, another AI agent working on the institution’s behalf, updates immediately, the same way the console’s brain surface repaints the instant a brain region starts working. There is no nightly export, no refresh button, and no dashboard quietly serving a copy from three hours ago while the real record has already moved on. A human brain does not need to be told to refresh. It already knows, the moment something changes, because knowing and storing were never two separate steps to begin with.

Continuous memory, with a direct view of the cognitive process

The design underneath Cortex is simple: model memory as neuronal plasticity, and stream updates to model weights directly to the console. Every screen, every presentation, and every agent works on an institution’s behalf using memory built from the organization’s data.

This opens the opportunity for true AI and organizational governance. Cortex has one memory because it holds facts that can be updated and change overtime.

Institutional memory is not incidental to Cortex. It is half of what makes Cortex worth its enterprise value. The other half is what an organization can actually do with its memories: like watching dataflow updates in real-time, querying its knowledge store at any scale from individual student-level reporting to institutional strategic planning, and letting na8ve agent serve the organization as an agentic harness to improve productivity. Everything from planning, executing, and reviewing workflows can be done because Cortex models the organization as itself, once it is trained on institutional knowledge.

Try it yourself: www.na8ve.com

The na8ve agent terminal: https://github.com/na8ve/na8ve-agent

Demos:

School — https://github.com/na8ve/case-study-school
Coding — https://github.com/na8ve/case-study-coding
Clinical — https://github.com/na8ve/case-study-clinical
Auto-Lab — https://github.com/na8ve/case-study-autolab
Biotech — https://github.com/na8ve/case-study-biotech

What if every student had their own learning model, instead of a general AI tutor?

David Laurenvil — Fri, 28 Aug 2026 06:32:51 +0000

Better yet, what if parents and teachers had full authority and control of their child's individual AI, so they could see how and why their students learn and achieve?

Too often we lean into inquiry-based learning and Socratic methods without knowing if that matches our student's learning style. So we guess, the way teachers have always guessed, and the kids who get the most out of us are the ones lucky enough to be sitting near an educator who happens to guess right about them. Our standard approach is a bit antiquated, but we don't have to continue operating this way.

With the advancement in AI, each child can gets a small model of their own, that holds what it has actually observed and learned about them. These models wouldn't average them into a cohort and then compare them to another. The models could measures your child's progress against yesterday's learning gains, never comparing them to another child, because every child learns differently. That would make the models fair. You could also open, read, argue with, and overrule the personal models, which is the part I care about most: parental control of the AI model. The models would exists to accelerate learning for one specific child. Not engagement, not time in the app, not completion percentage, but the thing education was created to provide: learning.

We tested the idea by simulating three students on the na8ve.ai platform so that we could watch how the models behaved. Before every one of these test runs, we wrote down what we expect to happen, then track the model's behavior during testing, along with the student's learning outcomes.

We discovered some interesting findings about how these personal models handle fairness: Two children, same skill, same week, both correct, but sent in opposite directions. Nobody programmed that outcome. It came from the model reading two different children's actual memory states and reaching two different conclusions, which is exactly the judgment a good teacher would make. The more the model understands the individual child, the less biased it is in serving that child's learning needs.

A single model answering every child the same way is a recipe for scaling biases onto a child it doesn't understand.

Alternatively, a model that belongs to one student and holds only what has actually been observed about them, one that shows an adult exactly how the student learns and how it reached its conclusion, one that hands over full authority and control to the adult, is a completely different kind of model. We're excited to share that model with those who need it most, and to share the journey of na8ve, what we believe, and the evidence we discover while keeping parents and teachers in the loop of their child's learning journey.

Read the research at: https://na8ve.ai/research/personal-learning-models

hashtag#AITutor hashtag#PersonalLearningModel hashtag#STEM hashtag#Education

I Built The UnoQ's Claw: A Tiny Agentic AI Assistant That Lives Inside an Arduino Uno Q

David Laurenvil — Thu, 21 May 2026 05:42:00 +0000

Every "AI on hardware" demo you have ever seen has a LLM behind it. The user talks to a board via a terminal or Telegram, and the board calls an API to have a cloud model do the work. QClaw flips that arrangement. The Arduino Uno Q hosts the language model, runs the agent loop, drives the compile toolchain, and flashes its own microcontroller.

Ask QClaw to scroll "QClaw" across the LED matrix and it does. End to end. On the board. Offline.

QClaw has an eight-tool agentic surface, a fifteen-skill pre-router, and a direct OpenOCD flash route that makes autonomous uploads actually execute. A dual-path runtime lets you pick speed or full hardware control on the same model.

Why the Uno Q Is the Right Board for This

The Arduino Uno Q is a split-silicon device. It looks like a classic Arduino on the outside, but it is two boards in a trench-coat:

The MPU and MCU share the same PCB. The MPU can hold the MCU in reset and reprogram its flash directly through GPIO pins wired to SWD via the linuxgpiod driver. No USB cable between them. No probe. No second machine. That is the genius of QClaw.

The agentic loop orchestrates the full sketch lifecycle across the Arduino Uno Q's dual-silicon topology, with the MPU driving the loop and the MCU executing the resulting firmware. This is how QClaw generates, compiles, flashes, and observes.

The QClaw arduino tool invokes OpenOCD directly at the correct address. The tool compiles with arduino-cli compile --fqbn arduino:zephyr:unoq --export-binaries, picks up the resulting .elf-zsk.bin, and pipes it through OpenOCD over the GPIO SWD bridge. No SSH, no network credentials, no remote OCD tunnel. Just MPU to MCU, on the same board. Sub-second flash once the binary is on disk.

Four gigs of RAM is also more than enough to host a Qwen3.5 0.8B Q4_0 model with an 8K context window, mlocked, with q8_0 KV cache. QClaw lives on the Uno Q at around 1.3 GB. Decode runs at roughly 8 tokens per second. Slow next to a desktop GPU, fast enough that a sketch compiles and flashes before you have finished your coffee.

*How To Use QClaw *

QClaw ships two runtimes on top of the same llama-server backend, the same SOUL.md, and the same 23-rule pre-router. They differ in what wraps the LLM call.

Agentic path (make qclaw-agentic). the qclaw Go gateway sits in front of the model. It runs channel adapters (terminal, SSH, Telegram), the multi-iteration agent loop, the pre-router, and the eight-tool dispatcher. This is the production default. It is the only path that can actually compile and flash a sketch.
Direct path (make qclaw-direct). A thin Python REPL POSTs directly to llama-server after running the same pre-router rules in Python. No loop, no tools, no Telegram. About 33 percent lower latency on pure factual prompts at equivalent correctness, because there is no tool schema in the prompt and no second iteration.

Use the agentic path when you want a sketch flashed or a frame captured. Use the direct path when you just want to ask which pins on the Uno Q do PWM.

Drop in two commands and you have a session:

git clone https://github.com/laurenvil/Uno-QClaw.git ~/ArduinoApps/QClaw     

cd ~/ArduinoApps/QClaw     

git submodule update --init --recursive     

# Download the inference engine     

cd yzma && make download-llama.cpp && cd ..     

# Download the model (~490 MB for Q4_0)     

mkdir -p ~/models     

wget -O ~/models/Qwen_Qwen3.5-0.8B-Q4_0.gguf \     

     'https://huggingface.co/Qwen/Qwen3.5-0.8B-GGUF/resolve/main/Qwen3.5-0.8B-Q4_0.gguf'     

# Build, install arduino-cli, configure (one time)     

make qclaw-install     

# Start a session — pick a path     

make qclaw-agentic    # full agent loop + 8 tools (compile/upload/camera/sysfs_led/network/i2cdetect)     

make qclaw-direct     # pre-router + direct API (fast Q&A, no tools)

make qclaw-install builds the Go binary, copies the system prompt and the fifteen-skill tree into ~/.qclaw/workspace/, installs arduino-cli plus the arduino:zephyr core, and runs an interactive wizard that sets up the optional Telegram gateway.

Once it is running, the agent has eight narrowly-scoped tools available:

read_file, write_file, list_dir for workspace navigation
arduino for compile and flash via OpenOCD
camera for single-frame V4L2 capture through GStreamer
sysfs_led for the MPU-side RGB LEDs at /sys/class/leds/*
network for hostname, interfaces, and the default gateway, all read-only stdlib Go
i2cdetect for listing and scanning Linux I²C buses with -y -r only
No general exec. No general shell. Every tool validates its arguments against an allow-list. The total tool schema is around 3.4K characters, leaving plenty of room for the system prompt at an 8K context window.

The Pre-Router: Skills, Not RAG

The pre-router is the part of QClaw that does the heavy lifting on a 0.8B model. It is not RAG. It is a flat table of 23 keyword regex rules across 15 skills. When you send a message, the pre-router scans it, finds matching rules, and inlines the relevant SKILL.md plus its referenced files directly into the system prompt before the LLM call.

The model never has to call read_file for canonical skill content. The content is already there. At 0.8B scale, a read_file call costs a full LLM iteration, roughly 10 to 20 minutes of cold prefill plus decode. The pre-router amortizes that to zero.

*The skills cover: *

Sketch fundamentals: blink, breathe, button, potentiometer, servo, compile and upload, CAN bus, DAC, OPAMP
The 13x8 LED matrix with the canonical Arduino_LED_Matrix template
Uno Q hardware: pin tables, voltage rules, connectors, power
Dual-chip workflow: Bridge RPC, App Lab, Bricks
Linux-side capabilities: Wi-Fi, Bluetooth, camera, OpenCV, microphone, sysfs LEDs
Plug-and-play Modulino sensors
Each skill is just a directory under workspace/skills/<name>/ with a SKILL.md and optional reference files. Adding a new one is a matter of writing the markdown and adding a regex rule.

*Try It *

Repo:https://github.com/laurenvil/Uno-QClaw

Issues, forks, and pull requests are welcome at https://github.com/laurenvil/Uno-QClaw. If you have an Arduino Uno Q on your desk, you can have a self-flashing AI assistant sitting on it tonight, with the Ethernet cable unplugged.