DOLET

• 

• 

• 

• 

• 

• 

• 

Inspiration

DOLET began with a question: what if an intelligent system could remain itself even when the AI model powering its reasoning changed?

Most AI applications are built around a particular language model. DOLET takes a different approach. The language model is a reasoning engine used by DOLET — the model itself is not DOLET.

I wanted to build a persistent software robot whose identity and state belong to the software itself. DOLET therefore maintains its own identity, memories, plans, permissions, tools and audit history independently of the reasoning model connected to it.

This architecture also creates an opportunity that is particularly relevant in environments where permanent cloud access cannot be assumed. If DOLET can use interchangeable reasoning providers, it can use powerful cloud models when they are available while also operating with smaller local models when connectivity, cost or privacy makes cloud inference impractical.

What it does

DOLET is a persistent software robot designed around a structured workflow:

Goal → Memory → Plan → Reasoning → Permission → Tool → Result → Audit

Rather than treating every interaction as an isolated chatbot conversation, DOLET maintains persistent state across interactions.

Its core manages:

• Identity — DOLET's identity exists independently of its reasoning provider.
• Memory — information can persist and later be retrieved as context.
• Planning — goals can be represented as plans rather than single prompts.
• Permissions — potentially sensitive capabilities are controlled by explicit permissions.
• Tools — DOLET can interact with approved software tools instead of only generating text.
• Audit history — actions and important events can be recorded.
• Interchangeable reasoning — different AI models can serve as reasoning providers without becoming DOLET itself.

For the Africa Deep Tech Challenge, DOLET extends this architecture to efficient local inference on commodity hardware, demonstrating how agentic capabilities can remain available where cloud APIs may be expensive, unreliable or unavailable.

How we built it

DOLET's core is implemented in Python with a modular architecture separating persistent robot functionality from model inference.

Persistent information is stored locally, while dedicated components manage memory, planning, permissions and audit history.

The intelligence layer uses a provider abstraction. This allows DOLET to connect to different reasoning systems without embedding its identity into any particular model.

DOLET has been developed with multiple reasoning paths, including local model inference and cloud-based model providers. Local operation is particularly important for the ADTC version because the challenge targets affordable CPU-based laptops with limited RAM and no discrete GPU.

The tool layer is also separated from the reasoning model. A model can request an action, but DOLET's core remains responsible for deciding whether that action is permitted and for executing approved tools.

This separation between robot, reasoning and execution is one of the central architectural principles of DOLET.

Challenges we ran into

One of the largest challenges has been defining the boundary between DOLET and the language models it uses.

Allowing a model to simply behave as the entire assistant would make DOLET dependent on that model. Instead, identity, memory, permissions, plans, tools and state need to remain controlled by the persistent core.

Another challenge is balancing capability with resource consumption. Large models can provide stronger reasoning but require significantly more memory and computational power. Running useful reasoning on an 8 GB CPU-only laptop requires careful model selection, quantization and inference optimization.

Agentic systems introduce another challenge: safety. Generating an answer and performing an action are fundamentally different. DOLET therefore uses a permission layer between reasoning and tool execution rather than automatically granting the reasoning model unrestricted access to the computer.

Accomplishments that we're proud of

DOLET has progressed from an idea into a functioning persistent software architecture.

The project now has a persistent core with its own identity and state, a memory system, planning, permission management, audit logging, interchangeable intelligence providers and controlled workspace tools.

I am particularly proud that DOLET's architecture does not define intelligence as identity. A reasoning model can be replaced while DOLET's persistent software state remains.

This makes it possible to explore a future where the same software robot can operate across very different computing environments instead of being permanently tied to one AI provider.

What we learned

Building DOLET has reinforced that an autonomous AI system requires much more than connecting an application to a language model.

Persistence, permissions, memory, tool execution, model orchestration and resource management all have to work together.

The Africa Deep Tech Challenge also pushes an important engineering constraint: useful AI should not require expensive hardware or permanent access to paid cloud infrastructure.

Optimizing DOLET for constrained hardware requires evaluating not only model quality but also inference speed, memory consumption and thermal performance.

What's next for DOLET

The ADTC implementation demonstrates that DOLET's persistent architecture can operate with a lightweight local reasoning model on constrained hardware. The next stage is to continue improving the efficiency, reasoning quality and reliability of this local path while expanding DOLET's persistent capabilities.

Future development will focus on stronger semantic and relational memory, richer task scheduling, improved sandboxing and security, multi-device persistence and synchronization, and broader integration with computers, applications and digital services.

Beyond the challenge, the long-term vision is larger: DOLET is intended to evolve into a persistent software robot capable of remembering, reasoning, planning and safely acting through digital tools while remaining independent of any single AI model or provider.

Models may think for DOLET. Models are not DOLET.

Built With

• docker
• json
• python
• qwen
• restapi