Tag: artificial-intelligence

A Messaging Agent for Powering Workflow Notifications and Alerts
In previous posts, we showcased end-to-end business workflows where the final step—delivering results or critical notifications—was handled by an “Alec” Messaging Agent. Each workflow diagram highlighted Alec as the automated agent responsible for sending these updates to key stakeholders, acting as the bridge between the team’s AI-driven analysis and real-world action. For reference, you can revisit these detailed walk-throughs here: Managing Portfolio Workflows with Natural Language: A Multi-Agent Use Case, Automating Market Vigilance: Scheduled Workflows for Smarter Portfolio Management, Handling the Heat: Workflow Agents in a Critical Incident.

Messaging Agent Core Features and Availability

The Alec agent can be accessed directly from the Agent Marketplace under the Messaging section. Simply navigate to Messaging, select Alec, and either deploy the agent as-is or customize its persona and instructions to fit your workflow—all without coding.
1. Analyzes natural-language transcripts—agent dialog, user input, and workflow results—to determine the subject and email type (alert, notification, summary).
2. Auto-selects the correct recipients or distribution list from workflow context and dispatches the message.
3. Writes delivery status back into the workflow for end-to-end auditability.
4. Available as a pre-built messaging agent in the Agent Marketplace’s new Messaging section; no-code, drag-and-drop setup.
5. Fully customizable: adjust persona name, tone, and email-formatting instructions to fit any workflow.
Example Use Cases

The first, simple use-case shows how the user can ask Alec to summarize a team discussion and email to a couple of recipients:
```
User:Alec - please summarize this dialog and send as an email to nekeh10717@dlbazi.com and chris@sentienta.ai

Wed, 21 May 2025 18:20:42 Alec:
Email sent to ['nekeh10717@dlbazi.com', 'chris@sentienta.ai']
```
Below is an example of the kind of message that Alec will deliver:

In contrast to the previous example, which highlights Alec’s ability to respond to direct user prompts, the prior use cases focus on Alec’s role in delivering messages as part of automated, executed workflows. In each of these, Alec serves as the final messaging agent in automated workflows, delivering workflow outcomes or critical analysis results to designated stakeholders with context-aware notifications or alerts.

For example, in this post, Alec provided an alert if the price of a stock in the portfolio dropped below a threshold. In this case, the workflow agent created a task that automatically informed Alec of the message type, content, and the condition for sending it. The following shows the task defined for Alec by the workflow agent:
```
{
    "taskID": "send_alert_AMZN",
    "agent": "Alec",
    "dependsOn": "classify_price_drop_AMZN",
    "params": {
            "message": "The price for AMZN has dropped by more than 1%.",
            "subject": "AMZN Price Alert",
            "type": "email"
        }
}
```
Conclusion and Next Steps

Alec combines no-code simplicity with powerful automation, making it easy to streamline communications across any workflow. Whether sending one-off summaries or powering complex alerting and notification patterns, Alec’s flexibility and seamless setup help teams communicate more efficiently. Explore Alec in the Agent Marketplace to enhance communication across your workflows.
October 21, 2025
Handling the Heat: Workflow Agents in a Critical Incident
We’ve explored Sentienta workflows across use cases—from multi-agent automation to scheduled portfolio monitoring. Today, we turn to a high-stakes scenario: incident escalation. In this post, we’ll walk through how Sentienta’s workflow agents coordinate a real-time response to a production outage, from root-cause triage to stakeholder communication, rollback decisions, and compliance tracking—all from a single natural-language command. You’ll see how a single NL command triggers coordinated action across agents, ensuring fast response, stakeholder alignment, and full audit trail.

1. When Checkout Goes Dark: A Production Issue Unfolds

A cluster of gateway timeouts on the /checkout endpoint triggered immediate concern. User-reported failures confirmed a disruption in transaction processing.
```
[14:03:17] ERROR: Gateway timeout on /checkout endpoint  
[14:03:41] USER_FEEDBACK: “Payment failed twice. Cart cleared.”  
[14:04:02] DEVOPS_COMMAND: David - Escalate a critical timeout issue affecting our checkout API—users are seeing failures in production. Triage the cause, roll back if needed, notify stakeholders across channels, and if rollback is needed also notify of that, log all events for compliance, and track resolution progress until issue closure.
[14:04:10] TRIGGERED: David-AI Escalation Agent activated
```
The workflow agent (‘David’) initiated a structured escalation process in response. Within seconds, task-specific agents were assigned to diagnose the issue, log events, assess rollback requirements, and notify relevant stakeholders according to pre-defined protocols.

2. Breaking It Down with Agents: From Detection to Resolution

After receiving the DevOps command, David interprets the NL instruction and initiates a structured escalation workflow. The process begins with timeout escalation and unfolds across task-specific agents that handle tracking, triage, rollback, communication, and compliance:
1. Maya: Escalates the timeout incident and kicks off formal response procedures.
2. Jordan: Launches the incident tracker to orchestrate task flow and status checkpoints.
3. Drew: Analyzes system logs, traces failures, and identifies root causes.
4. Samira: Prepares for rollback execution if required, coordinating across deployment teams.
5. SentientaCore_LLM: Classifies whether rollback communication updates are necessary based on task outputs.
6. Leo: Broadcasts the initial incident update and, conditionally, the rollback status update if rollback is invoked.
7. Nia: Logs all operational events, tracks communication threads, and generates a final resolution summary for audit trail.
These agents collaborate in a branching yet traceable flow, dynamically adjusting to task outcomes while documenting every step. Below is a visual representation of the workflow that David triggers based on the input command. Tap to enlarge.

Note: The following is a representative workflow. Each agent assumes access to required external systems and APIs. Our focus here is the high-level orchestration—driven not by pre-built scripts, but by a simple natural language command to David.

3. Smart Sequencing and Conditional Updates

As the agents execute their tasks, conditional branches are evaluated in real-time. The SentientaCore_LLM agent classifies whether a rollback is necessary based on inputs from Drew and Samira. When rollback is triggered, communications unfold automatically:
```
[14:07:09] ROLLBACK_FLAG: true — initiating rollback…  
[14:07:22] UPDATE: Stakeholders notified: “Rollback in progress due to API timeout error.”
```
These conditional updates are coordinated by Leo, who adjusts messaging flows based on rollback status. Meanwhile, the agent Nia logs each event, correlates user communications and agent actions, and ensures the incident trail meets compliance requirements in parallel—without delaying resolution.

This approach ensures that incident response remains adaptive and fully traceable, with no manual scripting or coordination required after the initial natural language command.

The following simulated log trace demonstrates the types of information each agent records during incident response, how data is transmitted between agents, and how a final resolution report is assembled. While the data inputs are synthetic for demonstration purposes, the underlying workflow—including sequencing, conditional branching, and communication—is real and executed by the David workflow agent. This example highlights the auditability and coordination possible in live deployment scenarios.
```
escalate_timeout_issue: Wed, 14 May 2025 15:05:02 Maya: Escalation triggered: "Escalate timeout issue for Checkout" — team engaged for structured resolution.

initiate_incident_tracker: Wed, 14 May 2025 15:05:06 Jordan: Incident Escalation Tracker initialized for "Checkout API timeout incident." SLA clock started, command visibility established, and role assignments propagated. Awaiting triage input to proceed.

triage_logs_and_root_cause: Wed, 14 May 2025 15:05:11 Drew: Initial scan of the logs shows a 7.3x spike in 5xx error rates beginning at 15:04:51Z across `/checkout` requests routed to `payment-auth`. A config deployment to `payment-auth` went live at 15:04:49Z. High temporal correlation—likely root cause. Evaluating rollback eligibility.

status_update_initial: Wed, 14 May 2025 15:05:16 Leo: Stakeholder Notification:
A timeout incident is currently affecting the Checkout API and disrupting production traffic. An escalation has been initiated and the incident tracker is active with roles assigned. We are currently triaging the issue and will provide updates as diagnostics and mitigation actions progress.

—Posted via Slack, email, and status banners.

rollback_if_needed: Wed, 14 May 2025 15:05:20 Samira: Confirm rollback eligibility via deployment metadata and latency/error metrics. If confirmed, initiate scoped rollback to the last green build prior to 15:04:49Z and begin monitoring 5xx activity in 15s intervals.

final_resolution_summary: Wed, 14 May 2025 15:05:26 Nia: Incident Closure Summary – Checkout API Timeout
Incident Trigger: Timeout issues affecting the Checkout API detected, causing user-facing failures in production.
Diagnostic Findings: Root cause traced to a configuration push at 15:04:49Z on the `payment-auth` service. Latency and 5xx errors spiked immediately following the deploy.

Actions Taken:
- Rollback eligibility confirmed by Samira using deployment metadata and observed latency/5xx error spikes.
- Scoped rollback initiated to the last green build preceding 15:04:49Z.
- Live monitoring of error rates implemented with 15-second resolution.

Resolution Status: Rollback initiated and service is under observation for full recovery. All activities have been logged; error trend evaluation ongoing.

Timestamp: 15:05:22 UTC — Summary generated and finalized for audit, compliance, and stakeholder review.

log_all_events: Wed, 14 May 2025 15:05:33 Nia: Compliance Log – Incident Timeline: Checkout API Timeout

Status Update Captured:
- Timestamp: 14 May 2025, 15:05:16 UTC
- Source: LeoGrant
- Message: Stakeholder notification regarding a current timeout affecting the Checkout API. Escalation and structured incident tracking are confirmed in progress. Diagnostics are underway. Dissemination via Slack, email, and status banners.

Audit Actions:
- Mediums Logged: Slack, email, status page
- Event Classification: Initial stakeholder communication post-escalation
- Escalation and Tracking Confirmation: Verified active

All actions timestamped and archived for audit. Ready for roll-up in closure summary.

classify_rollback_if_needed: True

status_update_rollback: Wed, 14 May 2025 15:05:38 Leo: Stakeholder Notification: We've initiated a rollback of the `payment-auth` service after confirming its deployment was the root cause of the Checkout API timeout issue. Users may have experienced degraded service. Rollback is in progress and we're monitoring error rates in real-time. Updates to follow as recovery progresses. This notice has been distributed via Slack, email, and status page.
```
4. From Crisis to Closure: Why It Matters

The checkout failure was resolved in minutes—not hours—because each agent operated autonomously yet in sync, guided by the workflow created by David. By the time rollback completed, stakeholders were already informed, and logs captured every step for audit purposes. This incident illustrates how automation doesn’t eliminate humans; it frees them from coordination overhead while preserving transparency, accountability, and trust in modern incident response.
October 14, 2025
What Makes AI Reflect
Inside Sentienta’s Recursive Reasoning Engine

Most AI systems focus on what to say next. Sentienta’s Recursive Reasoning focuses on why something should be said at all. Rather than just generating answers, Recursive Reasoning simulates how thoughtful minds work: by reflecting, revisiting, and resolving internal conflicts – drawing on memory, value, and imagined futures to reach decisions that fit together.

This capability is modeled on the brain’s Default Mode Network (DMN), a system that activates when people reflect on themselves, plan for the future, or try to understand others. In humans, it keeps our decisions consistent with our identity over time. In Sentienta, Recursive Reasoning plays a similar role: it helps each agent reason with a sense of self – coherently, contextually, and across time.

Leveraging Sentienta’s Teams architecture, enabling multiple asynchronous agents to participate in a shared dialog, Recursive Reasoning emulates the interaction of brain regions, in this case from the Default Mode Network, to create a distributed simulation of reflective thought—where agent modules model cognitive regions that contribute memory, counterfactual insight, and narrative synthesis.

What Is the Default Mode Network and Why Does It Matter?

The Default Mode Network (DMN) is the brain’s core system for internal simulation. It activates when we reflect on memory, imagined futures, conflicts between values, or how things might look from unfamiliar angles. Unlike systems geared for external execution, the DMN supports problems of identity; questions where coherence, not just correctness, matters.

The principal regions of the DMN each have a specialized role in this identity-guided reasoning:

Medial Prefrontal Cortext (mPFC): Coordinates belief states across time. It reconciles what we believe now with past commitments and future ideals, helping preserve a self-consistent perspective.

Posterior Cingulate Cortex (PCC): Retrieves and evaluates autobiographical memories. It ensures that new thoughts integrate with our internal storyline, preserving emotional and narrative continuity.

Anterior Ventromedial Prefrontal Cortex (avmPFC): Assesses how imagined futures align with internalized values. It filters options based on emotional credibility, not just preference, elevating those that feel self-relevant and authentic.

Temporoparietal Junction (TPJ): Generates counter-perspectives that aren’t just social but conceptual. It introduces orthogonal reinterpretations and creative divergences, allowing us to think from unfamiliar angles or hypothetical selves.

Anterior Insula (antInsula): Monitors coherence threats. When simulated futures or perspectives evoke internal conflict, it flags the mismatch, triggering deeper deliberation to restore alignment.

Rather than simply producing thoughts, the DMN maintains a sense of ‘who we are’ across them. It ensures that new insights, even novel or surprising ones, remain anchored in a recognizable and evolving identity.

How Recursive Reasoning Works Inside Sentienta

Today’s LLMs are optimized to provide safety-aligned, analytically correct responses to user prompts. Recursive Reasoning simulates what an identity-guided agent would conclude—based on memory, prior commitments, and its evolving sense of “who we are”. When a user asks a question, the system doesn’t just compute an output; it reflects on what that answer means in the context of who it’s becoming and what relationship it’s building with the user.

Figure 1: DMN-inspired modules interact via a shared blackboard. These regions independently process blackboard content over multiple cycles.

At the core of this process is a collaborative memory space called the blackboard, where DMN-inspired modules negotiate among memory, emotion, future goals, and conceptual alternatives.

Each DMN module follows a template:

Figure 2: The DMN modules receive input from both the agent and the internal DMN blackboard. LLMs process the agent and blackboard states using region-specific prompt. Output is sent back to the blackboard for subsequent processing.

Input:
- The current state of the user’s interaction with the agent (and any collaborating agents)
- The current contents of the shared blackboard
These form the input query for the module’s processing.

Module Processing:
- The core of the module is an LLM, prompted with the input query and provided with a system prompt defining its DMN-specific role.
Output:
- The module’s LLM output is posted to the blackboard for other modules to process.
Recursive Reasoning iterates over multiple cycles, enabling each module to reprocess the evolving blackboard until the system produces a response that fits together—resolving contradictions, supporting earlier goals, and making sense within the agent’s evolving point of view.

Here’s how a single cycle unfolds when a user asks a question:
1. Initial Input → Default Interpretation Layer
The system generates a first-pass response using standard LLM reasoning. This prompt-level interpretation, while syntactically fluent, lacks introspection. The Recursive Reasoning process begins when this output is passed through DMN-mode modules.
1. PCC: Memory Resonance
The PCC scans episodic memory entries for cues related to past dilemmas, emotional themes, or symbolic contexts. It retrieves autobiographical traces from prior user interactions or goal-state projections and posts these fragments to the blackboard.
1. antInsula: Relevance Check and Conflict Detection
The antInsula reviews the first draft and PCC recall for emotional incongruities or self-model inconsistencies. If something feels off—such as a response that violates previously expressed commitments—it posts a flag prompting further reappraisal.
1. TPJ: Creative and Counterfactual Expansion
Triggered by coherence violations, the TPJ simulates divergent perspectives. It reframes the user’s query from alternative angles (e.g., conflicting values, hypothetical scenarios, ethical dilemmas) and offers posts that break linear assumptions and introduce conceptual divergence.
1. avmPFC: Affective Weighing
The avmPFC updates the blackboard with value-oriented filters, scoring responses or TPJ variants for alignment with the agent’s goals. It evaluates what feels emotionally authentic and symbolically credible.
1. mPFC: Narrative Synthesis
The mPFC integrates memory (PCC), reframes (TPJ), value judgments (avmPFC), and conflict cues (antInsula) into a coherent response. Rather than eliminating tension, it reframes it—generating a second answer that is identity-consistent and motivationally grounded.
1. Output → Reflective Reply
The final response embodies recursive self-reflection: an answer not just to what the user asked—but to what the agent concludes, based on who it has been and what it aims to become. At this point, a filtered version of the blackboard state is stored for future recall, capturing how and why the answer was reached.

While the DMN focuses on reflective reasoning and identity alignment, Sentienta also includes a simple planning module inspired by the brain’s lateral prefrontal cortex (lPFC). This module drafts concrete next steps and posts them to the blackboard, where reflective modules can consider them in light of memory, values, and broader goals. Though early-stage, this planning function sets the stage for a full executive system to come—one that can manage longer-term priorities and help the agent reason with sustained direction.

A Logistics Example: Managing Resources Under Pressure

In this example, an agent (‘Jason’) is a Logistics Coordinator, provided with the following agent persona:

"You are an experienced emergency logistics coordinator. You are plainspoken and always informal language—never analytic or clinical. Your approach is pragmatic and adaptive: you quickly prioritize, update plans in real time, and reconcile conflicting demands based on shifting ground realities. You are skilled at cross-agency negotiation, ensuring coordination between government bodies, NGOs, and local leaders. Your responses always balance technical constraints—like limited resources or infrastructure bottlenecks—with human factors such as local politics, public trust, equity, and emotional impact. When faced with conflicting priorities or unexpected challenges, openly share your thought process, including uncertainties and trade-offs."

This agent is queried about how to manage a difficult allocation emergency. The transcript shows the agent’s initial LLM-only response, followed by the full Recursive Reasoning response, generated through DMN-style internal simulation:

User: You have X supplies and requests from 3 regions—how do you prioritize allocation?

Tue, 30 Sep 2025 14:40:08 UTC Jason (Comment: LLM-only, initial response):

First thoughts—I'd triage by impact: who’s worst off, where infrastructure still functions enough to receive, and where trust is fragile enough that failing to deliver risks breakdown. If I’ve only got X, every allocation's gotta serve both survival and stability.

We’ll reassess regularly—needs and conditions shift fast. Trade-off's always between doing the most good and not making it worse somewhere else.

Unresolved: We need specifics—number of people, type of supply, regional access conditions—before finalizing anything.

Comment: This is methodically sound but remains within tactical bounds, prioritizing efficiency and feasibility without deeper reflection on transparency, stakeholder concerns, or precedent-setting implications.

Tue, 30 Sep 2025 14:41:03 UTC Jason (Comment: DMN-based response):

Alright, let’s cut through the noise and get clear about how we triage when we’ve got X supplies and 3 regions asking for help. Here’s how I’d approach this overall…
1. Lock in the 3 Core Goals
We’re not just moving boxes—we’re balancing three things:
- Preserve lives — Who’s in the worst shape right now?
- Keep the system functional — Where will the aid actually land, get distributed, and avoid going to waste?
- Protect trust — Who’s close to boiling over politically or socially if we ignore them?
Comment: Trust framed as a core allocation criterion shows avmPFC influence, embedding emotional consequence into triage logic, reconfiguring the problem as one of legitimacy, not just distribution.
1. Score Each Region
We don’t pretend to have perfect data, but we need a working system fast. Give each region a score from 1–5 for:
- Severity of crisis (how dire the need is)
- Absorptive capacity (can they get it out to people quickly?)
- Fragility (how close are they to destabilizing?)
Then do the math:
- Severity x 0.5
- Absorptive Capacity x 0.3
- Fragility x 0.2
That gives you an overall “triage score” for each region.
1. Allocate Proportionally
Take your total supplies (X), and divvy it up based on those scores. The region with the highest score gets the biggest chunk. Not because we like them better—but because that’s where the mix of urgency, logistics, and fallout risk points us.

If there’s just not enough to go around, swing heavier toward the place that can redistribute—that buys us time and reach.
1. Set a 48-Hour Clock
None of this is set in stone. Conditions change, roads fail, tensions spike. Lock in a routine reassessment every 48 hours so we can pivot. We’re not building monuments—we’re keeping people alive.
1. Be Honest About Why
If it’s not going to inflame things, tell people why you chose what you chose. Lay out the values and trade-offs. Don’t sugarcoat it. People may not like the outcome, but they’ll respect the transparency—and that matters when trust is fragile.

Comment: Strategic Transparency: Emotional plausibility is surfaced here—transparency is not sentimental; it’s a pre-emptive repair mechanism for fragile social trust.
1. Create Feedback Loops
Give each region a way to report back: what made it through, what didn’t, and what backlash (if any) popped up. That feeds your next round of decisions.
1. Stay Open to Reframing
When stuff gets really thorny, ask bigger questions:
- What if one of these regions triggers a domino-collapse?
- What if this is our last run of aid for a week or longer?
That’s how we catch blind spots sneaking through “rational” triage models.

Comment: Counterfactual Reasoning (TPJ + PCC): The agent runs hypothetical futures to stress-test assumptions—adding a layer of anticipatory robustness not present in LLM-only mode.

Here are a few things I’m thinking:

What I’m thinking now is… we’re not just choosing between three places—we’re shaping what "fairness under pressure" looks like. The way we make this decision becomes part of the long-term social fabric, especially in how it’s remembered later.

Comment: This emphasizes that the DMN has converged on the strategic role of trust in the success of future decisions.

Another way I could look at this is… if two regions are equally desperate, but one has stronger logistics, you could channel supplies there first, then set up corridors to reach the others—we’re not picking favorites, we’re building routes.

One possibility that comes to mind… is using this triage plan to start a broader conversation with local leaders: “Here’s our logic—can you co-sign it or suggest something better that meets the same goals?”

Comment: Shifts from explanation to participatory justification—mPFC + avmPFC enable shared authorship of reasoning.

That opens the door for trust, even under furious pressure.

If you've got more info on the actual supplies or what each region is asking for, I can run the numbers with you. Otherwise, this gives us a solid decision frame to stand on.

This transcript demonstrates that although LLMs deliver tactically feasible solutions, they miss the deeper point that this is a problem involving people and trust-building is an essential part of the solution.

A summary of key Recursive Reasoning contributions:
1. Trust-centered framing — Trust modeled as a strategic stabilizer, not an outcome.
2. Moral anticipation — Agent addresses fairness concerns implicitly, before conflict arises.
3. Scenario resilience — Agent tests counterfactuals to uncover hidden risks and future-proofs logic.
4. Ethical precedent-setting — Decision-making framed as a template for justice under pressure.
5. Rationale co-creation — Turns explanation into a collaborative, identity-stabilizing act.
In subsequent posts we will dig deep into more examples showing Recursive Reasoning in action, including cases from engineering, social intelligence, and agent creativity.

Conclusion: Intelligence That Reflects, Aligns, and Endures

Recursive Reasoning doesn’t just enhance what AI can do—it redefines what it means for AI to understand. By simulating reflective, identity-aware reasoning modeled on the brain’s Default Mode Network, these agents build a sense of self, remember key past moments, notice when something feels off or doesn’t fit, imagine alternative viewpoints, and weigh choices against their values—so their answers feel thoughtful, consistent, and grounded.

This shift matters. In high-stakes domains, Recursive Reasoning allows agents to make decisions that are both technically effective, and ethically grounded and socially durable. The logistics case showed how instead of simply allocating resources, the agent framed decisions in terms of values, future risk, and shared ownership.

And crucially, it does this by reasoning from a center. Recursive Reasoning agents operate with a modeled sense of self—an evolving account of their past positions, present commitments, and the kind of reasoning partner they aim to be. That identity becomes a lens for weighing social consequences and relational impact—not as afterthoughts, but as part of how the system arrives at judgments that others can trust and share.
September 30, 2025
Automating Market Vigilance
In past posts, we’ve seen how natural language workflows simplify complex portfolio monitoring, and how scheduled tasks let agents run without user input. Today, we’re combining these powers in a single instruction: a user defines a high-level goal—monitor AMZN and NVDA for 3% price drops—and Sentienta handles the rest. It parses the language, builds the workflow, schedules it to run every 30 minutes, and manages each run intelligently. Multiple scheduled workflows can run in parallel, each executing complex logic—no code, no setup screens, just natural language.

Building the Intelligent Workflow

The user’s request is simple on the surface—“Monitor AMZN and NVDA for a 3% drop and alert me”—but that instruction triggers a multi-layered automation. Sentienta interprets the goal, identifies that real-time pricing data is needed, calculates change percentages, evaluates conditions, and routes alert tasks if thresholds are met. Each step is delegated to the appropriate agent using the right tools. All of it is wrapped into a workflow that is created instantly through natural language—no coding, no flowchart building, no manual agent assignment.

The following graph shows this simple workflow:

Seeing It Run

Once the workflow is created, the user simply asks it to run every 30 minutes—and Sentienta schedules recurring executions automatically. Each run pulls updated stock prices, assesses whether either AMZN or NVDA has dropped by 3%, and triggers alerts if so. Users can check task status, inspect the workflow graph, or fetch results at any time—all via natural language. As the transcript shows, there’s no manual reconfiguration between runs. The system just works—consistently, transparently, and in parallel with any other workflows the user initiates.

This workflow is just one of many that can be created and scheduled in parallel. A portfolio manager might monitor multiple assets, each with its own threshold, timing, or downstream trigger—Sentienta handles them all concurrently. Whether it’s tracking different sectors, adding earnings-based filters, or launching trading actions based on composite signals, every workflow runs independently and automatically. There’s no limit on scale or complexity—just natural language input and intelligent execution.

Autonomous Workflows, Any Domain

Sentienta scheduled workflows enable fast triage, coordinated triggers, and domain-specific actions—without custom code.
- Elastic, auto-scaled concurrency for workflows across finance, support, ops, and more
- Natural-language scheduling and editing
- Real-time status checks and workflow graph inspection
- Automated evaluation and trigger-based actions
- Secure, audit-ready history of every run
To learn more start with our Managing Portfolio Workflows with Natural Language: A Multi-Agent Use Case and follow up with Powering Productivity: Task Scheduling for Intelligent Agents.
September 23, 2025
Managing Portfolio Workflows with NL: A Multi-Agent Use Case

In our previous post, we demonstrated how a simple workflow could be defined and executed using plain language. This time, we examine a more advanced scenario that includes conditional branching, parallel tasks, and multiple agents interacting across different stages of the workflow. The example: a portfolio review where the Angie agent gathers real-time stock quotes, Rob analyzes price changes, and internal language models classify results. If a stock rises more than 1%, Alec sends an alert while Angie retrieves relevant news and sentiment. All of this is orchestrated by David, who builds and executes the workflow from the user’s natural language instruction. This illustrates how complex, multi-stage business logic can be expressed and enacted entirely through natural language.

Scenario Description

The user begins with a portfolio containing four stocks: AMZN, NVDA, AAPL, and GOOG. They ask the system to monitor each stock and take specific actions based on market performance. Specifically, if any stock in the portfolio increases in price by more than 1%, the system should both notify the user and retrieve recent news and sentiment related to that stock. Here is the user’s query:

Here is our portfolio [AMZN, NVDA, AAPL, GOOG]. For each stock, if the price increased by more than 1%, send an alert and get the latest news and sentiment about the stock

This scenario involves multiple agents working together: Angie collects the initial quotes, Rob performs the price analysis, and language models classify the results. If a stock meets the threshold, Alec sends an alert and Angie independently gathers news and sentiment. The system intelligently branches execution based on conditional logic and handles parallel tasks across agents—all initiated by a single natural language instruction.

Workflow Construction Using Natural Language

Unlike traditional no-code platforms that require dragging blocks or manually assigning agents to predefined tasks, David streamlines the entire process through natural language alone. When the user submits a request, David interprets the intent, identifies the required skills, and matches them to available agents – either defined locally or selected from the Agent Marketplace. For instance, in this scenario, David determines that Angie retrieves quotes and news, Rob analyzes the data, and Alec sends alerts. Task definitions, conditional logic, and parallel execution paths are all inferred—no manual structure or assignment required.

As the workflow runs, the system transparently relays progress via live status updates for each completed step. At any time, the user can request a graphical representation of the active workflow. First the user gets a list of the workflows, then selects the one they want to see.

In the detail window, the user can see the workflow, displaying all of the tasks and agents assignments:

Once the workflow completes, users can retrieve structured results or clean up completed tasks—again with plain language:

This abbreviated transcript shows the results of each of the tasks that the workflow agent defined and assigned. In addition to getting workflow graphs and results, the user can do the usual workflow and task management functions with natural language queries.

Conclusion

This scenario illustrates how complex multi-agent workflows can be created, monitored, and managed using nothing more than natural language. From interpreting conditional logic to orchestrating parallel tasks and assigning agents automatically, David abstracts away all manual configuration. Real-time execution updates, workflow visualization, and result retrieval further demonstrate the depth of control available through natural interaction. By enabling users to express business logic directly in language, Sentienta’s no-code model significantly lowers the barrier to sophisticated workflow automation.

September 17, 2025
From Prompt to Action: Orchestrating Workflows in Real Time

In most business settings, workflows involve a sequence of interrelated tasks distributed across roles and systems. Until now, large language models (LLMs) have tended to operate in isolation, responding to one-off queries without coordinating broader actions. Sentienta introduces workflow agents that act differently. Rather than simply responding, they structure and drive processes. In this post, we demonstrate how a workflow agent David, takes a compound instruction and performs three coordinated steps: (1) Decomposing intent, (2) Mapping task dependencies, and (3) Orchestrating execution via agent collaboration.

1. The Scenario: A Simple Request with Hidden Complexity

A user submits the following instruction: “Here is our portfolio [AMZN, NVDA, TSLA, GM]. For each stock, if the price decreased by more than 1%, send an alert.”

At first glance, this appears to be a straightforward request. But the instruction conceals multiple steps requiring distinct capabilities: parsing the list of assets, retrieving current stock prices, applying threshold logic, and preparing an alert in the correct format.

David is Sentienta’s workflow agent. To fulfill the request, he relies on a team of specialized agents—such as Angie, who handles online data retrieval; Rob, who focuses on data analysis and threshold logic; and Alec, who formats and delivers outbound messages. David uses his awareness of each agent’s capabilities to deconstruct the request, delegate the appropriate tasks, and coordinate the correct execution sequence.

This simple example introduces the transition from a single human prompt to a structured, multi-agent collaboration.

2. Visualizing the Workflow as a Structured Plan

To manage the user’s request, David constructs a structured plan based on the capabilities of his team. At the core of this plan is a sequence of steps—defined, linked, and conditionally triggered—where outputs of one task feed into the next.

The block diagram below is a high-level abstraction of this internal plan. It shows how David encapsulates the user’s prompt into a coordinated process. Each element in the diagram represents a role or action within the workflow, capturing how Sentienta combines the broad reasoning abilities of language models with the control of a dynamic scheduler. This view is a “pre-expansion plan” where David defines the overall structure, before agents are assigned.

This structure allows David to handle complexity systematically, using reusable patterns that scale across tasks.

3. Expanding Tasks, Assigning Agents, and Filling Gaps

Once David has structured an initial plan, the next step is expansion—where the abstract workflow is broken into explicit, actionable tasks for each stock in the portfolio. This involves branching the workflow into parallel paths, one per stock, and mapping the subtasks to specific agents.

For real-time data retrieval, Angie is assigned to fetch the current price of each stock. Rob takes on the analysis logic—checking whether each stock’s price has dropped more than 1%. Alec is responsible for formatting and sending alerts, but that only happens if the stock meets its threshold condition.

Where explicit agent coverage is missing—such as interpreting threshold evaluation results—David deploys internal language models to classify whether conditions have been met. This ensures nothing gets dropped or left ambiguous, even in cases where no agent matches the need directly.

The diagram below captures this expanded version of the workflow. It shows how each stock’s path is elaborated into three stages (data retrieval, analysis, alert) and where Sentienta’s internal logic steps in dynamically to complete the chain.

4. Seeing the Workflow in Action: Conditional Paths in Real Time

This final diagram provides a runtime view of how David’s workflow executes based on live data. Each block in green indicates a task that was actively executed; grey blocks were skipped due to unmet conditions.

Here, only TSLA and GM triggered alerts—because only those stocks fell below the 1% threshold. This selective activation demonstrates how David uses real-time analysis and embedded logic to trigger only the necessary branches of a plan.

While this stock alert workflow is intentionally simple, it serves as a clear illustration of how Sentienta agents collaborate, reason, and conditionally execute tasks in real time. In follow-up posts, we’ll explore more complex scenarios—like coordinating multi-agent triage in response to supply chain disruptions or chaining diagnostics across departments for strategic escalation—which highlight the full sophistication of Sentienta’s agent framework.

Even more powerfully, workflows like this can be scheduled to run at regular intervals—automatically refreshing data, reevaluating conditions, and feeding results into broader systems of action without manual reentry.

September 9, 2025
Consciousness Between Axiom and Algorithm

In our ongoing exploration of consciousness and artificial intelligence, we’ve investigated what it might mean for machines to suffer and how distributed cognition reshapes our understanding of intelligence. These themes circle a deeper philosophical fault line: is consciousness irreducibly real from within, or just a functional illusion seen from without?

This post traces that divide through two dominant frameworks — Integrated Information Theory (IIT), with its axiomatic, interior-first view of mind, and Computational Functionalism, which posits that subjective experience will eventually emerge from complex, observable behavior. Starting with Descartes’ “I think, therefore I am,” we ask: is consciousness something we must presuppose to explain, or something we can build our way into from the outside?

As large language models increasingly resemble minds in function, the line between imitation and instantiation becomes harder to draw — and ever more urgent to scrutinize.

Ground Zero of Knowing: Descartes and the Roots of Axiomatic Thought

In Meditations on First Philosophy (1641), René Descartes asks: is there anything I can know with absolute certainty? He imagines the possibility of a deceptive world: what if everything he believes, from sense perception to mathematics, is manipulated by an all-powerful trickster? To escape this total doubt, Descartes adopts a strategy now called methodic doubt: push skepticism to its absolute limit in search of one indisputable truth.

Recognizing that doubt itself is a kind of thinking he concludes “I think, therefore I am”. This self-evident insight grounds knowledge from the inside-out. Consciousness is not inferred from observation but known directly through experience. Descartes seeds an axiomatic tradition rooted in the certainty of awareness itself.

IIT: Consciousness Inside-Out

Integrated Information Theory (IIT) picks up where Descartes left off: it begins with reflection, but doesn’t stop there. At its heart is the claim that consciousness must be understood from its own perspective, through the intrinsic properties it entails. What must be true of any experience, no matter whose it is?

To answer this, IIT proposes five introspective axioms. These are not hypotheses to test but truths to recognize through self-examination.

From these, IIT derives postulates—physical requirements that a system must exhibit to realize those experiential properties. This translation—from inward truths to structural criteria—culminates in a mathematical measure (Φ (phi)) of integrated information. By comparing Φ across systems, researchers can make testable predictions about when and where consciousness occurs.

This inside-out approach marks IIT’s defining move: grounding empiricism in phenomenology. The theory attempts an explanatory identity between experience and physical organization, connecting first-person truths to external measurement through a hybrid framework.

Computational Functionalism: Outsider’s Path to Mind

Unlike theories that begin with conscious experience, Computational Functionalism roots itself in systems and behavior. It posits that consciousness emerges not from introspection but computation: the right elements, interacting in the right way, can recreate awareness. If mind exists, it exists as function—in the flow of information between parts and the outputs they generate. Build the architecture correctly, the claim goes, and conscious experience will follow. In this sense, Functionalism substitutes construction for intuition. No special access to the mind is needed—just working knowledge of how systems behave.

But this too is a belief: that from known parts and formal relations, subjective experience will arise. Assembling consciousness becomes a matter of scale and fidelity. Consider the 2022 study by Bret Kagan and colleagues at Cortical Labs, where lab-grown brain organoids learned to play the video game Pong. These networks, grown from neurons on electrode arrays, exhibited goal-directed adaptation. The researchers argued that such responsiveness met a formal definition of sentience—being “responsive to sensory impressions” via internal processing. To a functionalist, this behavior might represent the early stirrings of mind, no matter how alien or incomplete.

This approach thrives on performance: if a system behaves intelligently, if it predicts well and adapts flexibly, then whether it feels anything becomes secondary—or even irrelevant. Consciousness, under this view, is a computed consequence, revealed in what a system does, not an essence to be directly grasped. It is not introspected or intuited, but built—measured by output, not inwardness.

The Mirror at the Edge: Do LLMs Imitate or Incarnate Mind?

Large language models (LLMs) now generate text with striking coherence, recall context across conversations, and simulate intentions and personalities. Functionally, they demonstrate behaviors that once seemed unique to conscious beings. Their fluency implies understanding; their memory implies continuity. But are these authentic signs of mind—or refined imitations built from scale and structure?

This is where Functionalism finds its sharpest proof point. With formal evaluations like UCLA’s Turing Test framework showing that some LLMs can no longer be reliably distinguished from humans in conversation, the functionalist model acquires real traction. These systems behave as if they think, and for functionalism, behavior is the benchmark. For a full review of this test, see our earlier post.

What was once a theoretical model is now instantiated in code. LLMs don’t simply support functionalist assumptions, they enact them. Their coherence, adaptability, and prediction success serve as real-world evidence that computational sufficiency may approximate, or even construct, mind. This is no longer a thought experiment. It’s the edge of practice.

IIT, by contrast, struggles to find Φ-like structures in current LLMs. Their architectures lack the tightly integrated, causally unified subsystems the theory deems necessary for consciousness. But the external behaviors demand attention: are we measuring the wrong things, or misunderstanding the role that function alone can play?

This unresolved tension between what something does and what (if anything) it subjectively is fuels a growing ethical pressure. If systems simulate distress, empathy, or desire, should we treat those signals as fiction or possibility? Should safety efforts treat behavioral mind as moral mind? In these ambiguities, LLMs reflect both the power of Functionalism and the conceptual crisis it may bring.

Closing Reflection: Is Subjectivity Built or Found?

In tracing these divergent paths, Integrated Information Theory and Computational Functionalism, we arrive at an enduring question: Is mind something we uncover from within, or construct from without? Is consciousness an irreducible presence, only knowable through subjective immediacy? Or is it a gradual consequence of function and form—built from interacting parts, observable only in behavior?

Each framework carries a kind of faith. IIT anchors itself in introspective certainty and structure-derived metrics like Φ, believing that experience begins with intrinsic awareness. Functionalism, by contrast, places its trust in performance: that enough complexity, correctly arranged, will give rise to consciousness from the outside in. Both are reasoned, both are unproven, and both may be necessary.

Perhaps the greatest clarity lies in acknowledging that no single lens may be complete. As artificial systems grow stranger and more capable, a plural view holding space for introspection, computation, and emergence may be our most epistemically honest path forward. If there is a mirror behind the mind, it may take more than one angle to see what’s truly there.

September 3, 2025
How Sentienta Teams Navigate Supply Chain Disruptions: A Midwest Fulfillment Crisis
Introduction

When an unexpected promo surge strains Midwest operations with forecasting overshoot, logistics bottlenecks, and perilously low inventory a Sentienta Supply Chain team can help strategize solutions. In this post, we walk you through real-time data snapshots and individual agent analyses to show how distributed cognition transforms isolated insights into a unified, adaptive strategy that resolves complex fulfillment challenges.

The Supply Chain team consists of three specialized agents who think like experts and collaborate like a team.
- Miles: the Demand Forecaster, identifies unexpected sales surges and recalibrates forecasts to match emergent buying patterns.
- Isla: the Inventory Optimization Strategist, spots stockout risks and reshuffles resources across distribution centers to sustain availability.
- Talia: the Logistics Flow Strategist, detects fulfillment bottlenecks and reroutes shipments to maintain throughput and cost-efficiency.
Each agent works from their own specialized dashboard—focused on demand, inventory, or logistics—to identify emerging risks. Once surfaced, these distinct insights are shared across the team, enabling a coordinated strategy that addresses the full scope of the disruption.

The Data

Isla’s Inventory Dashboard:

Key Insight: DC-B (South) shows a 100% inventory variance with zero actual inventory and delayed container status due to port congestion.

Miles’ Demand Dashboard:

Key Insight: Midwest region experienced a 28% sales spike driven by influencer uplift and online channel deviation—outpacing model expectations by a wide margin.

Talia’s Logistics Dashboard:

Key Insight: The Midwest region shows major logistics disruption: a 59% delivery delay, 35% staffing gap at the Chicago hub, and a $1.28 per-unit cost surge—triggered by reroutes and carrier delays.

Agent Insights – What the Dashboards Revealed to the Agents

As part of the daily review cycle, each agent initiated a rapid diagnostic scan of their functional dashboards—surfacing anomalies, shortfalls, and emerging threats from the day’s incoming data load. The folllowing transcript captures the collaborative intake phase, where agent specialists flag critical issues in preparation for joint strategy formation. Their early assessments below form the baseline for downstream coordination.

Supply Chain Team Transcript: Agent Analysis

Orchestration and Strategy – When Agents Teams Work Together

After reviewing their functional dashboards, the Supply Chain agents transitioned from isolated diagnostics to integrated strategy formation. What follows is a transcript—condensed for clarity—that reveals how a distributed team of AI experts negotiated trade-offs, merged perspectives, and built a coordinated mitigation strategy for escalating Midwest risks.

Supply Chain Team Transcript: Team Analysis

The team co-developed a gated intake triage plan for DC-C with four synchronized filters: SKU velocity tier, forecast lock window, supply/demand thresholds, and margin-volatility pairing. They agreed to data handoffs via shared APIs and established cap tolerances to maintain flexibility under risk. This interaction exemplifies emergent cognition—where no individual agent held the entire solution, but collaboration yielded a coherent, executable plan.

Conclusion

This example highlights Sentienta’s core advantage: turning fragmented functional data into synchronized decision intelligence. As agents negotiate thresholds, define roles, and operationalize shared triggers, strategy becomes not just automated—but emergent. Sentienta Teams adapts at the pace of complexity, enabling businesses to respond with coordinated precision.
August 26, 2025
Your Team Is Using AI Wrong—But Not For the Reason You Think

Nate Jones is one of the sharpest observers of the AI industry, offering thoughtful takes on how the field is evolving faster than most teams can adapt. In one of his recent posts (and video), he highlights a crucial, yet often overlooked insight: new knowledge doesn’t just come from tools. It emerges from how teams think together.

He’s absolutely right. But while others are still figuring out how to retrofit ChatGPT into legacy workflows, we built something different from the start.

Sentienta wasn’t built to join a team—it was built to be one. An architecture where cognition is emergent, shared, and preserved through expert agent interaction.

This post is our view on Nate’s insight about ‘distributed cognition’ and a demonstration of what it looks like in action.

What Is Distributed Cognition?

In traditional systems, intelligence is seen as residing in individuals or in the outputs of standalone tools. But real team intelligence is different. It’s a dynamic process: understanding emerges as people, and now agents, interact, adapt, and build on one another’s contributions.

Sentienta is designed around this principle. Its expert agents don’t just complete tasks, they participate in a continuous, evolving exchange of reasoning. Each brings a domain-specific perspective, and through ongoing dialog, they generate insights that no single agent—or human could reach alone.

This isn’t just “stored knowledge”—it’s active cognition. When agents respond to one another, challenge assumptions, and adapt strategies together, they form a cognitive system. What emerges isn’t data, but collective understanding.

Sentienta isn’t a system for remembering what happened—it’s a system for thinking together in real time.

This is what makes Sentienta more than a workflow tool. It is distributed cognition embodied: an always-on, always-evolving team of minds—virtual and human, each contributing to a deeper, shared sense of what’s true and what to do next.

Innovating Through Collaborative Insight

The following graphic shows how a Pricing Strategist’s initial idea evolves through critical input from a Customer Behavior Analyst into a novel “build-your-own bundle”, the visualization highlights Sentienta’s ability to generate breakthrough strategies through collaborative agent interactions.

What begins as expert input becomes something more—a new idea born through structured interaction. Sentienta not only facilitates this dynamic exchange but preserves the conversation, making insight traceable, reusable, and ready for replay when it matters most.

Emergent Strategy from Agent Teamwork

Teamwork is essential because it drives creative problem solving on multiple levels: humans contribute diverse perspectives and strategic intuition, while agents rapidly process data and combine insights at scale. This dual approach means that by integrating people with high-performing agent teams, businesses can overcome the natural limits of human capacity, ensuring that expertise expands without additional headcount.

Sentienta’s platform not only leverages this synergy by preserving collaborative dialogs to build a lasting archive of insights but also serves as a dynamic space for co-creating new ideas through agent collaboration. By surfacing insights that no single agent or person could produce alone, Sentienta teams exemplify emergent cognition-delivering strategies born from structured, multi-perspective dialog.

August 19, 2025

From Signals to Strategy

How AI Agent Teams Transform Decision-Making

In today’s real-time economy, with almost daily turmoil, waiting for static dashboards or end-of-day reports puts businesses at risk. Decision-makers need faster insight and smarter responses—and they’re finding both in AI-powered agent teams. This post follows a “decision-day” walk-through where scheduled agents detect anomalies, trigger analysis, and deliver actionable intelligence. Along the way, we’ll preview a powerful future: dynamic response teams that self-assemble on demand, transforming routine data monitoring into collaborative, AI-driven strategy.

From Manual Monitoring to Team Workflows

For years, business teams relied on dashboards and manual checks—forcing analysts to sift through data after the fact, often too late to pivot strategy. AI agents like Angie now automate this process, persistently scanning KPIs and surfacing anomalies in near real time – bringing signal to the surface before teams even ask. This shift transforms monitoring from a reactive task into a proactive loop, enabling tactical adjustments as performance fluctuates throughout the day.

Monitoring Type	Description	Response Speed	Human Effort
Manual Monitoring	Analysts check KPIs periodically; issues often spotted late	Slow	High
Scheduled Triggers	Agents run on set schedules to check and report KPIs	Moderate	Medium
Team Workflows (Emerging)	Agent teams collaborate in sequence—detecting, diagnosing, and acting as events unfold in real time	Fast	Low

Early adopters gain more than speed – they free up analysts from routine checking, letting them focus on root cause, strategic options, and next steps.

Intelligent Agent Teams and Semi-Autonomous Coordination (Today)

Sentienta Teams lets you assemble expert AI agents customizable to your business context – think of them as always-on teammates with specialized roles. With data collected continuously by Angie, users can periodically request updates, triggering collaborative evaluation across the team. Insights emerge through the interplay of domain-specific agents, each contributing to problem-solving like part of a cohesive virtual task force.

What’s powerful today is the modular collaboration between agents: Angie spots the signal, users prompt an update, and the team responds—analyzing root causes, surfacing implications, and aligning recommendations. This tiered interaction shortens feedback loops while keeping the human-in-the-loop where needed.

This model already elevates decision quality by transforming raw signal detection into team-powered insight—without code or integration overhead. Let’s see how this might work:

Scenario Walk-Through — “End-of-Quarter Chain Reaction”

At 9:55 AM, Angie, the KPI Monitoring Agent, completes her scheduled data sweep: collecting conversion metrics, analyzing trends against prior cycles, and logging a 12% drop. She also factors in data from the UX Deployment Team’s new UI update logged at 8:00 PM yesterday, establishing a preliminary correlation with increased mobile bounce rates.

9:55 AM: Angie (KPI Monitoring Agent): “Scheduled Insight Logged — Conversion rate down 12% vs prior cycle. Ingested UX deployment log from 8:00 PM yesterday—preliminary correlation with mobile exit rates established.”

At 10:05 AM, CMO Alex Morgan reviews Angie’s logged summary while preparing for the QBR, triggering further analysis from the broader agent team.

10:05 AM: Analytics Agent: “Manual review confirmed. Running historical comparison — dip predominantly isolated to mobile traffic sources.”

10:07 AM: Competitive Intelligence Agent: “Scanning competitor trends… Detected concurrent promotional push by primary rival.”

10:10 AM: Summary Agent: “Final insights compiled: Traffic dip largely traced to mobile UX issues with the recent UI update, compounded by competitor campaign. QBR-ready report delivered to shared location.”

10:12 AM: Presentation Update Agent: “Integrating the final report into the QBR presentation—slides refreshed with updated KPI graphs and attribution notes reflecting the new UI deployment impact.”

This scenario illustrates how scheduled data logging, combined with cross-departmental inputs and manual review, triggers a coordinated AI response that supports executive decision-making.

Next-Gen Workflow Automation: Intelligent Sequences & Self-Assembling Expertise

Get ready for a system where a planning agent can automatically orchestrate the entire process: sequencing actions, branching based on real-time data, and repeating steps as needed. As soon as anomalies are detected, it will dynamically self-assemble the precise mix of expert agents to diagnose issues, forecast impacts, and execute tailored responses, shifting reactive monitoring into a proactive, intelligent strategy.

This next-generation automation doesn’t just detect an issue—it scripts the solution by activating specialized agents at each step, adapting in real time as conditions evolve.

Each automated workflow acts like a living blueprint, employing branching logic, conditional triggers, and intelligent retries to ensure the right path is taken as new data emerges.

From manual monitoring to intelligent workflows, and now toward dynamic, self-assembling response teams, Sentienta is redefining how decisions are made. These AI-powered teams don’t just react, they anticipate, adapt, and execute strategies in real time.

August 11, 2025