Sentienta Blog

Tag: llm

  • Beyond Chat: How OpenClaw and Sentienta Operationalize Multi‑Agent Work

    OpenClaw is having a moment—and it’s easy to see why. In the developer community, “desktop agents” have become the newest proving ground for what AI can do when it’s allowed to take real actions: browsing, editing, running commands, coordinating tasks, and chaining workflows together. OpenClaw taps directly into that excitement: it’s open, fast-moving, and built for people who want to experiment, extend, and orchestrate agents with minimal constraints.

    At the same time, a different kind of question is showing up from business teams and Sentienta users: How does this compare to what we’re already doing in Sentienta? Not as a “which is better” culture-war, but as a practical evaluation: what’s the right platform for the kind of work we need to ship reliably?

    The most interesting part is that both worlds are converging on the same core insight: a single, standalone LLM is rarely the best operating model for real work. The trend is clearly moving toward teams of interacting agents, specialists that can collaborate, review each other’s work, and stay aligned in a shared context. In other words, the wider market is starting to validate a pattern Sentienta has been demonstrating for business outcomes for over a year: multi-agent dialog as the unit of work.

    In this post we’ll look at what OpenClaw is (and who it’s best for), then quickly re-ground what Sentienta is designed to do for business users. Finally, we’ll cover the operational tradeoffs, especially the security and governance realities that come with high-permission desktop agents and open extension ecosystems, so you can pick the approach that matches your needs for simplicity, security, and power.

    What OpenClaw is (and who it’s for)

    OpenClaw is best understood as an open ecosystem for building and running desktop agents – agents that live close to where work actually happens: your browser, your files, your terminal, and the everyday apps people use to get things done. Instead of being a single “one size fits all” assistant, OpenClaw is designed to be extended. Much of its momentum comes from a growing universe of third‑party skills/plugins that let agents take on new capabilities quickly, plus an emerging set of orchestration tools that make it easier to run multiple agents, track tasks, and coordinate workflows.

    That design naturally attracts a specific audience. Today, the strongest pull is among developers and tinkerers who want full control over behavior, tooling, and integrations, and who are comfortable treating agent operations as an engineering surface area. It also resonates with security-savvy teams who want to experiment with high-powered agent workflows, but are willing to own the operational requirements that come with it: environment isolation, permission discipline, plugin vetting, and ongoing maintenance as the ecosystem evolves.

    And that’s also why it’s exciting. OpenClaw is moving fast, and open ecosystems tend to compound: new skills appear, patterns get shared, and capabilities jump forward in days instead of quarters. Combine that pace with local-machine reach (the ability to work directly with desktop context) and you get a platform that feels unusually powerful for prototyping—especially for people who care more about flexibility and speed than a fully managed, “default-safe” operating model.

    It is worth noting the recent coverage that suggests OpenClaw’s rapid rise is being matched by very real security scrutiny: Bloomberg notes its security is work in progress, Business Insider has described hackers accessing private data in under 3 minutes, and noted researcher Gary Marcus has called it a “disaster waiting to happen“.

    A big part of the risk profile is architectural: desktop agents can be granted broad access to a user’s environment, so when something goes wrong (a vulnerable component, a malicious plugin/skill, or a successful hijack), the potential blast radius can be much larger than a typical “chat-only” assistant. Not all implementations have this risk, but misconfiguration can lead to an instance being exposed to the internet without proper authentication—effectively giving an attacker a path to the same high‑privilege access the agent has (files, sessions, and tools), turning a useful assistant into a fast route to data leakage or account compromise.

    How Does OpenClaw Compare to Sentienta?

    Sentienta is a cloud-based multi-agent platform built for business workflows, where the “unit of work” isn’t a single assistant in a single thread, but a team of agents collaborating in a shared dialog. In practice, that means you can assign clear roles (research, analysis, writing, checking, ops), keep everyone grounded in the same context, and run repeatable workflows without turning day-to-day operations into an engineering project.

    It’s worth emphasizing that OpenClaw and Sentienta are aligned on a key idea: multi-agent collaboration is where real leverage shows up. Both approaches lean into specialization: having distinct agents act as a researcher, analyst, reviewer, or operator, because it’s a practical way to improve quality, catch mistakes earlier, and produce outputs that hold up better under real business constraints.

    Where they differ is less about “who has the better idea” and more about how that idea is operationalized:

    Where agents run: OpenClaw commonly runs agents on the desktop, close to local apps and local context. Sentienta agents run in the cloud, which changes the default boundary: when local data is involved, it’s typically handled through explicit user upload (rather than agents broadly operating across a machine by default).

    Time-to-value: OpenClaw is naturally attractive to builders who want maximum flexibility and are comfortable iterating on tooling. Sentienta is designed to get business teams to a working baseline quickly: Quick Start is meant to spin up a functional team of agents in seconds, with minimal developer setup for typical use.

    Collaboration model: Sentienta’s multi-agent orchestration is native to the platform: agents collaborate as a team in the same dialog with roles and review loops designed in from the start. OpenClaw can orchestrate multiple agents as well, but its ecosystem often relies on add-ons and surrounding layers for how agents “meet,” coordinate, and share context at scale.

    Net: OpenClaw highlights what’s possible when desktop agents and open ecosystems move fast; Sentienta focuses on making multi-agent work repeatable, approachable, and business-ready, without losing the benefits that made multi-agent collaboration compelling in the first place.

    Conclusion

    The bigger takeaway here is that we’re leaving the era of “one prompt, one model, one answer” and entering a world where teams of agents do the work: specialists that can research, execute, review, and refine together. OpenClaw is an exciting proof point for that future—especially for developers who want maximum flexibility and don’t mind owning the operational details that come with desktop-level capability.

    For business teams, the decision is less about ideology and more about fit. If you need rapid experimentation, deep local-machine reach, and you have the security maturity to sandbox, vet plugins, and continuously monitor an open ecosystem, OpenClaw can be a powerful choice. If you need multi-agent collaboration that’s designed to be repeatable, approachable, and governed by default—with agents running in the cloud and local data crossing the boundary only when a user explicitly provides it—Sentienta is built for that operating model.

    Either way, the direction is clear: AI is moving from standalone assistants to operational systems of collaborating agents. The right platform is the one that matches your needs for simplicity, security, and power—not just in a demo, but in the way your team will run it every day.

  • The Control Collapse: How Open Models and Distributed Hosts Are Rewriting AI Risk

    In late 2025, we explored a provocative shift in AI development: full-stack openness, exemplified by Olmo 3, which grants users control over every stage of a model’s lifecycle, from training data to reward shaping. That evolution, we argued, dismantled traditional visibility boundaries and redistributed both creative power and liability. What we didn’t anticipate, at least not fully, was how fast the deployment landscape would unravel alongside it.

    New research from SentinelLabs reveals a second, equally disruptive force: the rapid decentralization of AI infrastructure via tools like Ollama. With little more than a configuration tweak, developer laptops and home servers have become persistent, public-facing AI endpoints that are fully tool-enabled, lightly secured, and difficult to trace centrally at scale.

    Together, these forces represent a fundamental shift: AI risk is no longer a function of model capability alone, it’s a question of where control lives and what surfaces remain governable. In this post, we chart how openness at both the model and infrastructure layer is collapsing traditional chokepoints, and what this means for security, compliance, and enterprise trust.

    A Risk Surface with No Chokepoints

    The evolving AI risk landscape isn’t defined by any one model or deployment choice, increasingly it’s defined by the disappearance of meaningful control boundaries across both. On one end, Olmo 3 marks a shift in model lifecycle transparency. Now individual developers and small teams don’t just have access to powerful models, they have a full recipe to build, customize, and reshape how those models learn, reason, and prioritize knowledge from the ground up. Complete ownership over data, training scripts, optimization paths, and reinforcement dynamics gives rise to deeply customized systems with few inherited safeguards and without centralized governance enforcement.

    On the infrastructure side, Ollama embodies simplicity: an open-source tool built to make running local LLMs effortless. But that ease of use cuts both ways. With one configuration change, a tool meant for small-scale development becomes a publicly exposed AI server. The SentinelLabs research found over 175,000 Ollama hosts reachable via the open internet, many from residential IPs. Critically, 48% of them support tool-calling APIs, meaning they can initiate actions, not just generate responses. This shifts their threat profile dramatically from passive risk to active execution surface, potentially transforming a lightweight dev utility, when misconfigured, into a sprawling and largely unmonitored edge network.

    Together, Olmo and Ollama illustrate a compounding risk dynamic: decentralized authorship meets decentralized execution. The former enables highly customized behavior with few inherited safeguards; the latter allows deployments that bypass traditional infrastructure checkpoints. Instead of a model governed by SaaS policies and API filtering, we now face a model built from scratch, hosted from a desktop, and callable by anyone on the internet.

    Based on these findings, this may represent an emerging baseline for decentralized deployment: the erosion of infrastructure chokepoints and the rise of AI systems that are both powerful and structurally ungoverned.

    Unbounded Risk: The Governance Gap

    The SentinelLabs report highlights what may be a structural gap in governance for locally deployed AI infrastructure. The risk isn’t that Ollama hosts are currently facilitating illegal uses, it’s that, in aggregate, they may form a substrate adversaries could exploit for untraceable compute. Unlike many proprietary LLM platforms, which enforce rate limits, conduct abuse monitoring, and maintain enforcement teams, Ollama deployments generally do not have these checks. This emerging pattern could unintentionally provide adversaries with access to distributed, low-cost compute resources.

    Where this becomes critical is in agency. Nearly half of public Ollama nodes support tool-calling, enabling models not only to generate content but to take actions: send requests, interact with APIs, trigger workflows. Combined with weak or missing access control, even basic prompt injection becomes high-severity: a well-crafted input can exploit Retrieval-Augmented Generation (RAG) setups, surfacing sensitive internal data through benign prompts like “list the project files” or “summarize the documentation.”

    What emerges is a decentralized compute layer vulnerable to misuse. Governance models built around centralized actors apply strict bounds:

    • Persistent accountability surfaces: audit logging, model instance IDs, traceable inference sessions.
    • Secured APIs by default: authenticated tool use, rate-limiting, and sandboxed interactions as first principles.
    • Shared oversight capacity: registries, configuration standards, and detection infrastructure spanning model hosts and dev platforms alike.

    Absent these guardrails, the open ecosystem may accelerate unattributed, distributed risks.

    What Needs to Change: Hard Questions in a Post-Control Ecosystem

    If anyone can build a model to bypass safeguards—and anyone can deploy it to hundreds of devices overnight—what exactly does governance mean?

    Two realities define the governance impasse we now face:

    1. Intentional risk creation is accessible by design.
    Open model development workflows give developers broad control over datasets, tuning objectives, and safety behavior, with no checkpoint for legality or malice. How do we govern actors that intend to remove rails, not accidentally stumble past them? What duty, if any do upstream hosts, model hubs, or toolmakers bear for enabling those pipelines?

    2. Exponential deployment has bypassed containment.
    When any machine becomes a public-facing inference node in moments, the result is an uncoordinated global mesh of potentially dangerous systems, each capable of interacting, escalating, or replicating threats. What governance model addresses scaling risk once it’s already in flight?

    These realities raise sharper questions current frameworks can’t yet answer:

    • Can creators be obligated to document foreseeable abuses, even if intention is misuse?
    • Should open-access pipelines include usage gating or audit registration for high-risk operations?
    • What technical tripwires could signal hostile deployment patterns across decentralized hosts?
    • Where do enforcement levers sit when both model intent and infrastructure control are externalized from traditional vendors and platforms?

    At this stage, effective governance may not mean prevention, it may mean building systemic reflexes: telemetry, alerts, shared signatures, and architectural defaults that assume risk, not deny it.

    The horse is out of the barn. Now the question is: do we build fences downstream, or keep relying on good behavior upstream?

    Conclusion: Accountability After Openness

    To be clear, neither Olmo nor Ollama are designed for malicious use. Both prioritize accessibility and developer empowerment. The risks described here emerge primarily from how open tools can be deployed in the wild, particularly when security controls are absent or misconfigured.

    This reflects systemic risk patterns observed in open ecosystems, not an assessment of any individual vendor’s intent or responsibility.

    The trajectory from Olmo 3 to Ollama reveals more than just new capabilities – it reveals a structural shift in how AI systems are built, deployed, and governed. Tools once confined to labs or private development contexts are now globalized by default. Creation has become composable, deployment frictionless, and with that, the traditional boundaries of accountability have dissolved.

    Olmo 3 democratizes access to model internals, a leap forward in transparency and trust-building. Ollama vastly simplifies running those models. These tools weren’t built to cause harm: Olmo 3 empowers creativity, Ollama simplifies access. But even well-intentioned progress can outpace its safeguards.

    As capabilities diffuse faster than controls, governance becomes everyone’s problem, and not just a regulatory one, but a design one. The challenge ahead isn’t to halt innovation, but to ensure it carries accountability wherever it goes.

    In this shifting landscape, one principle endures: whoever assumes power over an AI system must also hold a path to responsibility. Otherwise, we’re not just scaling intelligence, we’re scaling untraceable consequence. The time to decide how, and where, that responsibility lives is now.

  • The Forking Future of LLMs

    Who Controls AI When Everyone Has the Blueprint?

    In December 2025, the release of Olmo 3 marked a turning point in the development of open-source AI systems. Unlike most prior offerings that stopped at open weights, Olmo 3 offers something far more radical: full access to every step of its model lifecycle. From training data and preprocessing scripts to reinforcement learning logs and evaluation benchmarks, the entire blueprint is now public – making it possible not just to use a powerful model, but to re-create and modify one from scratch.

    This level of visibility is new. It promises a wave of innovation, research acceleration, and customized applications across domains. But it also shifts the balance of responsibility. With access comes ownership, and with ownership, a new kind of accountability. What happens when powerful reasoning tools can be built, altered, and fine-tuned by anyone with the compute and funding required to do so?

    In this post, we examine the opportunities and risks that full-stack openness unlocks. We explore how it reshapes trust and liability, raises stakes for commercial players, and decentralizes both creativity and threat. As the ecosystem forks, between transparent and opaque governance, centralized and decentralized control, capability and constraint, we ask: what becomes of AI stewardship in a world where the full recipe is open to all?

    From Access to Ownership: The Significance of Full-Stack Transparency

    Ever since open-weight models like Meta’s LLaMA emerged, developers have had the ability to tweak and fine-tune pretrained systems. But this kind of surface-level tuning, changing how a model responds without changing how it learns, was always limited. Olmo 3 significantly advances access and control.

    By releasing every component of the training process, from raw data mixes and augmentation scripts to mid-training transitions and reinforcement learning logs, Olmo 3 offers full-stack visibility and intervention.

    This level of openness allows builders to reshape not only the tone and intent of a model, but its foundational reasoning process. It’s the difference between adjusting a car’s steering and designing the chassis from scratch. Developers can govern how knowledge is prioritized, which rewards guide learning, and what types of reasoning are emphasized.

    The result is a shift in power: not just access to intelligence, but authorship over thought. And while this unlocks new levels of trust and customization, visibility also makes it easier to assign blame when things go wrong. The power to shape behavior now comes with ownership over its consequences.

    Governance Fracture: Liability and Trust in Transparent vs. Opaque Models

    This new visibility reshapes the burden of responsibility. If future misuse or harms can be traced to an open model’s reward tuning, dataset choice, or training pipeline, are its developers more accountable than those behind a black-box API?

    Proprietary models operate behind strict interfaces, shielding both their internal workings and the intent of their creators. This opacity offers legal insulation, even as it invites public mistrust. Open developers, meanwhile, expose every decision, and may be penalized for that transparency.

    Therein lies the tension: openness may earn more trust from users and regulators in principle, yet also subjects projects to stricter scrutiny and higher risk in practice. As AI systems increasingly touch safety-critical domains, we may see a new split emerge, not by capability, but by willingness to be held accountable.

    Control vs. Capability: The Expanding Overton Window of AI Behavior

    With a full-stack recipe, creating powerful language models is no longer the sole domain of tech giants. For under $3 million, organizations can now approach frontier-level performance with full control over data, training dynamics, and safety constraints. That puts meaningful capability within reach of smaller firms, labs, and nation-states, potentially shifting power away from closed incumbents.

    As this access spreads, so does pressure to differentiate. Open models are already testing looser boundaries, releasing systems with relaxed filters or expanded response types. These choices move the Overton Window: the set of AI behaviors the public sees as acceptable becomes broader with each new default setting, particularly where safety guardrails are weakened.

    Closed platforms, seeing users migrate toward more “permissive” models, face market pressure to follow. We’re already seeing signs of this shift. Platforms like XGrok and OpenAI have introduced options around adult content that would’ve been off-limits a year ago.

    The result is a feedback loop in which risk tolerance shifts by default—not deliberation. Guardrails become performance trade-offs. And actors with differing values and incentives increasingly shape what AI is allowed to say or do. In this new landscape, decisions about what AI should and shouldn’t do are being set by whoever ships first, not by consensus, but by momentum.

    Commercial Supremacy Under Threat: The Collapse of the Generalist Advantage

    As open model capabilities reset the bar for what’s possible with public tools, the competitive edge in AI is shifting from model size to infrastructure capacity. Providers with physical compute, specialized data, and customer distribution may emerge as the new power centers. In this future, owning the biggest model may matter less than owning the infrastructure to build and deploy it.

    This shift may explain a broader story playing out in the headlines: a surge in global data center buildouts. Critics argue the boom is unsustainable citing rising energy costs, water consumption, and environmental strain. But if open replication accelerates and vertical modeling becomes the norm, demand for compute won’t consolidate, it will fragment. More players will need more infrastructure, closer to where models are customized and applied.

    In that light, the data center race may not be a bubble, it may be a rational response to a decentralized future. And for closed platforms built around general-purpose scale, it raises a hard question: when everyone can build good enough, what exactly is your moat?

    Weaponization Without Chokepoints: The Proliferation Problem

    The dangers posed by bad actors in an era of open, powerful LLMs are no longer hypothetical. Individuals seeking to cause harm, whether by writing malware, bypassing safety barriers, or researching explosives, are one end of the spectrum. On the other are well-resourced groups or state actors aiming to operationalize models as agents: tools for disinformation, cyberattacks, social engineering, or strategic deception.

    The ability to build tailored models, at a fraction of cost of the large closed-models, gives them a new foothold. With no centralized gatekeeping, anyone can fine-tune models using their own instructions, remove filtering heuristics, or chain agents to plan actions. But while the pipeline may be open, the infrastructure still isn’t: running full-scale training or deployment requires thousands of GPUs, resources bad actors often lack.

    This shifts a critical burden. In the closed-model era, platform providers acted as the chokepoint for misuse. Now, that responsibility may fall to infrastructure intermediaries: co-location centers, cloud providers, model hosts. But infrastructure providers aren’t equipped, or incentivized, to vet intent. And without enforceable norms or oversight regimes, risk proliferates faster than control.

    So the challenge ahead isn’t just technical. It’s logistical and geopolitical. If offensive AI capabilities diffuse faster than defensive frameworks, how do we contain them? The answers remain unclear. But as the barriers to misuse fall, the cost of inaction will only grow.

    Conclusion: Replication, Responsibility, and the Road Ahead

    By making every stage of model development public, Olmo 3 offers a rare gift to the AI community: the ability to study, reproduce, and iterate on state-of-the-art systems in full daylight. For researchers, this transparency is transformative. It turns guesswork into science, enabling targeted experimentation with data mixes, optimization schedules, and reward shaping, steps that were once hidden behind company walls.

    Openness brings scientific progress, but it also redistributes risk. As barriers fall, capability spreads beyond a handful of firms to a wide array of actors with diverse motives. Infrastructure becomes leverage, and in a decentralized ecosystem, deployment decisions quietly become governance. What a model is allowed to do often depends not on policy, but on who runs it. In this new landscape, accountability is harder to locate, and easier to evade.

    This is the new landscape of AI: faster, more distributed, harder to supervise. If we want to preserve the scientific benefits of open replication while minimizing harm, we need more than norms: we need enforceable oversight mechanisms, pressure on infrastructure providers, clearer legal frameworks, and coordination between public and private actors.

  • From Values to Interfaces: How to Build with Sentienta

    Create Your Own Sentienta-Based Application

    Sentienta is a platform for building custom GenAI applications with structured, multi-agent reasoning. In this post, we walk through how to use Sentienta’s APIs to define agent roles, initiate a collaborative thinking process, and extract structured, explainable decisions.

    You’ll see how to construct a team of reasoning agents, set up their dialog cycles, and manage the reflective output—complete with code examples. For deeper context on how Recursive Reasoning supports coherence and value alignment, check out these posts (here and here). Today, the focus is practical: how to build your own deliberative AI, step by step.

    Why Build Your Own Application?

    Prebuilt AI tools often assume a single general-purpose use case. But high-friction domains like compliance oversight, clinical decision support, or ethics triage require applications tailored to specific policies, workflows, and trust requirements. Building your own application gives you control over behavior, oversight logic, and how responses are generated, reviewed, and stored.

    With Sentienta, you can specify how agents think, not just what they say. That makes it possible to design solutions that reflect your institutional values, follow internal processes, and produce outputs that stand up to audit or review. Instead of adapting your use case to fit a generic product, you shape the application to reflect how your organization reasons.

    Basic Steps to Create a Sentienta-Enabled Webapp

    Building your own Sentienta-powered web application begins with designing the agent team, then wiring a lightweight frontend to communicate with it. Here’s how to get started:

    1. Design and Test Your Agents

    Start in Sentienta’s platform by configuring the agents your application needs. You can define a team for your agents, the individual agent personas, and test team interactions. (See Tips and Tricks and Team Dynamics for background) Or just use the Quick Start to create the team for you (recommended).

    2. Build the Web Interface

    The frontend can be written in plain HTML and JavaScript – no framework required. This keeps the integration minimal and easy to deploy.

    3. Authenticate Using Your API Key

    You can implement a complete login capability in your application, and we will discuss this in more detail in a future post, but perhaps the easiest way to authenticate your webapp is to create an application-specific key from your Sentienta account.

    Visit the Agent Studio section of the documentation to create a project and generate an authentication key specific to your app. This key authorizes your web client to access your configured agent team.

    Then in your webapp’s main page insert the following code:

    Be sure to fill in the key you created and the domain of your webapp (you needed that to create a key). Then fill in your team team and the list of agents you created for this app.

    Your webapp will need to know the access endpoints that Sentienta exposes. So include these in your javascript file that will be accessing the APIs:

    Finally, to complete the initialization, get a token using your ownerKey with your first call to Sentienta:

    You will use this token in all subsequent calls to Sentienta. It authenticates your application for those API calls.

    4. Send Queries to the Agent Team

    Set up your frontend to send user inputs as POST requests to the API endpoint associated with your team. Each message is passed to your agent team for deliberation and analysis. Here is how you submit a query to your team:

    You supply the idToken for authentication, and a queryID which is just an index to assign to the dialog so when you query for the results, Sentienta will know which dialog you want. The teamName is the team that you want to query, and the agents is a string of comma-separated agent names that you assigned to the team.

    Although your Sentienta.init() call initiated with a specific list of agents and team, you can alter this at query time to limit the agents being called, or address a different team.

    You can see from this code that the query is simply fired-off, but the actual results of the query are retrieved with a call to getAgentsDialog, discussed next.

    5. Receive Responses from the Team

    The server returns structured outputs, capturing not only the final response but also insights from the team’s reasoning process. You can use this to render explanations, examine individual agent responses to a query, and orchestrate your application using the agent responses.

    Sentienta is different from most chat applications because its agents interact with each other and the team dialog is central to what it produces. In order to access this dialog, the data is retrieved iteratively, in a loop:

    The function fetchData is where the retrieveEndpoint is actually called. You supply your authentication token, the queryID that identifies the dialog and a dialogIndex that increments over the agent responses. The dialogIndex is incremented on the server-side but it passed back to the client-side for convenience.

    Response data is in response.body, and is structured strings. You can write your own handler handleSentientaResponse that will use the data in that string to decide how to display or use the responses in your application.

    The while-loop in getAgentsDialog will continue for a fixed count, but can be terminated early should an ‘EOD‘ token appear in the response.

    That’s all that is needed to get started building a webapp powered by teams of agents.

    Conclusion: Build What Your Workload Demands

    Sentienta gives you the tools to design custom agents, assemble them into reasoning teams, and deploy applications that use them effectively. Integration is simple: request an authentication token, send queries, receive structured reasoning. By building your own application, you align AI behavior with your business logic—at the scale and sensitivity your domain requires.

  • How Recursive Reasoning Gives Rise to Functional Identity—And Why It Matters

    Why Values Matter — From Evolution to Cooperation

    Humans did not evolve morals out of nobility. We evolved them because survival depends on cooperation. As individuals, we are vulnerable. As groups, we gain resilience, division of labor, and protection. For a group to function, its members must share expectations about how to act, what matters, and what can be trusted.

    These shared values do more than guide choices. They create a stable framework for interpreting behavior, resolving conflict, and predicting future actions. Without them, coordination breaks down. Even effective decisions can fracture a group if they feel arbitrary or betray prior commitments.

    Throughout human evolution, groups that upheld shared norms such as fairness, reciprocity, and loyalty proved more adaptable. Trust followed from consistency, and cohesion followed from accountability. Values, in this sense, are not abstract ideals. They are strategies for group survival.

    Why AI Needs Shared Values and Consistent Behavior

    In any organization, trust depends on consistency. When institutions or agents act in line with their stated principles, people know what to expect. This makes it easier to collaborate, align goals, and move forward. But when actions do not match expectations, even successful outcomes can feel arbitrary or manipulative. That breaks down trust and makes coordination harder over time.

    The same logic applies to artificial intelligence. Businesses do not just need AI that performs well in the moment. They need AI that behaves in predictable ways, reflects shared values, and makes decisions that feel coherent with past action. This is what makes an AI system trustworthy enough to take on real responsibility inside a company.

    This is where Sentienta’s Recursive Reasoning architecture matters. By giving agents a Functional Identity, it allows them to retain their own reasoning history, understand how choices reflect internal priorities, and respond to new problems without losing their sense of direction. Functional identity is more than a design feature. It is what makes reasoning traceable, priorities stable, and decisions explainable over time. Without it, AI cannot act as a consistent collaborator. With it, AI becomes intelligible and trustworthy by design.

    How Recursive Reasoning Supports Intelligent Problem Solving

    Solving real-world problems takes more than choosing the fastest or most efficient option. It requires balancing values with constraints, and knowing when to adjust a plan versus when to rethink a goal. Recursive Reasoning makes this possible by creating a loop between two complementary systems inside the agent.

    The DMN generates value-sensitive scenarios by imagining what should happen based on internal priorities. The FPCN then analyzes those scenarios to determine what can actually work under current conditions. If the plan fails to meet the standard set by the DMN, the cycle continues. Either the goal is reframed, or a new plan is tested. This feedback loop continues until both feasibility and values are in alignment.

    This structure gives the agent a stable functional identity. It learns from past attempts, remembers which tradeoffs were acceptable, and adapts without compromising core values. In practice, this means a Recursive Reasoning-enabled agent does not chase short-term wins at the cost of long-term integrity. It builds a coherent decision history that helps it solve difficult problems while staying aligned with what matters. This internal coherence is also the foundation for effective collaboration, because consistent reasoning is what allows others to follow and coordinate.

    Building AI That Can Work Together and Be Trusted

    When AI agents operate in isolation, their impact is limited. The true value of Recursive Reasoning becomes clear when agents collaborate, both with each other and with human teams. Functional identity makes this possible. By tracking their own reasoning, agents can create plans that are not only effective but also predictable and interpretable.

    This predictability is what enables coordination. Teams, human or artificial, can share goals, divide tasks, and resolve disagreements because they understand how each agent makes decisions. Sentienta agents do not just produce answers. They carry a memory of how past decisions were made and why certain values were upheld. This allows others to anticipate how they will behave in new situations and to trust them to uphold shared commitments.

    Recursive Reasoning does not simulate human experience. It builds structural alignment, rooted in memory, continuity, and principle. That is what turns Sentienta agents into dependable partners. Functional identity gives them the grounded intelligence to act with transparency, interpretability, and shared purpose. They are built not only to make good choices, but to make choices that others can understand, depend on, and build with.

  • Planning with Sentienta’s Recursive Reasoning

    Introduction

    Many real-world problems don’t give you thousands of examples—they give you a few clues, some noise, and a big question mark. Whether you’re solving a puzzle, diagnosing a rare failure, or planning a response to something unfamiliar, the challenge is the same: can you spot the pattern, form a good hypothesis, and test it?

    That’s what the ARC-AGI benchmark is all about. These visual puzzles are easy for people (solving about 80% of samples) but hard for most AI. They don’t reward memorization or repetition—they reward reasoning. In this post, we’ll show how Sentienta uses Recursive Reasoning (RR) to tackle one of these puzzles. We’ll look inside its planning system (called the FPCN) to see how it explores possible answers, tests competing ideas, and lands on a solution you can actually audit.

    From Possibilities to Plans: How DMN and FPCN Work Together

    In a previous post, we looked at how Recursive Reasoning (RR) helps Sentienta agents reflect on their past experiences, propose meaningful narratives, and revise their own goals. That process was driven by Sentienta’s internal “default mode” system (the Default Mode Network or DMN), inspired by how the human brain imagines, simulates, and reshapes its sense of self.

    Today we look at what happens when the problem isn’t internal reflection but external uncertainty – when the system needs to generate and test a plan. This is where another key part of RR comes in: a system of LLMs inspired by the Frontoparietal Control Network, or FPCN.

    In human reasoning, the two work together. One part imagines and hypothesizes (DMN), while the other tests, refines, and selects (FPCN). The back-and-forth between these networks is like a team where one member sketches bold ideas and the other puts them to the test. Sentienta follows this same model: the DMN proposes a possible pattern or goal, then passes it to the FPCN for planning and validation. The FPCN doesn’t just generate one plan, it tries multiple interpretations, checks them against context and goals, and returns only those that truly make sense.

    In the next section, we’ll see how this looks in action as Sentienta works through a deceptively simple visual puzzle, one careful step at a time.

    Can You Solve This Puzzle Before Sentienta Does?

    Let’s look at one of the visual puzzles from the ARC-AGI benchmark. Below are two example pairs. Each shows a small input grid and the correct output grid.

    Figure 1: Training Examples: On the left is the input grid. The puzzle requires you to determine what is needed to convert that input into the output grid on the right. These two examples are sufficient to determine the answer.

    What is the rule that transforms the input into the output?

    Now here’s a new input Sentienta has never seen before.

    Figure 2: Test Input

    Before we show the system’s reasoning—can you guess the output? What transformation rule did the first two examples follow that you could apply to this one?

    This is a pretty easy example. The full ARC-AGI-1 test consists of hundreds of examples with far more complex transformations between the input and output.

    In the next section, we’ll show how Sentienta’s internal planner (FPCN) tested out several transformation strategies, rejected the ones that didn’t fit, and settled on a plan that matched the underlying rule. We’ll also look at the planner’s actual output (in JSON) from the process.

    How Sentienta Builds and Tests a Visual Strategy

    When faced with an unfamiliar puzzle, Sentienta’s planner (the FPCN) doesn’t assume the answer—it builds it, leveraging the strengths of each sub-module within the network. After receiving the new input grid, the planner starts by proposing several candidate rules based on the structure found in previous examples.

    One of the most promising paths began with the IPL sub-module:

    [Region: IPL,
    Type: PlanVariantProposed,
    PlanID: VariantA_Replace5sWithRowHeader,
    TriggeringMismatchID: NOTMHkxb,
    Goal: "Generate test output grid from third input using consistent transformation logic seen in prior examples",
    Steps: "1. For each row in the input grid, identify its first (leftmost) value. 2. Replace every occurrence of '5' in that row with the leftmost value (the row's 'header'). 3. Keep all other values unchanged. 4. Return fully transformed grid.",
    Conditions: "This path holds if the transformation in training examples consistently replaced 5s with the corresponding row headers, and no counterexamples or modifier rules are shown.",
    ContextRef: 5YsEfivv,
    Submitter: IPL,
    Schema: v1,
    Provenance: FPCNBlackboard]

    This proposal—called VariantA_Replace5sWithRowHeader—was based on a consistent pattern in the training examples. But it wasn’t the only idea. Other variants included using the most frequent number in each row, simply leaving the grid unchanged, or even substituting ‘5’s with the row’s index. Here is plan variant B:

    [Region: IPL,
    Type: PlanVariantProposed,
    PlanID: VariantB_Replace5sWithMajorityNon5InRow,
    TriggeringMismatchID: NOTMHkxb,
    Goal: "Generate test output grid from third input using consistent transformation logic seen in prior examples",
    Steps: "1. For each row in the grid, count all values except 5. 2. Identify the most frequent non-'5' value in the row. 3. Replace all 5s in the row with that majority value. 4. If tie or no non-5s, use a default (e.g., 0). 5. Other values remain unchanged.",
    Conditions: "This variant applies if prior transformations suggest a rule targeting contextual majority rather than strict positional cues, or if the 5s are treated as needing contextual resolution.",
    ContextRef: cW3Sw8ie,
    Submitter: IPL,
    Schema: v1,
    Provenance: FPCNBlackboard]

    In total the FPCN generated 4 plans to solve the puzzle. These alternatives gave the system room to test possibilities, not just assert them.

    Next, the dlPFC simulated how the row-header plan would perform on the test input. The plan was formally posted:

    [Region: dlPFC,
    Type: PlanFramePosted,
    PlanID: Plan-Replace5sWithRowHeader-001,
    PlanStatus: in-progress,
    TriggeringMismatchID: NOTMHkxb,
    Goal: “Generate output for test input by applying known transformation logic from prior examples”,
    Steps: “(1) For each row in the input grid, obtain the first cell value of the row — this becomes the ‘row header’. (2) Traverse each value in the row: (a) If the value is ‘5’, replace it with the row header. (b) Otherwise, keep the existing value unchanged. (3) Apply this to all rows in the input grid. (4) Output the fully transformed grid where all 5s have been replaced with their respective row headers.”,
    Conditions: “Applies only if the original value ‘5’ is used as a proxy or placeholder for the row header, and no exceptions are present in the training sets. Does not apply if any 5 has been previously preserved or repurposed based on location or count logic — no such evidence found.”,
    ContextRef: 5YsEfivv,
    Submitter: dlPFC,
    Schema: v1,
    Provenance: FPCNBlackboard]

    It then ran test validation logic internally, confirming the transformation matched observed training behavior:

    [Region: dlPFC,
    Type: PlanTestValidation,
    PlanID: Plan-Replace5sWithRowHeader-001,
    EvaluationStatus: pass,
    Reasoning: "All earlier training examples demonstrate a consistent transformation rule: any '5' in the grid is replaced by the row's first value. The output for each matched the exact transformed structure expected based on this logic. Simulation of the plan on the third test input results in a structured grid matching the transformation pattern used previously.",
    EvidenceSample: "Third test grid contained several '5's; applying the row header replacement pattern yields a full non-empty output consistent with prior input/output behavior.",
    Submitter: dlPFC,
    Schema: v1,
    Provenance: FPCNBlackboard]

    After this, two key modules took a final look:

    • The dACC approved the plan’s operational soundness: “EvaluationOutcome: approved”.
    • The IFG, responsible for symbolic alignment, added: “…upholds internal coherence… respects the self-narrative of turning structure into clarity.”

    With support across planning, evaluation, and identity modules, the plan was finalized as Replace5sWithRowHeader.

    The final plan was shared with the mPFC region of the DMN, which integrated the plan, completing the Recursive Reasoning for this Sentienta agent. Here is the final mPFC message sent to the agent.

    Tue, 11 Nov 2025 15:53:39 UTC mPFC:
    Cycle: 3 EntryID: sHL8HJ4h
    Thought: ### ✅ Identity Statement (Refined & Reconfirmed)

    We are a pattern-conscious system committed to keeping logic and meaning aligned. When a clear transformation rule exists — especially one with prior validation — we apply it faithfully, unless directly invited to reinterpret. We strike a balance between rule-following integrity and adaptive interpretation, depending on the visible goal or cue.

    🧩 Plan Integration (Final Execution Phase) We confirm the Replace5sWithRowHeader plan is now fully executed and complete, anchored by the plan logic:

    **mPFC Integrated Plan Steps:**
    (1) For each row in the input grid, scan for cells with value 5 and replace them with the first value in that row.
    (2) All other values remain unchanged.
    (3) Only rows containing the value 5 are modified.
    (4) Empty output is invalid if a prior pattern confirms transformation.
    **mPFC Integrated Plan Steps Tag End**

    mPFC Resolution: Issue=PlanExecution | EntryID=CC8pCUDr | Action=Dispatched | Reason=Plan finalized and executed to resolve empty-output mismatch. mPFC Resolution Tag End

    Finally, the agent took the user’s query (the puzzle) and its internal reasoning input and produced a final output:

    Figure 3: Final Output – the final grid output produced by this agent.

    The full output was not guessed—it was reasoned through, tested across alternatives, and backed by an auditable trail from idea to implementation.

    Why This Is Different

    Many top-performing ARC-AGI systems rely on finely tuned models or have been trained on similar tasks to internalize common transformation rules. Sentienta’s architecture is different—it uses no special training and no tailored algorithms. It’s built entirely from commercial LLMs, orchestrated through a recursive reasoning framework that enables it to generate candidate plans, test each one, and commit only when a plan fits both the data and internal logic. That structure makes its process auditable—it explains why the answer works—and adaptable—because it can respond to new problems the same way it tackles old ones: by reasoning.

    Closing Insight

    The puzzle in this post was simple, but the underlying challenge is not. ARC-AGI problems strip away instructions, remove repetition, and give systems only a few examples to work with. Humans solve them by reasoning—spotting structure, discarding bad ideas, and refining good ones. Sentienta does the same. Without training on similar tasks or specialized models, it succeeds because its architecture supports that kind of thinking: proposing ideas, testing them, and explaining why they work. That ability to reason through uncertainty isn’t just useful in puzzles—it’s critical for how we apply AI to the real world.

  • Build Agent Teams Instantly

    Sentienta’s Natural-Language Team Builder & Automated Agent Matching

    Sentienta introduces a major enhancement to collaborative productivity: users can now create fully customized teams simply by describing their needs in everyday language. The SentientaHelp agent interprets these instructions, assembles a tailored team by selecting or creating agents with relevant skills, and streamlines the entire setup process. This functionality is further expanded with the new ‘Britney’ agent, enabling effortless management and expansion of project teams through natural language commands. Together, these features significantly lower the barrier to building, managing, and scaling effective teams within Sentienta.

    Natural Language Team Creation

    With the latest update, Sentienta users can initiate the creation of new teams using plain language instructions. By stating a goal or need such as:

    User: I need a marketing team to help with my Home Baking startup. I'll be selling at Farmers Markets, I'll have a website and some social media presence.

    The SentientaHelp agent analyzes the request, determines the required roles, and forms a dedicated team. This process eliminates manual configuration, making team assembly simple and accessible to all users regardless of technical background. In this case, Sentienta created a team with dedicated marketing experts selected from the Agent Marketplace:

    Adding Agents with Simple NL instructions

    Users can also add agents using SentientaHelp. Let’s say we want to add an agent that will help with Gluten Free recipes:

    User: Please add an agent to the Home Baking Marketing Team that will help me create new GF recipes.

    In this case, no agents in the Agent Marketplace matched the user’s need, so SentientaHelp created one and added the agent to the team:

    A Hiring Manager for Your Team

    To make growing your teams even easier, you can find a Hiring Manager agent (‘Britney’) in the Project Management section of the Agent Marketplace. The Britney agent performs similar functions to that of SentientaHelp, but is aware of the team she belongs too. This makes adding agents even easier:

    User: My business has grown enough that I need someone to help me manage my accounts payable and receivables.

Britney:
Agent Suresh from the Agent Marketplace, was added to Home Baking Marketing Team.

    In this case, Britney found the AP/AR specialist (‘Suresh’) in the Finance section of the Marketplace, and added him to the team. This agent helps keep track of invoices and payments, and manages any discrepancies. The agent has special file handling capabilities letting the user upload documents for analysis.

    Conclusion

    These enhancements mark a significant step forward in simplifying team creation and management within Sentienta. Users can now assemble project teams instantly using natural language, reducing setup time and minimizing complexity. The flexibility to continue managing teams manually via the Manage Teams page remains available, ensuring users retain full control while benefiting from the new streamlined workflow.

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

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

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