DOLET

A persistent software robot that turns goals into safe, auditable multi-step actions using Gemini 3.5 Flash with memory, permissions, recovery, and Core-controlled tool execution.

Comment

Inspiration

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

Most AI applications are organized around a language model and a conversation. When that conversation ends—or the model changes—the system’s continuity, authority and evidence often disappear with it.

DOLET takes a different approach:

Models may think for DOLET; models are not DOLET.

DOLET is the persistent software robot. Its identity, memory, plans, permissions, tools, task state, results and audit history belong to DOLET Core. Gemini is an external reasoning provider that helps DOLET decide what to propose next but it does not own the robot or execute actions directly.

The broader DOLET concept predates this hackathon. This Python implementation began on August 14, 2026, during the All Things Agentic Hackathon submission period. Its Core, Gemini integration, persistent Taskmaster workflow, provider resilience, controlled tools, audit evidence and Google Cloud deployment were built for this submission.

What it does

DOLET turns a natural-language goal into a persistent, auditable workflow:

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

For a multi-step goal, DOLET can:

  • Record the goal and create a persistent task.
  • Generate and store a multi-step plan.
  • Ask Gemini 3.5 Flash to propose one next action at a time.
  • Validate every proposal inside DOLET Core.
  • Check the required owner-controlled permission before execution.
  • Execute authorized workspace operations.
  • Feed verified tool results into later reasoning steps.
  • Read generated artifacts back to verify that they were actually written.
  • Pause safely for missing permission or required user input.
  • Persist unfinished and completed workflows across browser refreshes and process restarts.
  • Record planning, reasoning, permission, tool, result, retry, pause, recovery, and completion events in an audit trail.

Implemented workspace capabilities include listing and reading files, writing files, creating directories, no-overwrite moves, same-directory renaming, and explicit deletion. Terminal and public-network tools also exist behind separate permissions, but they remain denied in the safe demonstration configuration.

DOLET does not treat a model’s statement that work is complete as proof. Tool-dependent steps require successful Core-recorded results, and artifact workflows can include read-back verification before Core marks them complete.

Outside Taskmaster workflows, DOLET also supports persistent memory capture and recall, conversational responses, planning, and interchangeable reasoning providers.

How we built it

I built DOLET in Python around a set of persistent Core systems:

  • Identity
  • JSON-backed memory
  • Planner
  • Persistent task execution manager
  • Permission manager
  • Controlled tool layer
  • Append-only audit history
  • Provider abstraction
  • Web API and judge-facing interface

For reasoning, DOLET uses the official Google Gen AI SDK (google-genai) with Gemini 3.5 Flash through Vertex AI.

Google SDK automatic function calling is explicitly disabled. Gemini receives context and returns a proposal; it does not receive direct callable access to DOLET's tools. DOLET Core parses and validates the proposal, enforces permissions, performs authorized operations, and returns verified results for subsequent reasoning.

The provider abstraction also retains local Ollama and safe Bootstrap fallback paths. Changing the reasoning provider does not change DOLET's identity or persistent state.

I deployed DOLET as an authenticated container on Google Cloud Run in the africa-south1 region, with Vertex AI as the Gemini backend.

Cloud Run uses an attached runtime service account with Vertex AI permissions, so no Gemini API key is embedded in the source code, container image, or Cloud Run environment variables. Persistent Core state is mounted under /mnt/dolet through a private Google Cloud Storage volume.

Challenges we ran into

One of the hardest challenges I faced was maintaining a strict boundary between reasoning and authority. A model can generate a convincing plan or tool request but DOLET still has to determine whether that proposal is valid, authorized, safe, and supported by real evidence.

Multi-step recovery introduced another difficult problem: avoiding duplicate side effects. If reasoning encounters a transient 429, 503, timeout, or transport failure after a tool has already succeeded, DOLET must retry the reasoning point without executing the completed mutation again. Retry checkpoints, completed action results, and uncertain interrupted mutations therefore have to be persisted carefully.

Provider output is also not always perfect. Large or malformed action proposals can fail protocol parsing even when the provider request itself succeeds. DOLET fails safely in this situation instead of guessing or executing incomplete instructions.

Cloud deployment introduced a separate persistence challenge. Cloud Run instances are replaceable, so task and memory continuity could not depend on the container filesystem. I used a mounted private Cloud Storage state directory while treating the current JSON-backed, single-instance design as a prototype constraint rather than claiming horizontally scalable database persistence.

Finally, I needed the interface to restore the same Planner, Taskmaster, and Audit evidence after refresh instead of presenting an attractive but temporary browser-only demonstration.

Accomplishments that we're proud of

I am especially proud that DOLET demonstrates real agent execution rather than simulated “agent-like” conversation.

The working system has demonstrated:

  • Persistent multi-step plans and task state.
  • Sequential, Core-authorized workspace actions.
  • Later reasoning based on verified earlier results.
  • Artifact creation followed by read-back verification.
  • Permission pauses instead of silent privilege escalation.
  • Safe recovery of failed steps without restarting an entire workflow.
  • Provider retry handling with bounded backoff and audit evidence.
  • Restart and browser-refresh restoration of completed Taskmaster workflows.
  • Sanitized audit records that do not copy file contents, prompts, or credentials.
  • Workspace confinement with rejection of traversal, absolute paths, symlink/junction escapes, unsafe overwrites, and workspace-root deletion.
  • A healthy authenticated Google Cloud Run deployment using Vertex AI and the Google Gen AI SDK.

The current automated test suite passes 75 out of 75 tests. Coverage includes persistence, planning, permission enforcement, provider selection, Gemini SDK request construction, retry and recovery behavior, restart safety, workspace confinement, controlled file management, audit redaction, web endpoints, security headers, and persistent Taskmaster restoration.

What we learned

I learned that the most important part of an autonomous agent is not merely how well its model reasons. It is the software boundary around that reasoning.

A useful persistent agent needs explicit ownership of state, permissions, execution, recovery, and evidence. It must distinguish between a model proposal and an action that actually happened.

I also learned that retry logic is not simply “send the request again.” A persistent agent must know exactly which reasoning point failed, which tools already ran, whether a mutation's outcome is certain, and what may safely be resumed after restart.

Using the Google Gen AI SDK with Vertex AI reinforced the value of keeping the provider replaceable. Gemini 3.5 Flash provides DOLET's reasoning, while Google Cloud Run and Google Cloud provide a reproducible execution environment. DOLET Core still remains authoritative over everything that affects the outside world.

What's next for DOLET

My next priority is to make large artifact-generation workflows more reliable through stronger structured-output constraints, better finish-reason diagnostics, and safe handling of responses that exceed an action budget.

I also want to evolve the prototype persistence layer toward a concurrency-safe production architecture, extend the current lexical memory system with semantic retrieval, and develop richer human approval workflows without weakening Core authority.

Future tools can expand what DOLET is able to accomplish, but they will follow the same rule: every capability must remain bounded, permission-controlled, verifiable, recoverable, and auditable.

The long-term goal is not to turn DOLET into another chatbot. It is to build a durable software robot that can use today's and tomorrow's models while retaining its own identity, responsibilities, and evidence of action.

Built With

  • artifactregistry
  • gemini3.5flash
  • googlecloudbuild
  • googlecloudrun
  • googlecloudstorage
  • googlegenaisdk
  • python
  • vertexai
Share this project:

Updates

Submission history