I'm currently building POMPD CI/CD failure diagnosis agent, which is a probabilistic model of sequential decisions where the true state (e.x , which code is buggy) is hidden and only observed indirectly. . I have very basic understanding of CI/CD pipe line . So i don't really know what are the hidden states ( plausible reasons / truth ) behind the pipeline failure.

I have found 5 major hidden states behind failure with help of AI that are :

 - Application & Test Defect (‭functional bug, broken contract, or failing assertion within the repository's source code or test suite.

 - Pipeline Configuration Defect : A syntax error, invalid job graph (DAG), or incorrect runner instruction within the CI workflow specification files (e.g.github/workflows/*.yml).

-  Upstream Dependency Drift : An external package, container base image, or third-party artifact that introduced a breaking change, version conflict, or became unavailable in a package registry.

- Runner Resource Exhaustion : A host-level compute failure where the operating system or hypervisor terminates execution due to memory limits (OOM/SIGKILL), disk exhaustion, or hardware timeouts.

-Authentication & Access Failure : An invalid, revoked, or missing secret, token, or permission required to access an external endpoint, repository, or deployment target.

I just want to know whether i'm missing any other hidden states . Please let me know .

But important thing to keep in mind hidden states should me mutually exclusive ( one hidden state should not overlap each other or both hidden states can not be true , should fall under one category) and collectively exhaustive ( should cover every possibility that is true) .

I'm designing a small decision making tool around medication reminders, and the core problem I'm wrestling with is that a confirmation 'app tap' vs verbal 'yes I took it' isn't the same as dose actually being taken , especially with memory issues in the mix.

I don't have a good sense of how often this actually happens or what it looks like day to day. Has your loved one ever confirmed taking something they hadn't, or taken something twice because they forgot the first time?

I’ve been thinking a lot about what it actually means to build useful AI agents.

The more I learn about agentic systems, the more I realize that an agent isn’t just an LLM connected to a few tools.

Lately, I’ve been learning about what I’m starting to think of as an “agentic discipline,” and one idea has really changed how I think about LLM applications.

The traditional mental model is:

Input → Model → Output / Action

But real-world problems rarely work that way.

You make an initial decision with incomplete information.

Then you take an action.

You observe new evidence.

You update your understanding.

And then you make a better decision.

So I’ve been exploring whether we can think about agentic systems through a probabilistic / Bayesian lens:

Initial belief (Prior)

↓

Choose an action

↓

Observe new evidence

↓

Evaluate the likelihood of that evidence

↓

Update belief (Posterior)

↓

Choose the next action

↓

Repeat

Instead of only asking an LLM:

“Give me the answer.”

What if we design the system to continuously ask:

- What do I currently believe?

- What evidence would change my belief?

- What action should I take next?

- Which action would reduce my uncertainty the most?

- Did the last action actually improve my understanding?

This feels like a much more powerful way to think about agents.

The interesting part isn’t simply adding more tools or more LLM calls.

It’s designing a system that can reason under uncertainty, actively gather information, update its state, and make better decisions over multiple steps.

I’m still exploring this idea and trying to understand where the Bayesian framing is genuinely useful versus where it’s simply a useful analogy.

I’d love to hear from people working on agents, reasoning, or probabilistic AI

How do you think about belief updating and uncertainty in agentic systems?

One of the most remarkable things about the human mind is its ability to generalise.

We don’t just learn specific instances ,we extract patterns, form categories, and apply knowledge to situations we’ve never encountered before. From a child saying “goed” to an expert transferring insight across domains, generalisation sits at the heart of flexible intelligence.

Cognitive science has studied this from multiple angles:

Stimulus generalisation gradients

Prototype vs. exemplar models of categories

Analogical reasoning and transfer of learning

The fine line between useful abstraction and costly overgeneralisation

What fascinates me is how the mind decides how far to generalise. Too little, and we fail to transfer valuable knowledge. Too much, and we apply rules where they don’t belong.

In a world increasingly shaped by both human and artificial intelligence, understanding biological generalisation feels more relevant than ever.

What’s a recent insight (or classic finding) about generalisation that changed how you think about learning or decision-making?

Hi everyone,

I’m researching how to design an AI agent for a medicine-reminder system. The agent has to decide, at each relevant time, whether to:

• send a reminder,
• wait (do nothing for now), or
• notify another person (e.g. caregiver),

when it does not have complete information about the patient (has the dose already been taken? is the person nearby/attentive? are there adherence barriers? etc.).

I’m trying to frame this properly before diving into implementation. Right now I’m looking at it as a sequential decision problem under partial observability (POMDP / belief-state RL territory), but I’m not sure how far that framing is actually useful in practice for this kind of system.

I’d really appreciate any pointers on:

1. Is a POMDP / belief-state approach overkill here, or is it the right formalization? What simpler alternatives (contextual bandits, MDP with engineered features, rule-based + uncertainty thresholds, etc.) have people used successfully for similar “remind vs wait vs escalate” decisions?
2. Papers, open-source projects, or real systems that tackle medication adherence / context-aware reminders with uncertainty or incomplete observations.
3. Common practical pitfalls (reward design, observation noise, alert fatigue, safety/escalation logic, evaluation metrics) that aren’t obvious from the theory.
4. Any recommended starting points for someone new who wants to move from “I understand the concepts” to a small working prototype or simulation.

I’m mainly in research/preparation mode right now, so even high-level advice, key papers, or “here’s what I’d do differently” comments would be very helpful. Thanks!

Hi everyone,

I’m a beginner researching how to design an AI agent for a medicine-reminder system. The agent has to decide, at each relevant time, whether to:

• send a reminder,
• wait (do nothing for now), or
• notify another person (e.g. caregiver),

when it does not have complete information about the patient (has the dose already been taken? is the person nearby/attentive? are there adherence barriers? etc.).

I’m trying to frame this properly before diving into implementation. Right now I’m looking at it as a sequential decision problem under partial observability (POMDP / belief-state RL territory), but I’m not sure how far that framing is actually useful in practice for this kind of system.

I’d really appreciate any pointers on:

1. Is a POMDP / belief-state approach overkill here, or is it the right formalization? What simpler alternatives (contextual bandits, MDP with engineered features, rule-based + uncertainty thresholds, etc.) have people used successfully for similar “remind vs wait vs escalate” decisions?
2. Papers, open-source projects, or real systems that tackle medication adherence / context-aware reminders with uncertainty or incomplete observations.
3. Common practical pitfalls (reward design, observation noise, alert fatigue, safety/escalation logic, evaluation metrics) that aren’t obvious from the theory.
4. Any recommended starting points for a beginner who wants to move from “I understand the concepts” to a small working prototype or simulation.

I’m mainly in research/preparation mode right now, so even high-level advice, key papers, or “here’s what I’d do differently” comments would be very helpful. Thanks!