2025¶

Day 51 of Dokugent Owner Identity & Metadata Refactor

1. dokugent owner Wizard
2. Migrated prompts from Inquirer → Enquirer
3. Separated roles: owner, admin, tech contacts
4. Added trustLevel with properly padded choice formatting
5. Created ownerId via sha256(ownerName:email)

6. Included new metadata:

   • cliVersion
   • schemaVersion
   • createdVia
   • createdAt & createdAtDisplay

7. Error Handling

8. Added graceful exit catch for owner-wizard.ts
9. Fixed runtime crash for dokugent preview and dokugent byo due to missing fields or early exits

Categories

• Dev Log

Truth Series Part 3: From Black-Box Autonomy to Practical AI Agent Accountability - A Developer’s Layer for Traceable AI Agent Behavior

Why Dokugent Isn’t Just Another Agent Framework

From Black-Box Autonomy to Practical AI Agent Accountability

If the first two posts introduced the problem space—autonomous agents in high-stakes systems—and the second mapped Dokugent’s alignment with accounting-grade controls, this third piece addresses a natural follow-up: what makes Dokugent different from other agent frameworks?

We begin by acknowledging the obvious: agent frameworks are everywhere. Open-source ecosystems are flush with orchestration tools, sandbox runners, and LLM-based workflow graphs. But much of the tooling landscape still privileges capability over accountability. Dokugent flips this.

Rather than asking “What can agents do?”, Dokugent starts with: “What has been authorized, by whom, and under what constraints?”

This reorientation is not philosophical flourish. It manifests structurally—within init, plan, review, and certify commands that enforce delegation as a precondition to action. Every traceable action requires a documented chain. Every document, a cryptographic anchor.

Not Just Logs—Executable Documentation

Many AI systems today attempt to patch the accountability problem with post-hoc logging. These logs are often hidden inside centralized dashboards or incomplete telemetry blobs. Dokugent doesn’t log after the fact—it scaffolds action beforehand.

Plans must be reviewed before execution. Simulations must pass validation before agents touch real data. Certificates are signed with real-world accountability in mind—not just metadata, but the provenance of who approved what.

That’s why we call Dokugent documentation-first tooling. Its outputs are not write-only records. They are living, auditable specifications that shape and constrain what agents may do. Unlike DevOps tooling that tracks what code was deployed, Dokugent tracks why it was authorized in the first place. That distinction matters when AI decisions require legal and ethical defensibility—not just operational uptime.

A Developer’s Layer, Not a SaaS Dashboard

One reason Dokugent may seem invisible compared to flashier platforms is because it was never built for spectators. It’s a developer-first CLI with markdown-native outputs—tools that support builders who want to reason about agentic behavior at the code level.

And this is precisely what sets it apart. Many orchestration platforms frame themselves as no-code sandboxes or team dashboards. Dokugent respects that many of us still work from the terminal—and want infrastructure we can see and edit, not portals we click and trust.

We believe that control should start local, and that traceability doesn’t require a subscription.

Here’s what that looks like in practice:

1. Developer writes a plan in Markdown—defining intent, constraints, and role responsibilities.

2. A reviewer certifies the plan with a cryptographic signature using dokugent certify.

3. The agent simulates execution with dokugent simulate, ensuring the plan behaves as expected before deployment.

4. The approved, signed plan becomes an executable artifact—ready for safe execution under traceable conditions.

Why This Approach Works

What makes Dokugent novel is not that it introduces an alien paradigm. It’s that it refactors basic developer workflows into chain-of-responsibility structures that hold up under scrutiny.

You don’t need to believe in autonomous agents to see its value. You just need to know what happens when things go wrong—and how hard it is to explain AI decisions without a map of who said yes, when, and under what version.

Dokugent gives you that map.

And for developers who are tired of debugging invisible processes, that’s not just helpful. That’s foundational.

🔧 What Happens When You Don’t Have This

Dokugent isn’t designed to solve for world models, persistent memory, or hierarchical planning—the kinds of cognitive architectures Yann LeCun argues are necessary for real AI reasoning¹. And that’s exactly why his critique matters.

LeCun warns that modern LLMs are “hacks”—brilliant but shallow pattern matchers without real understanding. He rejects scale-centric approaches in favor of structured, physically grounded models.

That warning strengthens Dokugent’s case.

When AI doesn’t reason like humans, it has to be governed like a system—not trusted like a person.

Dokugent assumes the agent is incomplete. So it enforces constraints—before execution. Every agent action must be pre-authorized, simulated, and traceable. Not because agents are unreliable, but because we know they are.

LeCun pushes for better AI cognition. Dokugent builds the rails we need until we get there.

🔧 When Things Break

The true test of agent infrastructure isn’t when it works—it’s when it fails. What happens when an agent runs a faulty script? When outputs are wrong but logs are missing? When a decision was made but no one knows who approved it?

These are not hypothetical edge cases. They’re common failure patterns in complex systems. And in environments like finance, healthcare, or education, these gaps become liabilities.

And if you're a developer, you already know what this looks like: the blame game during postmortems, the 3am incident report with no trace, the feature rollback because no one can verify how the decision was made—or who approved it. Fixing failures after deployment is slow, messy, and often reputationally expensive. Dokugent isn’t just insurance—it’s a toolkit to pre-empt those root causes with auditable foresight. You don't debug trust after the fact. You encode it before the break.

Dokugent was designed for these moments. The signatures, review chains, and simulations don’t exist to slow you down—they exist to catch these failures before they cascade.

🧾 Designing for Auditors, Not Just Engineers

Dokugent is engineered for developers, yes. But its outputs are also meant to stand up in audits, governance reviews, and third-party verification.

This is why its files are markdown-native, cryptographically anchored, and structured for human comprehension. They aren’t config files—they’re explainable artifacts. You can trace a decision from agent action all the way back to reviewer intent.

That’s what regulatory-grade design looks like: systems that aren’t just usable, but legible.

Where This Fits in Real Systems

Agent accountability isn’t theoretical. Here’s how it plays out:

• Healthcare: An AI summarizes a patient history. Dokugent ensures that summary action was pre-approved by a medical reviewer and bound by task scope.
• Finance: A trading bot receives constraints on daily volume limits. Dokugent logs who signed off and under what criteria before it runs.
• Education: A tutoring agent generates custom quizzes. Dokugent certifies the plan, so content creators can be held accountable for source alignment.

In each case, Dokugent provides a paper trail before the AI executes.

Addressing Governance Concerns

🔍 A Note on Scope

Dokugent doesn’t solve everything.

It doesn’t run agents. It doesn’t manage vector stores or RAG pipelines. It doesn’t even try to be your LLM backend.

It assumes those systems exist—and works alongside them to enforce accountability. It’s the part most frameworks forget: the infrastructure that encodes trust.

Think of it as the part of the AI stack that signs before it acts, simulates before it risks, and documents before it deploys. And when failures happen? It’s also the black box recorder—capturing what was reviewed, approved, and executed, so you can reconstruct what actually occurred.

But it's important to be precise: Dokugent tracks authorization, not execution. Once an agent leaves the CLI and enters runtime, Dokugent's role ends. What happens next—how the agent behaves, how it's logged, and whether those actions align with its plan—depends on the infrastructure it runs in. Dokugent signs the intent. It's up to the rest of your system to honor it.

Dokugent CLI is currently in active development, with a beta release planned soon.

If you’ve been following the Trustworthy AI Series, Part 3 marks the shift from philosophy to implementation. And once the CLI hits public beta, you won’t just be able to read about these ideas—you’ll be able to run them.

Follow updates at dokugent.com or subscribe to get notified when the beta drops.

Categories

• Agent Infrastructure
• Build in Public
• Trustworthy AI Series

Day 50 of Dokugent CLI development landed with a mix of code, reflection, and newborn life—literally

What We Accomplished

1. Drafted Part 4 of the Trustworthy AI Series
2. "What Dokugent Can’t Do (Yet)—and Why That’s the Point" is now locked in as a credibility-focused, bridge piece to an upcoming Adoption Series.

3. We leaned into limitations: what Dokugent doesn’t automate, can’t promise, and why its constraints are part of its trust-first design.

4. Real-Time Patch Testing

5. Worked on CLI alignment and visual UX polish for simulate and dryrun.
6. Patched slowPrint sequencing, spacing logic, and default formatting inconsistencies.

7. Added better developer-readable console output for padded sections (INPUT, OUTPUT, STEP SUMMARY).

8. Deployments + Site Sync

9. Re-synced full MkDocs deploy with JSON metadata refresh.
10. simulate, dryrun, and compile pages were updated with final fixes from the CLI.

In Between Commits…

A surprise litter! One of our shih tzus gave birth overnight—three pups made it, and the last one (who snuck in unnoticed) will forever be known as GPT.

Looking Ahead

• Finalize simulate command logic with security awareness and better mock alignment.
• Triage remaining UX polish for the dryrun step narrator.
• Prep for npm beta release and formal CLI freeze.

Onward to a sharper, humbler, more transparent agentic world.

Categories

• Dev Log

Dev Log 049 – Compile and Dryrun Agent Context Linking

✅ Dev Log 049 – Compile and Dryrun Agent Context Linking

This update addresses a long-standing inconsistency in how Dokugent resolves the current agent context between the compile and dryrun commands.

🔧 What Was Fixed

• dryrun previously defaulted to a hardcoded or oldest available agent (e.g., happybot@...) instead of the currently active agent.
• A new resolution path was implemented: dryrun now reads the agentName and birth fields directly from .dokugent/data/agents/current/identity.json and dynamically derives the agent ID used for lookup.
• This matches the folder naming convention inside .dokugent/ops/compiled/.

🧠 Why This Matters

Agent continuity is critical for verifiable workflows. By tightly coupling the identity source (current) with the compiled certificate location, we:

• Reduce accidental mismatches
• Avoid stale context errors
• Improve CLI reliability across chained commands

🛠 Example

```bash $ dokugent compile ✔ Compiled agent: merrybot@2025-06-08_04-16-35-246 ✔ Cert file: merrybot@2025-06-08_04-16-35-246.compiled.v19.cert.json

$ dokugent dryrun 🧠 Running dryrun for agent: merrybot@2025-06-08_04-16-35-246 📄 Certificate file used: compiled.v19.cert.json

Categories

• Dev Log

Truth Series Part 2: From Accounting to Agentic AI Governance - How Dokugent transforms AI agents into verifiable systems

Subhead: Why traceable delegation is the real foundation of trust in the age of AI agents—and how Dokugent generalizes the accounting mindset into system governance

1. Recalling Part 1: Accounting Is Not Math

In Part 1, we argued that accounting is not math. It's trust, formalized. That distinction reframes accounting from numerical computation to structural verification. One of our readers, initially grouped our insight with a broader trend, suggesting that the idea wasn't entirely novel.

But after a structured rebuttal, even they acknowledged:

“This level of rigor in pre-authorization… is not a widely established industry standard.”

That evolution matters. It confirms what we've been saying from the start:

The novelty isn’t in having AI agents. It’s in governing them.

2. Dokugent’s Core Insight: Traceable Delegation

Let’s address a likely assumption up front:

You might think Dokugent is just another agent framework—a CLI-based tool for building automated workflows.

But it isn’t.

Dokugent doesn’t focus on what agents can do. It focuses on what they should be allowed to do — and under whose authority.

This changes the system-level question from:

“Can this agent execute a task?” to “Who authorized this task, and under what conditions?”

Most modern AI tooling prioritizes capability and logs what happened after the fact. Dokugent reverses that. It prioritizes pre-authorization, traceability, and verifiable delegation—before the agent ever acts.

Strategic Parallels from the Field

Even without direct advisory boards, Dokugent’s roadmap aligns with high-level concerns voiced by AI leaders. We’ve systematically mapped public statements by figures like Satya Nadella, Sundar Pichai, Yann LeCun<sup>4</sup>, and others to actionable gaps in agent infrastructure.

Nadella’s call for agent auditability<sup>1</sup>, Pichai’s emphasis on compliance<sup>2</sup>, and Altman’s focus on SDK trust layers<sup>3</sup> directly echo the foundations of Dokugent’s design. Our certify, simulate, and trace commands didn’t arise in isolation—they’re direct responses to industry pain points articulated at the highest levels.

By mapping recurring themes from public leadership statements to systemic infrastructure gaps, Dokugent offers early responses to billion-dollar concerns—without waiting for permission or endorsement.

3. From Accounting to Universal Accountability

In accounting, every journal entry links back to a person, a time, and a reason. Accountability is built into the medium. The numbers tell a story—not just of what changed, but who changed it, why it happened, and whether it holds up to scrutiny.

That mindset scales.

This is more than a metaphor. Here's a practical translation of accounting mechanisms into agentic execution models.

This isn’t metaphor. It’s design inheritance. Just like accountants need structured records to defend financial actions, AI systems need structured context to defend autonomous decisions.

By bringing the logic of accounting into agentic AI, Dokugent provides:

• Agency with safeguards Plans aren’t just task lists—they’re declarations of accountability. Every agent begins with an explicit, reviewable plan that defines its scope and limits.

• Trust that travels with the task Once reviewed and certified, a plan becomes more than a file—it’s a portable, cryptographically signed artifact. Wherever it moves, trust moves with it.

• Built for audit, not obstruction Dokugent’s structure invites transparency. You can inspect any plan like a ledger, not to slow it down, but to ensure its legitimacy holds across time and teams.

This is how you build AI systems that can operate in real-world, high-stakes environments. Where every action must answer the question: who authorized this, and under what constraints?

Accounting showed us how to encode trust across time. Dokugent just extends that architecture to intelligent systems.

That's why Dokugent isn’t metaphor. It’s design inheritance. Dokugent generalizes the structural mindset of accounting to any system where agents act.

4. Common Misreads and Clarifications

Let’s preempt some common assumptions:

"Isn’t this just workflow automation?"

That’s a fair question. But no—Dokugent doesn’t just chain tasks. It enforces a plan-review-certify chain that must be cryptographically acknowledged before execution. This creates an immutable record of intent and consent.

"Is this like DevOps pipelines?"

In tooling, yes. In philosophy, no. DevOps focuses on reliability. Dokugent focuses on responsibility.

"Do other tools already do this?"

Some do parts. Most are either internal mini-agent tools or opaque dashboards. Dokugent is:

• CLI-first
• Markdown-native
• Cryptographically signed
• Designed for agent-native developer governance

5. Domains That Need This Now

Dokugent may have been inspired by accounting, but the principles behind it—structured intent, traceable delegation, and verifiable consent—apply far beyond finance.

In fact, they’re especially relevant in domains where the cost of AI mistakes is high, and the appetite for change is low. These are sectors with legacy systems, regulatory pressure, and deeply embedded cultural habits. Ironically, those are the exact conditions where agentic governance isn’t just useful—it’s necessary.

• Education — Who approved the AI lesson plan? When students are exposed to AI-generated teaching materials, we need systems that can prove what was taught, why it was chosen, and who authorized the content. In schools, trust isn’t optional—it’s foundational.

• Healthcare — Who authorized that treatment suggestion? Clinical decisions made by or with the help of AI need pre-cleared protocols and auditable trails. It’s not enough to say “the model suggested it.” Lives depend on verifiable review and sign-off.

• Governance — Who reviewed that policy draft summary? When AI summarizes laws or drafts policy memos, transparency about inputs, framing, and delegation becomes a civic requirement. Dokugent offers a model of agent transparency that aligns with democratic values.

• Software Development — Who signed off on the codegen plan? AI can now write and merge code. But when systems go down, who’s responsible? Dokugent embeds review and accountability into each step of the agent’s lifecycle, closing the gap between generation and governance.

• Finance — Who forecasted the risk profile and when? Markets run on trust. AI that makes predictions or allocates resources must carry an audit trail—one that doesn’t vanish with a server restart. Dokugent preserves context, authorship, and approval history for every financial move.

These aren’t just compliance checkboxes. These are institutions built on explicit trust. And as they adopt agentic systems, the absence of visible delegation mechanisms becomes a liability. Dokugent turns that liability into infrastructure.

6. Why Capability Isn’t Enough

Agentic AI challenges us to rethink power—not in terms of capability, but in terms of accountability. It’s not enough to design agents that can act. We must also design the systems that govern how and under whose authority they act.

Too often, AI tooling focuses on what models can do. More accuracy, faster inference, broader coverage. But Dokugent asks a different question:

Who said the agent should do this—and under what terms?

You might assume capability alone signals progress. But in regulated environments, capability often needs to be paired with explicit control mechanisms. It’s the difference between a helpful assistant and an untraceable actor.

Governance reframes speed as responsibility. It provides the boundaries and context that make rapid execution not just possible—but reliable, traceable, and aligned with intent.

Dokugent enforces this by design:

• Pre-authorized plans, not retroactive logs Plans must be reviewed and certified before execution. There’s no room for "oops" in high-stakes workflows.

• Signed approvals, not silent defaults Every reviewer and certifier is cryptographically stamped into the agent’s file. Trust is explicit, not implied.

• Traceable actions, not black-box guesses Post-action blame isn’t enough. Dokugent gives receipts before the agent moves.

For organizations in regulated industries, these features often become operational requirements—especially where mistakes can lead to compliance failures, financial loss, or real-world harm. Traceable delegation isn’t a conceptual ideal. It’s an operational necessity in systems where autonomy must remain accountable.

7. Why Dokugent Isn’t Just a CLI

At first glance, Dokugent looks like a command-line tool. And it is.

But behind the CLI is a protocol mindset. A way of working where agents don’t just perform—they account for themselves. It may look like a utility, but it behaves like infrastructure.

Dokugent introduces:

• Markdown-native plans Human-readable, version-controllable, and structured for collaboration. A compliance officer or product manager can draft a plan. A developer can review it. An agent can simulate it. Everyone sees the same file—clear, trackable, and ready for certifiable execution.

• doku:// URIs These unique identifiers persist across versions and link every action back to its authorized plan. This creates a namespace for agent integrity.

• Chain-of-custody records Every plan embeds authorship, review, and certification metadata. Nothing is left implicit.

Dokugent functions as both a CLI tool and a governance protocol—shaping how agent systems can be built with trust and traceability embedded from the start. Instead of designing around capability, we design around accountability.

Even if you never use Dokugent, you may still want your agents to behave like they did.

Because when agents are certified, they aren’t just processes—they become entities. Identity markers embedded in Dokugent’s schema allow agents to establish who they are, who they represent, and what authority they carry. This makes possible cryptographic handshakes, traceable interactions, and secure agent-to-agent communication—no mystery, no guesswork.

That’s the mark of a protocol: not just behavior, but verifiable identity and interoperable trust.

8. Why We're Writing This Series

Prompt hacks and sandbox demos made early AI exciting—but not safe. In this new era of agentic AI, we need more than capability. We need infrastructure that knows what it’s doing, why it’s doing it, and who said it could.

That’s what Dokugent is trying to build: A system that makes delegation visible, auditable, and real. Not by inventing new forms of trust—but by reviving old ones. Accounting didn’t just track value—it tracked consent, responsibility, and consequence. Dokugent extends that lineage into code.

If you’re building systems meant to scale, make sure your accountability scales with them.

That’s why this series exists. To remind us that trust isn’t a feeling—it’s a system. And we can build it.

In Part 3, we explore how these principles become practical—how Dokugent’s CLI enables cryptographically signed delegation, human-in-the-loop review, and traceable agent behavior in real systems.

References

Categories

• Agent Infrastructure
• Build in Public
• Trustworthy AI Series

Dev Log 048 – First in Search

Dev Log 048 – First in Search

Yesterday wasn’t a big development day, but we noticed something important.

Dokugent now appears as the top Google result for its own name. It previously competed with spelling variants like “document” or “documento,” but that ambiguity seems to have cleared.

🧭 Why This Matters

• The project name is now easier to find without confusion.
• Search visibility means others exploring agentic tools might land here first.
• Our blog posts and CLI documentation are being indexed effectively.

🧠 Notes

We’ve never done keyword-driven content. We just wrote what the tool was doing, why it mattered, and what needed work. Apparently, that was enough for Google to make the association stick.

🛠️ What’s Next

• Publish the CLI to npm
• Finish the MCP-compatible metadata spec
• Update docs and add lightweight CLI tutorials

Small win. Back to work.

dokugent cert --trace

Still building. Still documenting.

Categories

• Dev Log

Dev Log 047 – Hanging Indents and Padded Text

🧵 Dev Log 047 – Hanging Indent Victory

CLI output now wraps beautifully—with full hanging indent support.

🔧 Problem

Multiline text (e.g., description, dokuUri, intent) was wrapping in an ugly way:

• New lines didn’t align under the first line's value.
• ANSI styles broke layout.
• chalk[color] inconsistencies silently failed.

✅ Fixes

• Created wrapWithHangingIndent() using wrap-ansi + strip-ansi.
• Added paddedLongText() to wrap log lines cleanly while respecting label alignment.
• Hardened log logic: fallback if chalk[color] is invalid.

🎯 Before vs After

"description": "This is a long string...
                and this wraps terribly."

becomes:

"description": "This is a long string meant to demonstrate a hanging indent
                inside a terminal. Each new line aligns under the first."

🧠 Notes

• Don't trust .length on styled strings.
• chalk[color] must be validated at runtime.
• Terminal UX deserves design care too.

🔜 Next Up

• Integrate paddedLongText() into trace, review, and inspect.
• Optionally allow users to override indent width per theme.

⏱️ Wrapped at 5:00 PM. Took 4 hours, 3 crashes, 2 errors, 1 win.

Categories

• Dev Log

Dev Log 046 – Building a CLI Design System

Following up from yesterday’s post, this is day two of refining Dokugent’s terminal UX. After laying the foundation with glyphs and layout components in agent --ls, we’re now building a full CLI-native design system to support structured, styled, and human-readable output across all commands

🗓️ Dev Log 046 – CLI design system

We’re introducing a native CLI design system for Dokugent to ensure that logs, prompts, and step outputs stay legible, expressive, and consistent—no matter how complex the agent plan gets.

✅ Highlights

• paddedLog() now supports label prefixes, tone levels, and consistent padding rules
• paddedSub() enables secondary and nested information with alignment
• Boxed layouts with rounded, hex, and square borders now previewable via dokugent ui-demo
• Added step logger preview with wrapped, indented logs for step-by-step execution
• ANSI-safe styles for bold, underline, inverse, dim, and alert messages
• Glyph symbol table for use in future UI previews and formatting helpers

This forms the base for a full CLI-native design layer, helping agent workflows remain traceable and human-friendly across different output styles.

Before vs After

Here's a visual comparison of how far we've come:

Before the Design System

After the Design System

We replaced raw console.log dumps with styled, structured output powered by our internal design system.

From this… to this.

I used to think CLI UX just meant good logs. Then I realized: even terminals deserve a design system.

Dokugent CLI now ships with: • Structured layouts • Glyph-based symbology • ANSI-safe visual hierarchies • Self-documenting CLI references

Design isn’t just for web. We build for humans—even in black boxes.

Categories

• Dev Log

Part 1: Agentic AI and Accounting

Last updated: June 6, 2025

Truth Series Part 1: Agentic AI & Accounting - How Dokugent Brings Traceability, Sign-Offs, and Certs to the Future of CPA Work

Agentic AI is no longer a fringe idea — it's becoming central to how professionals work across regulated industries. A recent article by the Journal of Accountancy (June 2025)<sup>1</sup> spotlighted how Certified Public Accountants (CPAs) are expected to collaborate with AI agents in the near future. These agents won’t just automate tasks. They’ll participate in workflows, reason through decisions, and assist in audits, tax classification, and financial reviews.

But this raises urgent questions:

• How do you know what your AI agent actually did?
• Who approved the plan it executed?
• Can you prove that it followed professional standards and constraints?

Dokugent CLI: An Audit-Grade Trust Layer for AI Workflows

This is where Dokugent CLI comes in.

Dokugent is a documentation-first CLI framework for structuring, certifying, and tracing agentic AI behavior. It’s designed for accountable AI workflows — where plans are authored, reviewed, signed, simulated, and validated before an agent runs. Think of it as Git, but for agent plans with embedded receipts and role-based trust.

Let’s walk through how Dokugent supports CPAs using AI agents in practice — both from a practitioner’s perspective and from a developer’s point of view.

For the CPA, Dokugent provides confidence that AI behavior is constrained, reviewed, and provable. For the developer implementing these agents, Dokugent offers structured commands that scaffold, validate, and certify each step of the agent's lifecycle.

From plan to trace, the following steps ensure both human oversight and programmatic enforcement.

Planning Agent Behavior: Using dokugent plan

Before any AI agent can be run in a CPA workflow, its intent must be authored as a plan.

dokugent plan

Sample output:

{
  "plan": [
    {
      "id": "classify_transactions",
      "goal": "Classify 300+ bank transactions by tax category",
      "tools": ["openai-chat"],
      "constraints": [
        "Must not hallucinate categories",
        "Must cite source rules like BIR RMO 23-2018 or IRS Pub 463"
      ]
    },
    {
      "id": "generate_tax_report",
      "goal": "Format classified data into a summary report",
      "tools": ["markdown-formatter"],
      "constraints": [
        "Report must use standard tax reporting format",
        "Output must be human-readable and signed"
      ]
    }
  ]
}

📎 This ensures transparency before execution. No surprises.

See more about dokugent plan

Previewing and Reviewing: Ensuring Human Oversight

Before any agent is cleared to run, its plan is previewed and validated—typically by a trusted peer, senior team member, or designated reviewer.

This isn’t a blocker—it’s a safeguard. It ensures the agent’s intent matches organizational standards and professional expectations.

dokugent preview

This outputs:

"previewer": {
  "previewerName": "chatgpt",
  "email": "chatgpt@openai.com",
  "publicKey": "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEA0b1d91NtftCNhIzJ9yhH+U2cCMOrU9w4gWTzbf5dLzI=\n-----END PUBLIC KEY-----\n",
  "fingerprint": "e0b4a91e60d83ef164fa4d9ad69594969fe394359879ab3b88a4fbcd206cd1f6",
  "previewKeyVersion": "latest"
}

✅ Peer review is now part of the AI workflow.

See more about dokugent preview

Certifying the Plan: Using dokugent certify

Once a plan is reviewed, it must be cryptographically signed by an authorized certifier—often a compliance officer, partner, or delegated reviewer in the firm.

dokugent certify

Output:

"certifier": {
  "certifierName": "carmelyne_m_thompson",
  "email": "carmelyne@dokugent.com",
  "publicKey": "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEATtdnW+qkoYb2SAUaBM+TgjmzBKJjRRlSdKz8NTLnrMg=\n-----END PUBLIC KEY-----\n",
  "fingerprint": "099604b663f7e6f240534a26b8322d27b4f2db5162193b78aeb3df31550076eb"
}

✅ The agent certificate json file embeds: the owner, previewer, certifier, and compiler. This is real-world traceability — not AI theater.

See more about dokugent certify

Dryrun Before Deployment: Using dokugent dryrun

A critical step in audit-safe AI workflows is validating before execution:

dokugent dryrun

Dryrun checks:

• Constraints are respected
• All signer keys are valid
• Source files are referenced
• Estimated tokens within budget
• Plan is compatible with previewed LLM scope

See more about dokugent dryrun

Simulate Agent Output: Using dokugent simulate

Once dryrun passes, the firm may simulate the agent’s behavior without affecting data:

dokugent simulate --llm=claude

Simulated output:

{
  "input": "2023_BDO_Transactions.csv",
  "outputPreview": {
    "Travel Expenses": 14,
    "Meals & Entertainment": 32,
    "Office Supplies": 9
  },
  "explanation": "Categories derived using BIR RMO 23-2018 and IRS Pub 463"
}

🔧 If you want the simulated output to be structured as machine-readable JSON instead of natural language or markdown, simply add this as a constraint inside your agent plan:

{
  "id": "generate_audit_report",
  "goal": "Produce a machine-readable audit output",
  "tools": ["openai-chat"],
  "constraints": [
    "Output must be in valid JSON format",
    "Include top-level keys: input, output, explanation"
  ]
}

This lets Dokugent simulate results that can be parsed, stored, or validated — not just inspected.

This is essential for regulatory-facing professions. It allows internal validation of what the AI is about to do.

And from a developer’s perspective, this is the stack: each command scaffolds one layer of agent control—plan, preview, certify, dryrun, simulate, trace. It doesn’t mean the accountant has to do it. But it means the team has a shared language of delegation and validation. Today, this tooling may sit with developers. In time, it will make sense to everyone working with agentic AI.

See more about simulate

Tracing Decisions Over Time: Using dokugent trace

After deployment, every agent plan can be traced by its persistent identifier:

dokugent trace doku://taxbot@2025-06-02_09-41-05

Trace reveals:

• The original plan
• Who authored and signed off
• Token cost
• Decision rationale
• LLM used and constraints

🔎 This makes agent behavior auditable across time and teams.

See more about dokugent trace

Why This Matters for CPAs

As accounting firms begin to adopt AI agents for work like:

• Transaction classification
• Tax preparation
• Forecasting
• Expense verification

…it’s no longer enough to say "AI handled that."

CPAs aren’t expected to become developers—but they are expected to work with AI systems in ways that hold up to audit, review, and client accountability.

Dokugent doesn’t push that burden onto the practitioner. It creates a shared structure where developers build with audit in mind, and professionals operate within a system that documents who approved what, under what constraints, and when.

You must be able to:

• Prove who authorized the behavior
• Show the constraints it followed
• Explain the LLM’s source logic
• Produce receipts on demand

Dokugent doesn’t just make this possible — it makes it structured.

External Links and Sources

• Journal of Accountancy: Agentic AI and CPAs
• OpenAI
• Anthropic (Claude)
• American Institute of CPAs (AICPA)
• Bureau of Internal Revenue, Philippines

Explore Other Use Cases

• Trace Agent Intent Before It Acts
• Prompt Variant Testing
• Compliance and Risk Review

🚧 Project Status: Active Development Phase

Dokugent is currently in active development. While many of its core features — including agent planning, certification, traceability, and simulation — are already functional, we are still refining workflows, validating real-world use cases, and improving developer UX.

This blog post reflects an internal test case built using the current CLI features. Outputs are simulated to match JSON schemas but may differ depending on your agent setup or tool configuration. And right off the bat, we have our system ready for you to bring your own JSON via our dokugent byo.

We welcome feedback and contributions — but this isn’t a v1 stable release just yet. Think of this as a working notebook from the field.

Final Thoughts

Agentic AI is here, and regulated industries are waking up to the need for audit trails, identity, and traceable behavior. Dokugent was built to meet this exact moment.

CPAs won’t trust AI until it gives receipts. Now it can.

Try Dokugent CLI today and bring trust back into AI workflows.

This article is part of our Trustworthy AI Series. Subscribe to stay updated on real-world AI infrastructure you can actually deploy.

Categories

• Agent Infrastructure
• Build in Public
• Trustworthy AI Series

🗓️ Dev Log 045 – CLI design system - The Terminal is My Canvas

The Terminal is My Canvas

Today was all about terminal UX. What started as layout cleanup for agent --ls turned into a full-blown CLI design system:

• Finalized agent --ls layout: emoji glyphs, color-coded labels, aligned arrows
• Introduced checkmark (✅) glyph for current and magenta for latest
• Created CLI layout components: paddedLog, paddedSub, paddedDefault
• Started standardizing output formats in ls-utils.ts
• Discovered fragmentation: plan --ls was using a totally different path (plans.ts)
• Re-aligned logic for consistent CLI DX

Highlight:

We’re not dumping logs anymore — we’re rendering interfaces inside the terminal.

CLI has always been fast. Now it can be beautiful too.

Categories

• Dev Log