"Who Let the DOGs Out?": the diagram below illustrates how Agent DOGs collaborate. Agent DOGs are AI agents operating over a Data Object Graph, each with its own goals, objectives, and tasks executed over their respective graphs.

They all follow the same process: SNIFF ➔ FETCH ➔ MAP  ➔  HUNT  ➔  RETRIEVE  ➔  GUARD

We have an overall Agent DOG that maps to the overarching goal but decomposes into sub-Agent DOGs, each with its own goals and objectives. The entire process operates in a shared workspace where all Agent DOGs share the environment, access, and exchange data using shared memory but communicate over a shared messaging communication system.

Each Agent DOG is initiated and coordinated by the Lead Agent (borrowing terminology from sled dog teams). The lead agent owns, creates, and executes its graph overall, but each Point Agent is defined and activated by the lead agent, operating within its own execution space while interacting with the shared workspace.Each DOG comprises Data Products (data, AI models, and other analytics components), which can run in their own process spaces (e.g., microservices) or be executed inside the shared workspace area, with each result feeding into the lead DOG.

Think of it as a coordinated pack—there's a lead coordinating everything while specialized agents work on their own tasks, all sharing the same workspace but with their own execution areas. These agents can handle different types of data, AI models, and analytics, whether running as separate services or within the shared space. It's a systematic way to break down big problems into manageable pieces while keeping everything connected and coordinated.

We have demonstrated how multiple AI agents collaborate on complex data problems by using Data Object Graphs (DOGs). There's much more to come, so stay tuned.

Following the discussions on DOGs, several people have inquired about the architecture supporting Agent DOGs. Introducing PackRunner, which solves key problems through coordinated, parallel execution with shared context.

Components and Their Interplay:

1. Control Plane (Mission Control):

   • Configures agent workspaces based on the problem domain.
   • Manages execution policies and resource allocation.
   • Deploys agent templates for specific problem types.
   • Monitors system-wide performance, security, and control.

2. Agent Services Layer:

   • Shared Memory Engine maintains global state across agent tasks.
   • Messaging coordinates real-time agent interactions.
   • DOG Generator dynamically builds execution graphs based on task requirements.

3. The Den (Shared Environment):

   • Utilizes an actor model for simultaneous agent process execution.

   • Lead Agent DOG:

     • Decomposes complex problems into sub-tasks.
     • Orchestrates Point Agent deployment.
     • Manages and monitors resource allocation.

   • Point Agent DOGs:

     • Execute specialized sub-tasks.
     • Maintain local graphs for specific objectives.
     • Share insights through a common workspace.
     • Adapt based on shared learnings.

4. AI Services Integration:

   • MLOps Environment executes model-based decisions.
   • Model Repositories provide pre-trained capabilities.
   • Feature Stores enable rapid experimentation.
   • Training Pipelines adapt to new patterns.

5. Data Product Infrastructure:

   • Serves Data Products for use in each DOG.
   • Cloud-native dynamic execution across environments.
   • Scalable resource management.
   • Multi-platform data access.

Process Overview:

When tackling a complex goal-oriented process orchestration:

1. The Control Plane configures the workspace.
2. The Lead DOG analyzes and decomposes the task.
3. Point Agents deploy across sub-problems.
4. Shared Memory enables coordination.
5. AI Services provide analytical capabilities to accelerate definition and execution.
6. Data Infrastructure scales resources as needed.

Technical Optimizations:

• Inter-agent communication patterns.
• Resource allocation strategies.
• Graph execution efficiency.
• Learning transfer between agents.

This architecture effectively merges two systems—the Data Product infrastructure and the Agentic AI framework. While they address different problems and have distinct solution and architectural approaches, they coordinate seamlessly. A key tip: do not attempt to merge them into a single system.

This architecture builds upon our Data Product and AI work that has been successfully implemented across many organizations.

"Better Processes, Smarter Pack": We have been engaging in numerous conversations about our approach to business change. It's fascinating that we still rely heavily on workshops and theoretical designs when we wouldn't consider building a bridge or aircraft without first simulating it.

While working on various process transformation use cases, it has become apparent that we are effectively experimenting with digital process twins. What if we could test new processes in a safe environment before deploying them?

Using Data Object Graphs (DOGs), we can achieve this by quickly simulating process changes using interactive, executable canvases. The technology stack is intriguing and includes components like:

• A Data Fabric for all the data work.
• Multi-process architecture managing distributed process simulation through shared memory spaces.
• Data Products serving as executable nodes of the graph.

Instead of traditional whiteboarding, we've been prototyping processes directly on the canvas. We've encountered some failures, but these were quick and inexpensive to address—something often impossible in many cases.

The concept is straightforward:

1. Model your process
2. Run it in simulation
3. Validate the outcomes
4. Deploy with confidence

Think of it as "try before you buy" but for business transformation.

The technology to enable this is sophisticated—creating end-to-end business processes (using DOGs) with distributed processing and AI-native integration (LLMs and Small Language Models, both local and SaaS-hosted). However, the core idea is simple: to model and reconfigure the information layer of business processes at the speed of business.

"Decisions Need DOGs to Hunt for the Truth": Agentic AI and Data Object Graphs (DOGs) can revolutionize strategic decision-making.

Decision Intelligence transforms organizational decision-making from intuition-based choices into engineered processes by combining data science, behavioral insights, and systems thinking. It aims to create repeatable frameworks that capture decision patterns, reduce biases, and continuously learn from outcomes, ultimately enabling better choices through a structured approach that balances human judgment with computational capabilities.

However, traditional decision intelligence frameworks often struggle with:

1. Complex data relationships.
2. Real-time processing of multiple data streams.
3. Maintaining context across decision cycles.
4. Scaling human expertise.

Combining Agentic AI (autonomous AI agents) with DOGs addresses these challenges in decision intelligence.

How It Works:

• AI Agents act as specialized knowledge workers:

  • Data Scouts continuously monitor and collect relevant information.
  • Analysis Agents process and contextualize data.
  • Strategy Agents identify patterns and opportunities.
  • Decision Agents propose and evaluate options.

• DOGs serve as the "neural network" connecting these agents:

  • Create dynamic, interconnected representations of data relationships.
  • Maintain context and historical decision patterns.
  • Enable real-time updates and propagation of changes.
  • Facilitate multi-agent collaboration and knowledge sharing.

Impact:

• Agents can traverse the DOG to understand complex relationships.
• Multiple agents can simultaneously work on different aspects of the same problem.
• The system learns and evolves from each decision cycle.
• Human experts can easily interact with and guide the system.

Potential Benefits:

• 3-5x faster decision cycles.
• 60% reduction in decision-making errors.
• 40% improvement in outcome prediction accuracy.
• 80% better utilization of existing data assets.
• Significant reduction in risk, as these can be prototyped quickly (with the right solution), avoiding costly programs before validation.

Key Takeaways:

The future of decision intelligence isn't just about better algorithms or more data—it's about creating an ecosystem where AI agents can collaboratively work with humans, using DOGs as their shared understanding of the world. Being able to test these out in simulations quickly, cheaply, and with low risk allows firms to "try before they buy," but it requires a new way of thinking that also integrates well with their current operations.

"Release the Hounds": There has been significant interest in the technical details of DOGs, so we'd like to make them concrete by anchoring them in the real world of Business Intelligence (BI) and enterprise metrics.

The core concept is a metric tree that rolls up to a business insight, represented as a Data Object Graph (DOG)—a directed graph where metrics are nodes forming an executable dependency tree.

Technical Implementation:

• Nodes: Containerized metric compute units—Data Products—with runtimes, described as Data Product Containers. They can be dynamically run anywhere.
• Edges: Executable data flows, queryable and traversable using graph theory.
• State: Moves along the edges and is physically distributed across infrastructure boundaries.

Every metric in our graph is a self-contained Data Product runtime, deployed as a container, carrying its own compute requirements, governance rules, Service Level Agreements (SLAs), and data quality rules. They also include a query/data processing engine that forms a distributed, virtualized Data Fabric.

These nodes know what they need, where they can run, and whom they serve, which can span cloud and on-premises infrastructure. They have service contracts with methods for filters, versioning, etc. Metrics call each other through the graph, all rolling up to the root (the topmost metric in the graph).

There are two types of metrics:

• Atomic: Derived from raw data.
• Derived: Calculated from other metrics.

For the infrastructure, these aren't just static configurations—they're dynamic patterns that adapt as the system runs and execute where they need to, allowing for dynamic relocation (being cloud-agnostic). For example, in financial metrics, transaction processing stays close to core banking, risk calculations run in secure zones, and regulatory reporting executes where jurisdiction demands.

One can execute any part of this DOG by navigating to any node and running the graph from that point.

When metrics become graph nodes, they behave like a coordinated pack—each knowing its role but working together. Some process data near the sources, others aggregate downstream, all choreographed by the graph.

This is one use case, with metrics as the execution nodes, but the nodes could be LLMs, knowledge graphs, or any type of processing unit. This usage demonstrates the power of this approach.

The beauty lies in the ability to model and reconfigure the information layer of business processes at the speed of business (the metric tree mentioned was built and deployed in three hours).

We are observing two emerging AI/agentic patterns:

1. Pure Agentic Workflow (PAW): Delegating entire tasks to AI agents that work autonomously. Examples include email management bots or automated customer service agents that handle inquiries end-to-end with minimal human oversight.

2. Model-Accelerated Workflow (MAW): Humans and AI working in close collaboration. AI agents and models amplify human capabilities by generating or augmenting more prescriptive process flows.

Pure Agentic Workflows

In PAW approaches, agents use their interactions (e.g., LLM-driven conversations) to create and execute an implicit workflow dynamically. These approaches are highly effective for many use cases, offering significant efficiency through automation. However, the probabilistic nature of these agents can be problematic for highly regulated and prescriptive workflows.

For instance, Parcha, a fintech startup, attempted to build autonomous AI agents for critical flows such as Know Your Business (KYB), Know Your Customer (KYC), and fraud detection. These use cases required accuracy, reliability, seamless integrations, and a user-friendly product experience, which can be challenging for the dynamic nature of PAW approaches.

Model-Accelerated Workflow

For more predictable and prescriptive flows, MAW approaches, like our Data Object Graph (DOG), are advantageous. In our DOG methodology, we use models (AI agents, classical and generative AI, simulations, etc.) to accelerate the creation and execution of flows, which include LLMs, Small Language Models, and other algorithms as processing nodes.

Model-driven DOGs accelerate processes while providing transparency, predictability, and human input, but they may lack the dynamism that PAWs offer.

Which Workflow Approach?

Ultimately, it's about balance, and there are variations between the two approaches. It's not a matter of choosing one over the other—currently, both are necessary in the AI and algorithmic toolkit, and it's essential to know when to use each.

After sharing the above chapters, we've received numerous insightful questions about the fundamentals of Data Object Graphs (DOGs). To provide clarity, we'd like to draw an analogy with traditional database architecture, as the Agentic DOG process—modern AI-driven business process execution—mirrors this architecture conceptually.

Let's compare Classic Traditional Database architecture with our PackRunner Agentic Product architecture to highlight the parallels.

Architectural Parallels

Orchestration Across Business Domains

PackRunner orchestrates these processes across various business domains—such as Sales, Marketing, and Logistics—spanning multiple clouds and disparate infrastructures. This dynamic orchestration allows for seamless integration and execution of complex business workflows.

Dynamic State Traversal

An intriguing aspect is how the state, represented by evolving datasets, traverses the graph. This movement alters the traditional data modeling approach, offering more flexibility and adaptability. We'll delve deeper into this topic in future discussions.

Data outputs can be returned by the last data product executed, enabling actions such as sending emails, updating transactional systems, or providing insights to BI tools.

Transforming Business Logic into Executable Reality

While traditional databases typically operate on static data structures, PackRunner has the capability to create living, executable workflows. These workflows can dynamically access and orchestrate real business processes, effectively turning business logic into executable reality.

This is the essence of PackRunner's approach: leveraging Agentic Data Object Graphs to transform business intentions into actionable, dynamic processes that drive innovation and efficiency.

One of the most common concerns about AI agents involves the predictability and transparency of their decision-making processes. Traditional agent architectures often obscure their internal states within sequential memory buffers and token windows, making it challenging to understand their decision-making processes, particularly when driven by Large Language Models (LLMs).

DOG-equipped agents address this challenge through a dynamic, graph-structured memory architecture. This approach maps and records relationships between data and executable nodes (data products) in real-time, enabling transparent state tracking and context management across multiple interactions.

Consider how this works with a concrete business objective like "Reduce customer support response time by 50%." The system processes this through several structured phases:

Goal Analysis & Prompt Engineering

The system methodically:

• Decomposes high-level objectives into measurable components
• Creates specific, actionable prompts to guide AI decision-making
• Establishes clear success metrics and KPIs

DOG Runner Architecture

The system employs AI to construct its Data Object Graph with four primary node types:

• Data Nodes: Managing customer databases, ticket repositories, and agent skill matrices
• Execution Nodes: Handling ticket classification, agent matching, and response generation
• State Nodes: Tracking real-time system status, agent availability, and performance metrics
• Function Nodes: Implementing quality checks, load balancing, and learning update mechanisms

Real-World Implementation Example

A customer support system implementation demonstrates this architecture in action:

Input: "Create an AI-enhanced support system with sub-1-hour response times"

The system automatically generates a DOG with these data products arranged in three processing stages:

1. Intake Stage:

• Smart ticket reception and classification
• Multi-factor priority assessment
• Initial response generation

2. Processing Stage:

• AI-powered agent matching
• Response suggestion system
• Resource optimization

3. Execution & Feedback Stage:

• Response delivery optimization
• Quality assurance mechanisms
• Performance tracking and analysis
• Continuous learning loops

This implementation achieved significant measurable improvements:

• Response times reduced by over 50%
• Customer satisfaction increased by 35%
• Agent efficiency improved by 40%
• System demonstrated self-optimization through continuous learning

Key Insights

The DOG approach delivers several critical advantages:

1. Enables creation of self-improving AI workflows
2. Ensures direct alignment between components and business objectives
3. Incorporates built-in feedback loops for continuous optimization
4. Provides clear success metrics for measurable improvements
5. Maintains consistent business alignment and focus on ROI

This technology is transforming how organizations handle complex operations by enabling:

• Enhanced decision-making capabilities
• More efficient resource allocation
• Improved scalability
• Stronger business performance

The transparency and structure provided by DOGs make AI systems more manageable, predictable, and aligned with business objectives while maintaining their powerful capabilities for autonomous operation and continuous improvement.

Over the weekend, I had a fascinating discussion that shed light on a critical yet often overlooked aspect of Agentic system design: the strategic choice between deterministic and probabilistic planning. This decision is fundamental to building enterprise-grade agent systems and directly impacts their performance, reliability, and adaptability.

Understanding the Two Approaches to Agent Planning

Agent planning is the decision-making architecture that drives an agent's actions. There are two dominant approaches:

• Probabilistic Planning:
  This approach leverages Large Language Models (LLMs) to create plans dynamically. Probabilistic planning excels in flexibility, context-awareness, and adaptive decision-making. However, it comes with challenges:

  • Consistency: Plans may vary between executions.
  • Bias: Outputs can reflect unintended or unpredictable biases.
  • Repeatability: Recreating exact results can be difficult.

• Deterministic Planning:
  This approach emphasizes precision, repeatability, and predictability through more rules-based systems. Sometimes referred to as "Agents on Rails" (thanks, Parcha!), deterministic planning is ideal for environments where consistency is critical. However, it struggles with:

  • Novel Situations: Limited flexibility for unexpected scenarios.
  • Adaptability: Difficult to modify dynamically in response to changing contexts.

A Strategic Blend: Combining the Best of Both Worlds

The most effective enterprise-grade agent architectures don’t rely solely on one approach—they integrate both. The choice between probabilistic and deterministic planning isn’t about excluding probabilistic components like LLMs entirely; it’s about where and how you use them.

For instance, LLMs can serve as the "glue" between deterministic components, enabling dynamic adaptability while maintaining the reliability of deterministic processes. At Dataception Ltd, we employ AI/LLM-generated Data Object Graphs (DOGs) to fuse these approaches seamlessly.

Key Considerations for Enterprise-Grade Agent Systems

1. Decomposition Over Delegation
   Break down complex tasks into smaller, manageable pieces rather than delegating everything to a single large LLM. This improves both control and efficiency.

2. Match the Tool to the Risk Tolerance

   • Use deterministic approaches for high-assurance tasks where precision and consistency are non-negotiable.
   • Employ probabilistic methods when flexibility and adaptability are more valuable than perfect repeatability.

3. Benchmark Against Reality, Not Perfection
   Probabilistic systems shouldn’t be judged against ideal deterministic outcomes but rather against existing human processes, which are inherently probabilistic. Often, probabilistic outputs are "good enough" for the task—just know when they won’t be upfront to avoid costly rabbit holes.

DOGs as the Foundation of Dynamic Fusion

A key strength of Data Object Graphs (DOGs) is their ability to incorporate both deterministic and probabilistic elements in a structured yet flexible way. By using DOGs, you can dynamically adapt workflows, incorporating LLMs where appropriate while grounding high-stakes processes in deterministic logic.

For example:

• Deterministic Nodes: Handle high-assurance tasks, ensuring consistency and reliability.
• Probabilistic Nodes: Add flexibility and adaptability, especially in dynamic, context-sensitive scenarios.

This hybrid architecture creates a powerful, enterprise-ready framework for Agentic systems.

Final Thoughts

The key to building robust, enterprise-grade Agentic solutions lies in leveraging LLMs and deterministic systems in harmony. By strategically choosing where to apply each approach, you can create solutions that balance precision, flexibility, and scalability.

Just as Gutenberg’s printing press democratized knowledge, AI (Generative + Agentic) is revolutionizing how we create end-to-end software and analytics. In much the same way the press allowed books to be produced quickly and distributed widely—bypassing the labor-intensive work of scribes—AI is accelerating data and technology projects at a remarkable pace.

The New "AI Digital Twin"

What once took teams of developers months to build can now be prototyped in a matter of hours. At Dataception, we call this the AI Digital Twin: leveraging Generative AI and agentic methods with Data Object Graphs (DOGs) to create fully realized analytical applications—complete with user interfaces, back-end logic, and integrated data—at unprecedented speed.

Not Just Faster Coding

Rather than replacing people, AI empowers every member of a project team to contribute at a higher level:

• Product managers can prototype features directly.
• Analysts create custom tools.
• Domain experts collaborate on solutions alongside engineering and data science teams, who can then focus on advanced analytics and modeling—“the cool stuff”—instead of plumbing and boilerplate code.

Implications and Benefits

1. Rapid Innovation: Cycles compressed from months to days.
2. Instant Feedback: Easier to test ideas and iterate with business stakeholders and customers.
3. Reduced Technical Debt: AI-assisted development can help maintain higher code quality.
4. Lower Costs: AI augments human capabilities, trimming overhead.
5. Elevated Work: Teams can focus on strategic problem-solving rather than repetitive coding tasks.

Pure Agentic vs. Model-Accelerated Workflows

You may have heard the debate:

• Pure Agentic Workflow (PAW): AI autonomously creates and executes dynamic decision-making paths.
• Model-Accelerated Workflow (MAW): AI generates more static, accelerated workflows that humans oversee and refine.

TL;DR: Both are valid. Each has its place and must be applied with an understanding of the use case and risk profile.

Delivering Real Business Value

Ultimately, whether you choose PAW or MAW—or a hybrid of both—tools like Lovable (and, of course, our own solutions) help us rise above the data trenches. We can finally give businesses what they’ve been asking for (at least for the last 30 years): rapid, agile, and game-changing outcomes that truly align with their needs.

"We might get in trouble for this one." My son (and I, to be honest) love the Puss in Boots movies, and while watching the latest installment, the scene where the map conjures a nightmarish journey for Puss reminded me of many AI implementation challenges I've seen in organizations. Concept to realized business value is not always a straightforward path.

Below are three recurring challenges—and the insights we've gained—while helping organizations navigate the AI landscape quickly, cheaply, and effectively.

Challenge 1: The Abyss of Eternal Loneliness

Waiting for Data, Access, and Processing

AI often relies on raw data, so make sure you can source it quickly—even if it’s imperfect. You won’t know the data’s value until you see it. Organizational blockers (e.g., delayed access tickets, excessive approval layers) frequently stall innovation, so streamlining this process is critical.

Key Takeaway: Don’t aim for perfectly refined data from the outset. Access raw data, run quick experiments, and refine iteratively.

Challenge 2: The Mountains of Misery

Avoiding Endless Technical R&D and Iteration

AI is rarely (if ever) 100% accurate. Instead of striving for perfection, focus on fast end-to-end feedback loops that validate business impact. Rapid prototyping with digital twins—complete with user interfaces, process flows, models, and data—enables you to:

• Fail fast and cheaply
• Demonstrate feasibility quickly
• Elicit real user feedback early

Key Takeaway: Prioritize fast, iterative delivery over large, costly programs with unclear outcomes.

Challenge 3: The Swamp of Infinite Sorrows

Bridging the Organizational Readiness Gap

Many organizations view AI as solely a data or tech initiative, creating internal friction and resistance. In reality, AI introduces business process change. Engage end users by showcasing an end-to-end business workflow, highlighting how their daily tasks benefit from AI.

Key Takeaway: Frame AI as a driver of business transformation, not just another tech project. Collaborate with business units and show tangible, user-focused value.

The Destination: Valuable Business Change

Success lies in simultaneously overcoming all three challenges while maintaining momentum. Organizations that can ideate → prototype → iterate rapidly at scale will see tangible ROI from AI.

With Agentic AI accelerating the entire process—and making end-to-end business change conversations unavoidable—the real question is: Are you ready for this transformation?

By addressing these common pitfalls head-on, you’ll unlock AI’s potential to turn ruff terrain into real business treasure—and hopefully avoid that cinematic horror-show journey in the process.

We recently highlighted a growing imperative: move from data-centric to business process-centric thinking. In practical terms, this means quickly assembling “AI Digital Twins”—end-to-end business processes (flows, components, UX, governance, etc.) that incorporate exactly the data needed, iterating in rapid cycles with business stakeholders.

Common Pitfalls of Data-Centric Approaches

1. Prolonged Canonical Modeling 
   Months or years spent creating canonical data models slows innovation, adds cost, and delays the testing of new ideas.

2. Delayed Business Use-Cases 
   Data programs can become mired in infrastructure and conceptual frameworks, delaying real end-to-end business use-cases.

3. ‘Single Customer Record’ Complexity 
   Different processes often require different views of customer data, conflicting with the dream of one unified, perfect record.

4. Loss of Business Context 
   Homogenizing “data assets” can strip away contextual nuances, leading to brittle designs that break under new use-cases.

5. Friction for AI and Agents 
   AI models and agentic systems need quick, repeatable access to raw data. Rigid data pipelines hamper these evolving needs.

Data Object Graphs (DOGs) to the Rescue

Instead of focusing on canonical data structures, DOGs start with business processes:

• Process-Centric Approach 
  Rather than intricate data models, we define processes as the “connective tissue.”

• Composable Components 
  Each process pulls in the data products—such as ML models, metrics, or AI agents—it actually needs.

• Virtual Schemas 
  Provide flexible views without physically moving data, preserving business context and avoiding unnecessary duplication.

• Direct Source Integration 
  Keep data in its source systems where possible; DOGs orchestrate the right data at the right time, capturing true domain knowledge.

• Natural Data Relationships 
  Relationships form organically around business operations, rather than being forced into rigid schemas.

Rapid Prototyping with AI and LLMs

Using AI and LLMs, we can now prototype these processes in minutes rather than months:

1. Instant UI Creation 
   Build user interfaces tied directly to data and process flows for fast feedback.
2. Immediate Validation 
   Demonstrate real, working prototypes to stakeholders early and often.
3. Living Knowledge Base 
   Every process, component, and data relationship is cataloged—not just as static documentation but as executable knowledge.

Building a Unified Knowledge Base

As we construct end-to-end processes, we capture all assets and their linkages in a living knowledge system. Each DOG is recorded as a complete business process with its own dependencies, components, and virtual schemas—enabling on-the-fly data virtualization and continuous improvement.

The Result

Using AI, user experience canvases, and DOGs, organizations can quickly prototype, test, and refine end-to-end business processes at the speed of business. No more waiting on monolithic data projects; the data and business processes evolve together.