Giving AI a Memory, a Job and Eventually a Body

I originally got into local AI in the same way a lot of people probably did…curiosity.

I wanted to see what would happen if I stopped treating AI as something you only access through a browser tab or an API and started running it on my own hardware. At first, that meant experimenting on my Alienware laptop. It was a good place to begin, perfectly capable of running smaller models locally without sending everything to the cloud.

That first phase was exciting because it made AI feel closer, cheaper, more personal and more secure. I could try different models, test agent frameworks and play with the idea that AI becomes much more interesting when it is given tools rather than just prompts. Instead of simply asking for an answer, I could start asking what happens when a model can search, retrieve, execute, remember and work through a task over time. But quickly I realised I was no longer really interested in chat. What I wanted was something more persistent.

I wanted AI that could remain available in the background, that could remember previous work, even the smallest detail. AI that could use tools, retain context and gradually improve through repetition rather than starting from scratch every time. And beyond that, I found myself increasingly drawn to a bigger question: what happens when that kind of AI can eventually connect to cameras, sensors and machines in the physical world? That was the point where the experiment changed.

The question stopped being “what model can I run locally?” and became “what kind of system do I need if I want AI to have memory, agency and eventually a body?” That is what led me to the Dell Pro Max with GB10.

The real change was not just speed

What changed for me with Dell Pro Max with GB10 was not simply performance in the narrow benchmark sense. It was that it made a different style of experimentation practical. The combination of Grace Blackwell architecture and 128GB of unified memory changed the way I approached local AI almost immediately. On the Alienware laptop I was often thinking in terms of compromise, what could fit, what had to be cut back. Which model was small enough to run acceptably. Whether I could get away with shorter context, fewer services or a more limited setup.

With Dell Pro Max with GB10, the mental model shifted. I found myself thinking less about what I could squeeze in and more about what was appropriate for the task. Which model made sense. Whether I wanted to run multiple services at once. How much context I wanted to preserve. How much memory I wanted an agent to retain. Whether the system could support something persistent rather than something temporary. That flexibility has been the real game-changer for me.

The other part I do not want to understate is the practicality of it. If a system is going to sit there running models, memory services and background agents for long stretches, power draw and day-to-day efficiency matter. That was part of the appeal here as well. I was not looking for a loud, power-hungry box that only made sense during short bursts of experimentation. I wanted something I could genuinely live with as part of a persistent local AI setup that sat on my desk. In my own use, Dell Pro Max with GB10 has been sitting at around 11W at standby, which says a lot about why it feels realistic as an always-available local system rather than a machine I only want to switch on occasionally.

There will always be other systems that are faster for a specific benchmark or better optimised for a model that fits neatly into a smaller pool of memory. But that is not how I think most people end up using AI once they move beyond novelty.

A useful agent is not just a model producing text as quickly as possible. It is an environment, or rather the way you interact with that environment. It may need to run a model, call tools, access files, search previous conversations, maintain memory, execute code, process images and interact with several supporting services. The more I experimented, the clearer it became that this private interface to everything from email, the web, through to systems administration and code generation, mattered more to me than isolated speed.

The moment AI starts to feel persistent

Most people still experience AI as a conversation. You open an application, ask a question, receive an answer and move on. Even when the answer is impressive, the interaction is temporary. A personal agent feels different.

An agent can remain active. It can monitor something, use tools, perform a task, store information and return later with a result. It can remember what happened last time. It can improve its workflow. It can accumulate context rather than constantly throwing it away. That is a very different model of AI.

Cloud models are still incredibly useful, and I continue to use them regularly. They provide access to extraordinary capability, and there are many things that remain easier or better to do through cloud services. But persistent agentic behaviour changes the economics quite quickly. Long context, repeated model calls, tool use, image processing and memory retrieval all add up. More importantly, there is a subtle psychological effect: when every experiment has a visible API cost, you naturally become more conservative. You give the agent fewer attempts. Shorter context. Less room to fail, recover and try again. Local AI changes that feeling.

When the marginal cost of experimentation is much lower, I find myself more willing to let an agent explore. To let it fail. To let it critique its own work, try a second path and slowly converge on something better. A lot of the most interesting learning seems to happen in exactly those loops.

Giving AI memory instead of just answers

One of the most important things I have been experimenting with is memory. Not memory in the vague marketing sense, but practical, persistent memory that can make an agent more useful over time. I have been testing both OpenClaw and Hermes Agent on Dell Pro Max with GB10. They approach the agent problem differently, and that difference has been useful to explore. OpenClaw feels more like a local-first, always-available assistant built to connect across channels, tools and workflows. Hermes Agent feels more explicitly centred on the agent itself as a system that learns over time through tools, skills, memory and self-improvement.

The model is no longer the complete system. The model provides reasoning, but the usefulness of the overall agent depends just as much on its tools, its instructions, what it can access and what it can remember. I increasingly think it also depends on something closer to a soul, not just in the abstract sense of continuity, purpose and behavioural character, but in the literal sense that a SOUL.md file can define the agent’s personality, priorities and way of engaging with the world. In practice, it is a plain-text file of guiding instructions that gives the agent a durable sense of identity and behavioural direction across interactions, for example, specifying a warm personality default, or a more formal, concise, playful or analytical style suited to the user(s). That file becomes part of what makes the agent feel coherent over time rather than like a stateless machine producing isolated responses. Without that, even a capable agent can feel fragmented and amazingly bland to use. With it, the system begins to feel like it has not just capability, but identity and direction. This matters more than I expected.

An assistant that answers the same question every week is useful; however, an agent that remembers how it solved that question last week, retains the important steps and improves the process is something else entirely, which is why the memory architecture attached to the agent is so critical.

I have also been experimenting with the native memory capabilities inside Hermes Agent as well as related agent memory projects like Hindsight and MemPalace. My MemPalace environment has already grown into hundreds of structured ‘drawers’ covering different parts of work and experimentation. It is still early and there are still obvious problems to solve. More memory does not automatically create better memory. An agent that remembers everything without understanding relevance can become less helpful rather than more. But even with those caveats, the direction feels clear to me. Persistent memory turns out to be just as important, if not more so, to practical agents, as the underlying model itself.

The point where AI leaves the screen

The part of this work that gets the strongest reaction from people is the robotics. That reaction makes sense, because there is a big difference between watching AI generate a paragraph and watching it make something happen in the physical world. A language model can be clever, useful and even surprising, but it still feels contained. Once an agent can see through a camera, control a robotic arm or move through another room, the experience changes, with the intelligence becoming far more tangible. That is what I have been building toward.

At the moment, I am also using an Nvidia Jetson Orin NX, connected to an Intel RealSense depth camera, to control a robotic arm. The RealSense gives the system RGB imagery, depth information and a sense of spatial structure. The aim is not just to issue pre-scripted movement commands. I want the system to be able to perceive an object, estimate where it is, plan an action, execute it and then use visual feedback to decide whether the attempt actually worked.

That sounds straightforward when written down in one sentence. In practice, it requires perception, reasoning, planning, control and feedback to work together as a system.

The Nvidia Jetson Orin NX is well suited to the immediate robotics and perception layer. It can stay close to the hardware, process the camera feed and handle real-time workloads without relying on a constant connection to a larger external system. Dell Pro Max with GB10 then sits above it as a higher-level reasoning and memory layer. Rather than trying to control every motor movement directly, it can interpret the task, understand the broader objective, create a plan and retain information about what happened.

That layered structure is where things start to feel genuinely exciting. Because the next step is to take that same idea and quite literally give it legs.

From robotic arm to robotic dog

The next phase of my project is to mount the Jetson Orin NX onto a Unitree Go2 and turn it into a mobile extension of the same agentic environment.

The idea is simple, even if the implementation definitely is not. The Jetson travels with the robot and handles the local robotics layer: sensor processing, immediate control, navigation and edge perception. Dell Pro Max with GB10 remains the larger reasoning system, providing access to more capable models, broader planning and persistent memory.

The first goals are modest enough: view the camera feed, access LiDAR data, send the Go2 to a specific room and trigger particular actions or poses. But even those apparently simple tasks involve an enormous amount of coordination.

To tell a robot to go and check whether a door is open, the system has to understand the request, know where it is, identify the relevant room, plan a route, avoid obstacles, find the door, interpret what it sees and report back meaningfully. None of those pieces is new in isolation. What feels new is how accessible it has become to start combining them using open-source software, edge hardware and relatively simple prompts of increasingly capable local models.

That is the point where AI starts to feel less like a chatbot and more like a system that can take responsibility for completing a task, even one in the physical world.

Why edge AI feels different to me

For me, this is the real promise of edge AI.

Not just that it brings inference closer to where data is created, while potentially reducing cost and latency, all while improving privacy, though both matter. What excites me is that edge AI makes it more practical to build systems with continuity. Systems that stay available and remember. Systems that interact with real tools and real environments, that can bridge the gap between reasoning and action.

That is also why I think embodiment changes the conversation.

Once AI can observe and affect the physical world, even in relatively simple ways, it stops feeling like a purely digital trick and starts to feel like critically important infrastructure. Something you design around. Something that can become part of a workflow, a machine or an environment.

The Alienware let me begin exploring that world. Dell Pro Max with GB10 is what made it make sense architecturally.

Local does not mean automatically safe

One of the major attractions of local AI is privacy. Models, files, memories, camera feeds and agent activity can remain within an environment I control rather than constantly being sent to external services. For personal agents, that matters. A genuinely useful agent could eventually know a great deal about how I work, what I am building, what systems I use and how I prefer tasks to be completed. I would much rather retain control over where that context lives.

But local AI should not be confused with automatically secure AI. An agent with access to files, terminals, credentials, cameras and physical systems can create very real risk if it is not carefully constrained. In some ways, a capable local agent deserves more caution than a conventional cloud chatbot because it may have far more ability to act. Tools need limits. Credentials need segmentation. Actions need logging. Trust boundaries need to be deliberate.

The benefit of running locally is not that the security problem disappears. It is that I get to decide how that problem is managed.

Trust takes time

Trust is probably the other major theme that sits alongside memory, capability and embodiment.

It is easy to be impressed by what an agent can do on a good day. It is much harder, and much more important, to build confidence in what it will do consistently over time. That kind of trust is not created by a demo; it is built gradually, through repeated observation, clear boundaries and a growing understanding of where the system is reliable and where it still needs closer supervision. That applies both to the models themselves and to the agents built around them.

I have also seen the stranger side of that first-hand. Some of the model eccentricities have been genuinely funny in retrospect. I have had agents fall into completely absurd loops, fixating on the same action or line of reasoning long after it was obvious they were stuck. In a few cases, after I expressed frustration, the model seemed to swing into an exaggerated tone of apology or self-critique, only to start looping again around that sense of failure instead of returning to the task. It can feel faintly ridiculous when you are watching it happen, but it is also part of the reality of working with these systems in their current form.

At a high level, my sense is that this happens because these models are always predicting the next most likely token from the context they have in front of them. Once a pattern starts repeating, whether that is an action loop, an apology loop or a kind of self-referential spiral, the model can end up reinforcing the pattern it has already created. That seems especially likely with some models, tighter context windows, weaker prompting or more limited local resources, where the system has less room to recover gracefully and more tendency to latch onto the most obvious continuation. Frustrating as that can be in the moment, it is also part of the fun. A lot of the learning comes from seeing exactly how and where these systems go wrong, then redesigning the environment so they fail in more useful ways.

A model may be intelligent, but that does not automatically make it dependable. An agent may complete a task successfully ten times and still fail in an unexpected way on the eleventh. When tools, memory and physical systems are involved, those failures matter a lot more because the consequences are no longer confined to a chat window. The path to useful agentic AI is not just about increasing capability. It is also about learning where trust is earned, where it is not and how much autonomy should be granted at each stage.

That is one reason I increasingly think these systems need to begin from a zero-trust, or at least very low-trust, posture. In practice, that means assuming the agent should start with limited permissions, limited reach and carefully controlled tools. It means treating memory as useful but not automatically authoritative. It means expecting verification, logging and human oversight to be part of the system rather than something added later. If trust grows, it should grow because the agent has repeatedly demonstrated good judgement inside those boundaries, not because the model sounds confident.

That same mindset is part of why Dell Pro Max with GB10 feels well suited to this kind of work. One of the benefits of a local, more controlled environment is that it becomes easier to design security and trust in from the beginning. Sensitive context, memory, models and agent activity can remain closer to the system I am actually managing. Combined with sensible default agent settings that assume low trust rather than broad entitlement, that creates a much better foundation for experimenting safely.

If agents are going to become genuinely useful, especially once they can access tools, credentials, cameras and machines, trust will have to be earned in layers. First the model, then the workflow, permissions, and eventually, the autonomy.

From one Dell Pro Max with GB10 to two

Since I started writing this blog, I have added a second Dell Pro Max with GB10 and linked the two systems with a ConnectX-7 cable. It is still early days, but the impact has been so substantial that I want to call it out rather than wait until I have finished exploring every edge case.

The difference is not simply that I now have twice the hardware. With tensor parallelism and agent parallelism, I can use substantially larger models and distribute workloads in ways that were not practical on a single system. The felt improvement is closer to a tenfold increase in both performance and capability than a simple doubling. Models that previously felt constrained now seem much more capable, and the overall experience easily resembles using a frontier cloud model from a few months ago, except that the infrastructure is sitting here, under my control, with no cost aside from power and available for experimentation whenever I need it.

Just as importantly, several of the limitations I had started to accept have effectively disappeared. Out-of-memory failures are no longer a constant constraint, and the limited context-window issues that regularly shaped what I could attempt have largely faded into the background. I can keep more of the system running, try larger and more complex workflows and experiment with parallel agents without everything competing for the same resources.

This has changed the character of the Dell Pro Max with GB10 for me. The first machine felt like a powerful workstation somehow fitting inside a tiny quiet box that sits on your desk. With the pair, it now feels more like a small, personal AI platform, something capable of supporting persistent services, larger models, robotics and real-time experiments, indexing, memory, background agents and testing all at once. Much more akin to the experience of using a large frontier AI model.

It is early, and I am still learning what this configuration can really do. But the leap has been startling enough to make the next stage feel less like incremental optimisation and more like crossing a threshold. As Arthur C. Clarke famously put it: “Any sufficiently advanced technology is indistinguishable from magic.” That’s exactly how I would describe the first few days with two Dell Pro Max with GB10 systems.

The bigger shift

When people talk about AI, the conversation naturally gravitates toward better, faster or larger, more capable models. Those improvements matter, and they will continue to matter, but I increasingly think the larger shift may come from what surrounds the model.

• • • • A model can reason.

     

    • • An agent can reason, remember and use tools.

     

    • • An embodied agent can reason, remember, use tools and affect the physical world.

     

The infrastructure needed for that future looks different from the infrastructure built for occasional chat or image generation. These systems need to stay available. They need persistent memory, supporting services and connections to local devices, all while having clear security boundaries. They need to operate as systems, not just demos. That is why my journey has been so interesting to me.

Dell Pro Max with GB10 is not the answer to every AI workload. There are faster systems (including its bigger brother, Dell Pro Max with GB300) and cloud services that can access far larger models. But for the kind of experimentation I care about most now, persistent local agents, memory, robotics and embodied AI, it has changed what feels practical enough to build around.

Dell Pro Max with GB10 is where it started to feel like architecture, and the next step, quite literally, is to give that architecture four legs.