"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.

As AI continues to evolve, a new frontier is emerging—Reasoning Language Models (RLMs)—a next-generation AI approach that could redefine how machines think, solve problems, and generate insights. Unlike traditional Large Language Models (LLMs), which rely on pattern recognition and probabilistic text generation, RLMs introduce explicit, verifiable reasoning paths, moving beyond single-pass black-box processing.

Why RLMs Matter

While LLMs are powerful for general text generation, their lack of structured reasoning makes them unreliable for complex, multi-step problems. RLMs, on the other hand, actively explore multiple solution paths, evaluate intermediate steps, and backtrack when needed—mirroring human problem-solving.

By leveraging structured exploration using trees, chains, and graphs, combined with value and reward models, RLMs can systematically verify progress, adjust when necessary, and produce more transparent and reliable outputs. This makes them ideal for tasks such as:

• Mathematical proofs
• Scientific analysis
• Complex business planning
• Long-term strategy development

The Trade-Off: Capability vs. Computational Cost

RLMs offer superior reasoning, but this comes with higher computational costs and greater architectural complexity. The decision to use RLMs vs. traditional LLMs is ultimately a trade-off between advanced reasoning capabilities and resource efficiency.

The Core Components of RLMs

1. Reasoning Scheme – The blueprint defining how AI structures its thought process:

• Reasoning Step – The fundamental unit of reasoning.
• Reasoning Structure – How reasoning steps are organized (Chains, Trees, Graphs, or Nested structures).
• Reasoning Strategy – How the reasoning structure evolves over time.

2. Operators  – The AI’s toolset for manipulating and navigating reasoning paths:

• Structure Operators – Modify the reasoning framework.
• Traversal Operators – Navigate through the reasoning process.
• Update Operators – Improve specific steps.
• Evaluate Operators – Assess the quality of reasoning at each stage.

3. Models  – Systems that generate, evaluate, and reward different reasoning approaches:

• Policy Model – Generates reasoning steps.
• Value Model – Evaluates reasoning states.
• Reward Model – Assesses step quality and guides optimization.

4. Pipelines  – The workflows that orchestrate the RLM’s operations:

• Inference – Runs the trained model for real-world application.
• Training – Continuously improves reasoning performance.
• Data Generation – Creates structured training datasets.

The Future of RLMs and Data Object Graphs (DOGs)

There’s already a great paper, "Reasoning Language Models: A Blueprint" (link https://arxiv.org/abs/2501.11223), that lays out one approach to this concept. However, at Dataception, we’ve been exploring a similar but more efficient approach—using Data Object Graphs (DOGs) to tie all these reasoning components together.

Rather than relying on massive LLMs with 100Bs of parameters, we believe we can optimize reasoning processes within DOGs, making RLMs significantly more scalable and efficient. More on that soon… but one thing is clear:

AI isn’t just getting smarter—it’s learning how to think.

Accelerating Business Transformation with AI Digital Twins

I had a fantastic session with Peter Everill discussing "Quantifying Your Value: The Framework Used to Realize £100M Profit" on Kyle Winterbottom’s Orbition Group podcast (link in comments). Peter outlined a consultancy-based framework for delivering end-to-end data products that drive profit directly to the P&L—sometimes to the tune of hundreds of millions.

The Key Takeaway?

It all starts with the business process.
(Yes! Every Data & Analytics team should be doing this!)

A key question that came up was:
"How can LLMs accelerate this process?"

At Dataception, we’ve built a solution that does exactly that—turning simple prompts into full end-to-end business processes using Data Object Graphs (DOGs).

How It Works: From Prompt to AI Digital Twin

1. Capturing the Business Requirement

   • We use our Data Product Pyramid to extract the high-level requirement from stakeholders and convert it into a simple, structured prompt describing the ask.

2. Generating the Business Process as a Data Object Graph (DOG)

   • Our AI-driven solution takes this prompt and generates a complete end-to-end business process, covering:
     • Data to Business Outcome
     • Defined Data Products (AI forecasts, LLMs—SLMs, OSS, and SaaS models—ML models, decision models, pipelines, metrics, and more)
   • The entire process is represented in a structured, human- and machine-readable markup language, where each data product is described alongside its required data.

3. Automated Execution & Visualization

   • The DOG is executed using a graph and data product container-based distributed processing engine.
   • The entire process is visualized in an interactive 3D schematic, providing instant clarity into the workflow.

This is the AI Digital Twin in action—a fully executable, testable business process model.

Why This Matters: The Business Transformation Impact

• Rapid Prototyping with AI & Digital Twins

  • We can test, iterate, and refine entire business processes in days—not months.

• One-Click Execution at the Business Process Level

  • Individual data products can be run in isolation or executed as a complete end-to-end process.

• Continuous Iteration & Adaptability

  • As business needs evolve, the DOG can be refined in real-time, incorporating data quality rules, validation, and automated testing.

• Massive Speed & Low Risk

  • This approach allows businesses to "try out" AI and new ways of working in a risk-free environment before committing to full-scale deployment.

The Future of AI-Driven Business Change

This approach isn’t just faster—it’s safer, smarter, and more cost-effective.

By using AI Digital Twins, businesses can simulate, test, and optimize workflows in real time, unlocking true innovation without the traditional risks of large-scale digital transformation projects.

Want to see how it works? Get in touch with us if you’re interested in trying it out.

With Dataception’s DOGs (Data Object Graphs), AI really is just a walk in the park. 🚀

The long-standing divide between operational and analytical systems is vanishing—if not already gone.

We just used our Data Product Pyramid Gen AI tool to create transactional Data Object Graphs (DOGs) in seconds for a real-world use case. The results? A single, seamless process handling:

✅ Transactional Steps – Actions like bookings
✅ Analytical Steps – AI-powered pricing and decisioning

This is a huge leap for AI-driven business transformation.

The End of the Operational vs. Analytical Divide

Historically, operational data systems (handling real-time transactions) and analytical systems (for decision-making, forecasting, and reporting) have been separate worlds. This led to:

❌ Lag Between Insight & Action – Analytics were always a step behind.
❌ Complex Integration Efforts – Keeping the two in sync was a nightmare.
❌ Higher Costs & Slower Transformation – Running dual infrastructures added complexity and delays.

But with Agentic Data Object Graphs (DOGs), we can now combine both in a single, AI-driven framework—no more silos.

AI Digital Twins: The New Paradigm

With DOGs, businesses can model both operational and analytical processes as a single unified execution graph.

• Immediate Decision-Making – No waiting for analytics to catch up.
• Adaptive Processes – AI dynamically refines transactions based on real-time insights.
• E2E Transformation – True business transformation, where AI, data, and process automation work together seamlessly.

This is not just another tech evolution—it’s a fundamental shift in how business systems operate.

Why This Matters Right Now

We’re entering a new era where data, AI, and business operations are no longer separate conversations.

With AI Digital Twins and Agentic Data Object Graphs, organizations can finally:

• Run real-time operations and AI-driven decision-making together
• Optimize both transactional and analytical flows simultaneously
• Reduce complexity, cost, and technical debt

It’s an amazing time to be at the nexus of Business, Tech, and AI, driving true end-to-end transformation.

If you’re still treating operational and analytical processes separately—it might be time to rethink that approach.

🚀 The future isn’t coming—it’s already here.

At Dataception, we’ve been working on something big—getting AI to generate Data Object Graphs (DOGs) for business processes as AI Digital Twins.

From Process Design to Machine Execution

One of the biggest challenges in business transformation is bridging the gap between process design and execution. Traditionally, business processes exist as static diagrams, documents, and flowcharts—but translating those into real, working solutions has always been a manual and time-consuming effort.

With Agentic DOGs, we automate this entire process by turning traditional business workflows into machine-executable data object graphs, where each node represents a concrete data product—whether it’s:
✅ A metric
✅ A dataset
✅ An ML or GenAI model
✅ A decision engine

Real-World Example: Customer Lifetime Value as a DOG

We recently mapped customer lifetime value (CLV) as a Data Object Graph. Here’s what happened:

1. Each step automatically extracted and processed the precise data needed—pulling from sources like Zoho and other platforms.
2. The data seamlessly flowed through interconnected data products, linking metrics, models, and decision logic.
3. GenAI didn’t just generate the process—it became an active participant, analyzing data and generating insights dynamically along the way.

Why This Is a Game-Changer

🚀 No more manually crafting business process diagrams—everything is automated and executable.
🚀 Cross-domain processes become easier to maintain, as AI dynamically adapts to changing business needs.
🚀 Business process transformation moves from months to days, with real-time AI-driven iteration.

The Future of AI-Driven Business Execution

By using AI-generated Data Object Graphs, we’re not just automating business processes—we’re creating adaptive, intelligent AI Digital Twins that:

🔹 Bridge the gap between design and execution
🔹 Enable AI to actively participate in decision-making
🔹 Dynamically integrate with real business data in real-time

This is the next step in AI-powered business transformation, and we’re seeing incredible results already.

If you’re working on similar challenges—or just want to see this in action—let’s connect.

With  Dataception's DOGs (Data Object Graphs), AI is just a walk in the park. 🐕🚀

Get Good at Changing the AI Wheel Without Stopping the Car

AI implementation is proving to be a major challenge for many organizations. We’ve seen firms sink millions and years into AI projects, only to struggle with adoption and ROI.

But after years of hands-on experience, here’s what we’ve learned:

Key Lessons from AI Implementation

1️⃣ AI Projects Will "Fail"—and That’s Okay

• Experimentation and iteration are essential. AI is not a one-shot success—it’s a process of continuous refinement.

2️⃣ It’s Not Just About GenAI

• Data Science is about problem-solving, not just about picking the latest shiny LLM. Sometimes, traditional ML models or statistical approaches are more effective or complementary.

3️⃣ AI Must Be Continuously Tested in a Fast, Low-Risk Way

• The key isn’t avoiding failure—it’s rapidly placing value-driven, prioritized bets with fast adoption cycles.

The Playbook for Continuous AI Evolution

1️⃣ Create a Strong AI Ideation Process

• Use a value framework to build a pipeline of business-changing ideas.
• Prioritize based on impact, feasibility, and strategic fit.

2️⃣ Rapid Prototyping & Testing (Days/Weeks, Not Months/Years)

• Test new AI innovations using real data in real business use cases.
• Agentic Data Object Graphs (DOGs), powered by our AI Digital Twin prototyping tool, allow businesses to quickly trial new models, frameworks, and workflows.

3️⃣ Prepare the Organization for Change

• AI isn’t just a tech transformation—it’s a business transformation.
• Incentivize business leaders to drive change rather than resist it.
• Shorten the path to production—in people, process, and tech—so that successful AI prototypes don’t get stuck in endless pilot mode.

TL;DR: Get Good at Testing & Swapping AI “Wheels” in Motion

You don’t have to stop the business to integrate new AI capabilities.You just need the right process to test, iterate, and deploy—without disruption.

With Dataception's DOGs (Data Object Graphs), AI is just a walk in the park. 🚀🐕

I had a fantastic discussion with Eddie Short about how GenAI is transforming the process of turning ideas into working prototypes—complete with user interfaces—in front of customers faster than ever before.

The rise of Large Language Models (LLMs) isn’t just changing how we write code—it’s revolutionizing how we bring business ideas to life.

The Traditional "Miner" Mindset: Extracting Raw Materials

Historically, delivering business solutions followed a slow, resource-heavy approach:

🔹 Requirement Workshops – Extensive stakeholder discussions to define needs.
🔹 UX Research & Wireframes – Building static design mockups.
🔹 Spike Solutions – Exploratory coding exercises to test feasibility.
🔹 Platform Foundations – Standing up infrastructure, security, and integrations before real development begins.

🚨 The result? Months (or longer) before the business gets:
✅ A realistic application experience
✅ Real data from enterprise systems

This is the Miner Mindset—spending time "mining raw materials" before producing something valuable.

The AI-Driven Designer Mindset: Rapidly Translating Ideas to Business Experiences

Now, LLMs are massively accelerating this process, enabling us to build customer-facing industrial prototypes at unprecedented speed.

🔹 Idea → Working Prototype in Days – AI takes business requirements and generates an interactive prototype rapidly. 

🔹 AI-Generated Business Processes – Data Object Graphs (DOGs) define end-to-end workflows, including UIs, backend logic, and data pipelines. 

🔹 Real Data, Real Insights – Early-stage solutions integrate real business data, enabling immediate testing and validation.

This is the Designer Mindset—where ideas quickly become tangible, testable business solutions.

AI Won’t Get It Perfect—But It Doesn’t Need To

AI won’t generate a flawless solution on the first attempt—but that’s not the point.

Instead, it gets us 80% of the way there, providing a functional design that businesses can review, validate, and refine quickly.

💡 The true paradigm shift is that we can now design, test, and iterate business solutions in real time, instead of waiting months to even begin user validation.

The Challenge: Mastering AI-Assisted Development

While LLMs are game-changers, they struggle with:

• Handling Large Codebases – Token limits cause them to forget prior context.
• Understanding Complex Requirements – AI needs guidance to navigate intricate business rules.

🚀 The key? Knowing how to break down problems and steer AI towards the right output.

It’s no longer about writing every single line of code—it’s about:

✅ Conceptualizing business-facing systems
✅ Accelerating with AI
✅ Applying human expertise where it matters most 

The Future Belongs to Developers Who Think Like Designers

The ability to orchestrate AI-driven solution design is now a competitive advantage.

By shifting from Miners to Designers, we unlock the full potential of AI-assisted software development—delivering faster, smarter, and more adaptive business solutions.

With Dataception's DOGs, AI is just a walk in the park. 🚀🐕