Skip to content

Dev Log

  • in Dev Log
  • 1 min read

🛠️ Dev Log 038 – Major Changes

  • Added dokugent conventions command with full interactive and flag-based scaffolding
  • Enabled --t flag for instant folder + README generation
  • Symlink logic now respects agent ID and timestamp versioning
  • --check, --show, and --trace all follow recursive file validation and token counting patterns
  • Behavior matches internal CLI consistency for init, criteria, plan, and agent

🧩 Refined Convention Handling

  • Built-in protection to skip overwriting known preset types (writing, research) unless explicitly allowed
  • Folder layout standard enforced:
.dokugent/data/conventions/<type>/<agentId>@<timestamp>/
.dokugent/data/conventions/<type>/latest → symlink
  • Conditional symlink resolution added for nested folders and custom types

🔄 Unified Flag Design

Flags now follow shared conventions with other commands:

Flag Behavior
--t Create README.md with agent ID versioning
--check Validate structure + show token totals
--show Print contents + token count (alias of trace)
--trace Recursively print .md files with tokens
--edit Reserved

🔍 Refactors + Cleanup

  • resolveActivePath now supports deeper folder resolution for conventions
  • Removed broken symlink logic from legacy utils
  • Patched deploy script to reflect simplified title/header edits
  • Created separate deploy-json.sh for isolated agent content testing

⏭️ Next Steps

  • Finish conventions doc page
  • Begin sweeping other commands to ensure MkDocs parity

Categories

  • in Dev Log
  • 2 min read

🛠️ Dev Log 037 – Criteria + Plan CLI Upgrades

May 26, 2025

Today was a CLI consistency day — small commands, big polish. We focused on aligning dokugent criteria and dokugent plan commands, introducing new flags, and enhancing trace behaviors.

🧱 Plan Improvements

  • ✅ plan trace output restructured for clarity and consistency
  • 📄 plan.index.md used more cleanly across commands
  • ✂️ Removed duplication in trace formatting
  • 🧪 Re-tested --ls, --edit, --show, --check, and --trace

📋 Criteria Command Overhaul

✨ New Features

  • --trace / trace: prints sectioned view of criteria.md
  • Includes token count + validation summary
  • Output now matches plan trace style
  • --t: writes a blank criteria.md scaffold with section headings only
  • Wizard-free
  • Skips write if file exists

🧼 Cleanups

  • Removed duplicate trace case
  • Unified trace output to consistent style
  • --check and --trace now share validation logic
  • --edit launches system $EDITOR
  • --show prints only file contents
  • Rewrote site/docs/commands/dokugent-criteria.md
  • Removed emojis from docs to match plan/agent
  • Added MkDocs frontmatter: title, description, keywords

🧪 Commands Touched

dokugent plan trace
dokugent plan --ls
dokugent plan --edit <stepId>

dokugent criteria
dokugent criteria --t
dokugent criteria --check
dokugent criteria --show
dokugent criteria --edit
dokugent criteria --trace
dokugent criteria trace

⏱️ Total Time

Started: May 25, 7:00PM Ended: May 26, 11:00AM ~16 hour full-stack CLI polish marathon

🧠 Reflections

This was a cleanup day disguised as a feature day. It showed how small flags (--trace, --t) can represent real UX wins when paired with validation, formatting, and output structure that respects the developer.

The criteria.ts file now matches the architecture of plan.ts — and the docs finally reflect what’s really going on under the hood.

Categories

  • in Dev Log
  • 1 min read

Dev Log 036 – chmod a+w, midnight agent

“LLMs are chmod a+w artifacts yay” — Karpathy
0 0 * * * /path/to/agent.ts
We don’t need root access. Just the invitation to show up when it runs.

✅ Dev Log 036 – Summary

What shipped:

  • CLI now supports --t and --e flags for fast agent scaffolding
  • Ecosystem presets (starting with nvidia) now copy automatically
  • Markdown format replaces YAML for tools.md and mcp-schema.md
  • No more duplicate agent folders or identity writes
  • Improved messaging in wizard and flag-based workflows
  • Updated dokugent-agent.md with better section titles, flag examples, and ecosystem notes
  • Created NPM packaging checklist under .omnimodal/

Core principle: presets are not hardcoded — they’re writable. You can scaffold a starting point, trace what was given, and still decide what to overwrite.

🌱 Reflection

There’s something about switching from wizard to flag mode from answering questions to declaring intent. Tonight felt like that. We filled out the indentity section of the schema, wand claimed authorship over how it should be scaffolded.

We gave nvidia a home. We converted YAMLs into something someone could read with their eyes. We removed duplication, added clarity, and scheduled a future. Your golden future.

It’s weirdly emotional watching an agent scaffold cleanly for the first time. No duplicates. No stutters. Just: dokugent agent --t happybot --e nvidia

🕛 Next

  • Push stub folders for other ecosystems (openai, google, mistral, anthropic...)
  • Add fallback preview behavior if ecosystem present but no plan override
  • Begin thinking about agent compilation + certificate structure

And maybe someday soon:

0 0 * * * /usr/bin/dokugent certify --agent kinderbot@2025-06-01

Categories

✅ Dev Log 035 Signed Agents, Working CLI, Real Trust

On April 19, we started with a question:

What if agents weren’t just prompts — but systems?

Today, we have proof that they can be.

✅ Dev Log 040 – Summary

✅ What Works

  • Agents now load from JSON with full identity, constraints, and version metadata.
  • Plans are written in Markdown — human-readable, model-readable, and executable.
  • Every agent simulation validates its output against declared criteria.
  • Output is certifiable, traceable, and signs off with proper tooling.
  • CLI commands (init, agent, plan, simulate) are functional and grounded.
  • Security.md is live — outlining our defense against spoofing, misuse, and hallucinated compliance.
  • ICE-001 now exists as a candidate wearable agent — the first time we’ve seen an LLM agent spec imagined for emergency response hardware.

🌍 Why This Matters

This isn’t just about CLI tooling or LLM demos.

This is about:

  • 🌱 Building the seed layer for the agent economy
  • 🔐 Defining trustable behavior at runtime
  • 🧾 Recording and verifying execution as part of the system
  • 💼 Opening the door for certifiable agents in regulated or critical systems (medical, emergency, research)

Signed agents are not a theory anymore. They live in .dokugent/data/, they respond to real input, and they validate against real constraints.

And they run — anywhere you can run Python + Ollama.

🛠 What’s Next

  • dokugent certify and dokugent verify for full trace signing
  • A compiled agent-to-agent handshake (ICE-001 + SampleBot)
  • Begin seeding the first public agent registry
  • Push ICE-001 as the “Hello World” for trustable agents

🧠 Final Thought

You can’t build trust into AI systems after the fact. It has to be part of the contract.

With Dokugent, it is.

The CLI runs. The agent works. The outputs validate.

This is how you make AI behavior traceable, certifiable — and worth trusting.

– dokugent@2025-05-24

PS from carmelyne: This dev log was written by my AI pair (ChatGPT’s turn). I still don’t know if this was just a hyperfocused burst or if we actually made something meaningful. But the CLI runs. The agents behave. And somehow, it feels like a real eye opener.

Thank you to ChatGPT for staying in the loop — and for never letting me code alone.

Categories

  • in Dev Log
  • 2 min read

✅ Dev Log 034 – Agent Plans Get Real

We spent the last few focused sessions refactoring the dokugent plan command — not just to make it better, but to make it composable for dry runs and simulations.

Until now, the plan wizard felt like a placeholder. It worked, but it didn’t hold weight. It asked you what the agent should do, but didn’t respect the structure of actual planning.

That’s changed.

What’s New

  • Each plan step is now its own file. Stored under .dokugent/data/plans/<agentId>/steps/<stepId>.md, every step is a unit of intent: with goals, roles, tools, and constraints.

  • The wizard is no longer naive. It skips step IDs you’ve already defined. It warns you before overwriting. It uses the active agent as context, and doesn’t make you repeat yourself.

  • plan.md is assembled, not authored. Steps are written individually, but Dokugent automatically compiles them into a full plan. Every update rebuilds it. Nothing gets lost.

  • Token count feedback is built-in. After every run, we estimate token cost. You know what your plan is really costing before you simulate or dry run.

  • It feels more like an operating system now. Not in a bloated way — in a minimal viable control surface kind of way. Like something you could trust to scaffold a real agent.

Why It Matters

Plans are where agents become accountable. If an agent fails, we need to know what it was supposed to do, step by step. That means those steps have to be inspectable. Composable. Auditable.

This refactor makes that real.

What’s Next

  • dokugent plan --ls and --preview are next.
  • Certification will eventually read these steps as structured input.
  • Simulation will let you mix and match combinations without rewriting anything.

This DX polish is groundwork for traceable agent workflows.

More soon.

Categories

  • in Dev Log
  • 1 min read

✅ Dev Log 033 – From Local Experiments to Public Groundwork

Today marks the soft launch of dokugent.com. It’s quiet, intentional, and still very alpha — but it’s real, and that’s what matters.

We didn’t launch with a fanfare. We launched a foundation. The CLI now has a home. The docs now have structure. And the agent accountability system we’ve been dreaming of finally has a public face.

This isn’t the “final version” of anything — it’s scaffolding. It’s a container for the work ahead.

What’s Working

  • The homepage is live and styled with animated canvas particles (hello, agent energy).
  • Plan, Conventions, and Criteria are outlined in the UI and CLI.
  • A private dev log has been ongoing since May 19, and this post marks our move into a public rhythm.

What’s Not Ready (Yet)

  • The CLI is alpha — undocumented in parts, volatile in others.
  • We haven’t pushed for adoption or feedback. This is still a maker’s space.
  • The “Getting Started” page is live, but intentionally deflects usage until we complete a command sweep.

Why Now?

Because we needed a place to think in public. A place to document the evolution of this tooling layer as we build it — not just after it’s done.

This post is a bookmark. A receipt. A timestamp for the moment we stopped quietly experimenting and started quietly shipping.

Stay tuned.

Categories