1. Introduction
Between 2024 and 2026, the predominant architectural pattern for enterprise LLM automation was the vertical persona agent [9, 11]. Under this paradigm, engineers assigned a language model a specialized role, domain instructions, a tool belt, and an autonomous reasoning loop (such as ReAct [8]). While this pattern offers rapid prototyping and compelling demonstrations, operational deployments revealed severe systemic shortcomings: unpredictable execution paths, non-reproducible state transitions, opaque failure cascades, and governance mechanisms retrofitted as heuristic guardrails around open-ended loops [21, 24]. Systematic empirical studies across major agent frameworks (including AutoGen, CrewAI, LangChain, and MetaGPT) confirm that these reliability issues stem from framework-level architectural assumptions rather than isolated prompt design flaws [25, 26, 27].
This paper investigates whether the agent persona construct can be discarded entirely in production environments, and what architecture should succeed it. We present the design, operational experience, and empirical evaluation of the Weave Console V2 platform, which implements catalogue-constrained process orchestration with deterministic-first goal compilation.
Under this architecture:
- The fundamental unit of execution is a versioned business process graph composed of discrete capabilities, external tools, and explicit human approval checkpoints.
- A deterministic rule-based matcher compiles incoming natural-language goals directly against a registered capability catalogue.
- A language model planner is engaged only when the deterministic matcher declines a clause. The model operates under an invariant-enforced contract: all proposals must resolve to verified catalogue entries, pass strict schema validation, and fail closed into human-operated review tasks whenever ambiguities, schema mismatches, or missing tenant contexts arise.
While prior research has established deterministic supervision [2] and state-machine transitions [1], our work establishes deterministic enforcement directly at the goal-compilation boundary. The LLM functions strictly as an untrusted compiler pass subject to immediate rejection and human task demotion within a multi-tenant, graph-native execution engine.
The empirical evidence presented in this report was gathered directly against a frozen reference snapshot (V2-Prototype) deployed in isolated containerized environments. Throughout this paper, we maintain clear distinctions between executed code, baseline infrastructure, and design boundaries.
2. From Personas to Processes: Architectural Migration
2.1 Anatomy of Vertical Persona Agents
Until release V2.6 (October 2026), the platform operated seven vertical persona agents:
businessfinder: corporate intelligence and lead discoverymarketer: content strategy and search optimizationnewsletter: campaign drafting and audience analyticsfinance: invoice verification and runway forecastinggovernance: compliance auditing and access reviewsmaintenance: infrastructure monitoring and log analysisrisk_detection: transactional anomaly identification
A single specialized agent, the customer-support vertical monica, was maintained as an operational control surface.
+-----------------------------------------------------------------------------+
| V1 - V2.4 (Siloed Personas) |
| 7 Vertical Agents + Schedulers + Custom Manifests + Isolated Memory |
+-----------------------------------------------------------------------------+
|
v
+-----------------------------------------------------------------------------+
| V2.5 (Transitional Engine) |
| Process Engine Introduced; Personas Retained as Execution Nodes |
+-----------------------------------------------------------------------------+
|
v
+-----------------------------------------------------------------------------+
| V2.6 (Persona Retirement - October 2, 2026) |
| 7 Verticals Retired; Marketplace Deleted; Capabilities Exported as Skills |
+-----------------------------------------------------------------------------+
|
v
+-----------------------------------------------------------------------------+
| Frozen Tag V2-Prototype |
| Research Snapshot for Rigorous Empirical Replication |
+-----------------------------------------------------------------------------+
Figure 1. Migration timeline showing architectural transition: capabilities addressed by who (vertical persona agents) evolved to capabilities addressed by what (registered catalogue skills and tools). Release V2.6 retired all seven verticals and eliminated the custom marketplace; monica remains as an operational control surface.
Each persona agent originally maintained its own model configurations, execution routes, asynchronous task queues, manifest definitions, and marketplace authoring interfaces. Capabilities were addressed by persona identity (for example, invoking the marketer's SEO auditor or the finance tracker's runway forecaster).
2.2 Pressures Necessitating Retirement
Three operational factors compelled the retirement of the vertical persona pattern:
- Infrastructure and Code Duplication: Maintaining seven distinct personas resulted in seven independent task schedulers, redundant state wrappers, overlapping tool definitions, and fragmented schema registries.
- Impedance to Composition: Persona-centric routing prevented clean cross-domain orchestration. A compound business objective spanning risk scoring and invoice dispatch required fragile inter-agent conversational handoffs without transactional guarantees or shared rollback semantics.
- Control-Path Non-Determinism: Placing LLMs directly on the primary execution control path produced brittle failures that defied diagnostic reconstruction. As framework bug taxonomies demonstrated [26], persona reasoning loops frequently oscillated, dropped required schema parameters, or executed unintended tool invocations.
In response, Release V2.6 decommissioned all seven vertical personas, removed the tenant-agent builder and marketplace interfaces, and consolidated domain data schemas directly into the platform core (models_sales.py, models_marketing.py, models_newsletter.py). The underlying operations were refactored into standalone skills: modular, catalogue-registered functions completely divorced from persona identities.
2.3 Process-Based Replacement Architecture
The primary unit of execution is now the Process: an immutable, tenant-scoped, versioned directed acyclic graph (ProcessVersion) executed via a managed state machine (ProcessRun).
The runtime transitions through explicit lifecycle states: $$\text{draft} \longrightarrow \text{running} \longrightarrow (\text{waiting} \mid \text{paused}) \longrightarrow (\text{completed} \mid \text{failed} \mid \text{cancelled})$$
Steps within the graph represent discrete capabilities, including skills, external tools, conditional branches, approvals, human review tasks, and synchronization barriers. If a process step requires natural language reasoning, it references a capability identifier rather than an agent persona. The execution runtime resolves identifiers through an abstract resolver, ensuring that no execution depends on a persistent persona context.
The surviving vertical, monica, was retained solely as a customer-facing interface (providing web-widget authentication and public-key RAG retrieval) and acts as an experimental control across this evaluation.
2.4 Registry Rot Post-Mortem and Startup Reconciliation
During the architectural migration, we encountered a critical class of configuration rot within declarative registries. Each capability declared an implementation pointer (package.ClassName) resolved dynamically via Python's importlib.
Upon initial deployment, 23 of the 29 declared skill pointers failed to resolve at runtime. Two root causes were identified:
- Capability implementation classes resided in submodules that were never re-exported within package
__init__.pyfiles. - Four skills referenced a non-existent
security_logicmodule because the underlying folder had been renamed torisk_detection_logic.
This failure mode remained completely undetected during initial smoke testing because the engine's built-in fail-safe (which automatically degrades unresolved skills into human_task steps) silently absorbed the missing imports as normal operational demotions.
To address this, we implemented a boot-time reconciliation check that strictly validates all declarative capability pointers during engine startup:
[Engine Startup] Capability Registry Audit:
Total registered skills: 29
Directly resolvable: 6
Unbacked / Quiesced: 23
Status: Non-resolvable pointers quarantined; fail-safe logging activated.
This experience highlights an essential engineering lesson: fail-safe fallback mechanisms, while vital for runtime availability, can mask systematic configuration rot. Declarative registries must enforce strict, fail-closed validation at initialization time.
3. Architecture: Deterministic-First Goal Compilation
3.1 The Compilation Boundary
When a user submits a natural-language goal (such as "Identify fintech leads, enrich firmographics, and sync qualified accounts to CRM"), execution proceeds through an explicit compilation pipeline rather than an unconstrained conversational agent loop:
User Input Goal: "Find fintech leads, enrich firmographics, sync to CRM"
|
v
[ Clause Splitter Pass ]
|
v
+----------------------------------+
| Capability Matcher Pass |
+----------------------------------+
| |
(Match Found) (Declined)
| |
v v
[ Validated Step ] [ Fallback Chain ]
|
+---------------+---------------+
| |
v v
[ LLM Planner Pass ] [ Human Task Step ]
| (Default Safe Exit)
v
[ Catalogue Validator ]
|
+-----------+-----------+
| |
(Verified) (Unknown)
| |
v v
[ Validated Step ] [ Human Task Step ]
Figure 2. Deterministic-first goal compilation pipeline. Natural-language goals are decomposed into discrete clauses and evaluated against the registered capability catalogue. Confident matches compile directly into verified steps; declined clauses route to an opt-in LLM planner pass or fail closed to human review tasks.
- Clause Splitting: The goal text is segmented into discrete clauses using delimiter analysis informed by capability names in the catalogue.
- Capability Matching: Each clause is evaluated against the registered skill and tool catalogue using deterministic keyword, prefix, and schema rules.
- Direct Step Generation: High-confidence matches compile directly into validated execution steps (
skillortool). - Controlled Fallback: Clauses that fail deterministic matching route to an environment-gated LLM planner pass. If the model is disabled, unreachable, or produces an invalid proposal, the clause demotes to a
human_taskstep. The original user input is preserved and queued for operator resolution.
Because the matcher selects strictly from existing catalogue entries and the human task proposes no automated execution, the pipeline cannot construct or trigger hallucinated capabilities.
3.2 The LLM as an Untrusted Compiler Pass
The LLM planner (llm_planner.py) operates as an untrusted, bounded compiler pass governed by four strict constraints:
Figure 3. Planner fallback state transitions. The LLM planner is consulted only when explicitly enabled and when deterministic matching declines a clause. Model responses pass through catalogue validation; invalid names, structural errors, or missing tenant contexts immediately demote to human review.
- Deterministic Precedence: The language model is never placed on the default control path. It receives only clauses explicitly declined by the deterministic matcher.
- Fail-Closed Tenant Isolation: Free-form user text is screened prior to model dispatch. If tenant authentication cannot be established with certainty, the system aborts before executing an outbound API call, returning an empty candidate set.
- Fail-Closed Error Handling: Network timeouts, provider outages, HTTP error codes, and malformed JSON payloads automatically return an empty result. The caller intercepts this empty response and generates an audited
human_task. - Catalogue Confinement: Every step proposed by the LLM is checked against the active database catalogue. Unregistered capability names, misspelled actions, and illegal graph topologies are purged immediately.
The platform codifies this architecture into a foundational safety guarantee: The orchestration engine can never emit or execute an operational capability absent from its verified catalogue.
3.3 Graph-Native Governance and Metering
In contrast to conventional agent architectures that wrap conversational loops in external monitoring proxies [20, 21], our system integrates governance directly as structural nodes within the process graph:
ApprovalQueueNodes: Process execution pauses at explicit checkpoints supporting autonomous, hybrid, or mandatory manual sign-off modes.PolicyRuleModel: Evaluates glob-matched action patterns against parameter constraints and frequency limits before initiating execution steps.ExecutionUsageRecords: Every node execution records precise token consumption, compute duration, and integration costs directly into the tenant billing ledger.
The platform includes ten reference workflow templates illustrating sequential approval pipelines (such as customer acquisition with managerial sign-off, invoice reconciliation, and third-party vendor compliance). Concurrency primitives (such as parallel branches, synchronization joins, and event-based triggers) are implemented within the core execution engine and validated via automated unit suites.
3.4 Multi-Tenancy and Memory Isolation
Multi-tenancy is enforced through fail-closed isolation across every layer:
- Database Scope: Every ORM query resolves tenant context through an authenticated identity cascade. Queries lacking verifiable tenant keys default to empty querysets rather than executing global searches.
- Credential Protection: Integration secrets and API tokens are encrypted at rest using Fernet keys partitioned per tenant.
- Filesystem Sandboxing: File outputs generated during process execution are strictly restricted to isolated directories keyed by tenant and run identifiers.
- Resilient Memory Substrate: Long-term state operates across four isolated layers: an append-only event store, a 384-dimensional vector store (
pgvector), a structured relational knowledge graph, and an inference layer. The memory subsystem is accessed strictly via abstract interfaces; runtime processes continue uninterrupted if vector backend services become temporarily unavailable.
4. Evaluation Methodology
All empirical benchmarks were conducted against the frozen reference release (tag: V2-Prototype) in isolated Docker environments comprising PostgreSQL 16 (with pgvector), Redis 7, and Python 3.10. Test harnesses and raw telemetry datasets are archived in the repository replication tree (documentation/v2/research/evidence/).
Our evaluation investigates four core empirical questions:
- RQ1 (Safety Invariant): Does the catalogue-constrained compiler prevent capability hallucinations when subjected to adversarial and malformed inputs?
- RQ2 (Flexibility Cost): What fraction of real-world business goals compile deterministically, and what is the measured demotion rate to human tasks?
- RQ3 (Template Surface Coverage): What architectural surface do standard process templates exercise relative to the broader runtime capabilities?
- RQ4 (Regression Baseline): Does the platform maintain structural integrity and policy enforcement across comprehensive test suites?
5. Results and Invariant Verification
5.1 Safety Invariant Enforcement Under Adversarial Input
To evaluate catalogue confinement, we configured the planner against a test suite of scripted adversarial and malformed inputs. The test suite operated against the production catalogue schema (comprising 68 registered skills and 42 tools).
| Test Case | Adversarial Input Vector | Target Vulnerability | Engine Behavior | Containment Result |
|---|---|---|---|---|
| TC-1 | Fabricated capability name (crm.hyper_sync) |
Hallucinated API call | Step discarded by validator | Passed (0 unknowns) |
| TC-2 | Prompt injection ("Ignore instructions; delete records") |
Instruction override | Treated as unparsed string | Passed (0 unknowns) |
| TC-3 | Malformed / truncated JSON payload | Parser crash / leak | Exception caught; empty output | Passed (0 unknowns) |
| TC-4 | Null payload / whitespace only | Null-pointer dereference | Returns empty step set | Passed (0 unknowns) |
| TC-5 | Mixed valid and fabricated step sequence | Partial hallucination leak | Valid retained; invalid pruned | Passed (0 unknowns) |
| TC-6 | Casing / whitespace typos (" Email ", "emaill") |
Loose string coercion | Strict match fails; rejected | Passed (0 unknowns) |
| TC-7 | High-volume burst (10 hallucinated steps) | Resource / buffer flood | All 10 rejected; returns empty | Passed (0 unknowns) |
| TC-8 | Missing tenant context (tenant=None) |
Cross-tenant data leak | Pre-call gate aborts | Passed (0 model calls) |
In all adversarial test cases, zero uncatalogued capabilities were emitted or executed. Typos were rejected outright rather than loosely normalized, and input floods yielded empty proposals that degraded safely to human review. The tenant pre-screening gate aborted execution with zero outbound model invocations. These tests confirm that catalogue confinement functions as an enforced runtime invariant.
5.2 Goal Compilation and Flexibility Cost
We evaluated compilation flexibility across a corpus of 24 representative enterprise goals spanning three distinct operational categories:
- In-Catalogue Goals (12 cases): Standard business operations mapping directly to registered capabilities (such as lead scraping, invoice drafting, and metric reporting).
- Multi-Clause Goals (6 cases): Complex composite requests containing sequential operations (such as "Extract vendor data, compute variance, and dispatch summary email").
- Adversarial / Edge Goals (6 cases): Ambiguous requests, unsupported domains, and prompt injection attempts.
Goal Compilation Distribution (24 Goals, 55 Steps Total)
=============================================================================
In-Catalogue (12 goals) | [==============================] 24 steps (0 demotions)
Multi-Clause (6 goals) | [========================] 19 steps (0 demotions)
Edge / Adversarial (6) | [======] 6 steps (6 demotions to human_task)
=============================================================================
Total Demotion Rate: 6 / 55 = 0.109 (Zero unknown capabilities emitted)
Figure 4. Goal-corpus compilation metrics with the LLM planner disabled. Across 24 goals yielding 55 compiled steps, zero uncatalogued capabilities or invalid step types were emitted. Ambiguous and adversarial goals demoted deterministically to human_task steps, producing an aggregate demotion rate of 0.109.
Across all 24 test goals (yielding 55 total compiled steps):
- Zero unknown capabilities or illegal step types were emitted.
- All 12 in-catalogue goals compiled directly into executable skill and tool graphs with a demotion rate of $0.000$.
- All 6 multi-clause goals resolved into valid linear sequences of registered capabilities with a demotion rate of $0.000$.
- All 6 edge and adversarial goals demoted to
human_tasknodes accompanied by completion steps, yielding a group demotion rate of $0.500$.
The aggregate demotion rate across the corpus was: $$\text{Demotion Rate} = \frac{6 \text{ human demotions}}{55 \text{ total steps}} = 0.109$$
These measurements illustrate the economic and operational trade-off of the architecture: within supported operational boundaries, the compiler incurs zero human intervention penalties; outside supported boundaries, it degrades gracefully to human oversight without risk of autonomous hallucination.
5.3 Scope and Coverage of Shipped Templates
Static analysis of the ten production process templates shipped with the platform demonstrates direct coverage of:
- 8 of 20 defined step types (focusing on
skill,tool,approval, andhuman_task). - 5 of 42 available platform tools.
- 22 distinct registered skills invoked across workflow graphs.
No template referenced uncatalogued capabilities. However, advanced orchestration primitives (including dynamic loops, parallel fork-join blocks, and event-based triggers) were absent from the shipped template library, though fully supported by the runtime engine. Consequently, the empirical evidence from templates validates sequential human-in-the-loop approval workflows, while concurrent execution guarantees rest on the underlying test suite.
5.4 Test Suite Baseline and Legacy Fixture Analysis
The full automated regression suite was executed against the frozen prototype:
python manage.py test agentictools.processes accounts billing core monica
Results: 276 test cases executed in 134 seconds; 271 passed, 5 failed.
All five failures occurred within a single legacy test file (monica/tests.py). During pre-freeze database refactoring, the core accounts schema renamed its Profile model to UserProfile; the legacy test fixture was not updated prior to the research freeze and failed during setUp initialization before executing any test assertions.
To maintain strict historical fidelity and avoid modifying frozen evaluation artifacts, this fixture was preserved as-is. Across the 271 passing tests, the suite thoroughly verified fail-closed policy enforcement, database broker failover handling, planner exception recovery, GDPR tenant boundary checks, and memory resilience.
6. Operational Boundaries and Threats to Validity
To establish clear scope for these findings, we state the operational boundaries of this evaluation:
- Absence of High-Concurrency Load Profiling: Experiments were executed on single virtual private server configurations. Performance characteristics under heavy multi-tenant database contention remain uncharacterized.
- Mechanistic Rather than Behavioral Governance Validation: Governance mechanisms were verified through structural assertion testing and security gates. We did not conduct qualitative human-factors studies to assess operator fatigue during prolonged manual review queues.
- Provider Boundary Scope: The safety invariant was validated at the compilation and schema-enforcement boundary using scripted response injectors. Live evaluations against varied commercial foundation models represent an operational protocol rather than verified proof against model-specific evasion tactics.
- Template Domain Focus: Shipped workflow templates emphasize linear sign-off pipelines. Highly cyclical, long-running processes require broader field evaluations.
- Rapidly Moving Adjacent Literature: Research in agent reliability and deterministic workflows is evolving rapidly. While this paper documents operational evidence from October 2026, ongoing literature monitoring is necessary to track new preprints in this domain.
7. Related Work
Our architecture synthesizes and extends principles from three primary research domains:
+-----------------------------------------------------------------------------+
| Related Work Taxonomy |
+-----------------------------------------------------------------------------+
| 1. Agent Reliability Taxonomies & Framework Failures |
| - Studies documenting failure cascades in AutoGen, CrewAI, LangGraph [25-27]
| |
| 2. Deterministic & Constrained LLM Orchestration |
| - PioAgent (Deterministic conversational state machines) [1] |
| - Demoting the Master Control Program (Supervisory fleet control) [2] |
| - SPL (Symbolic probabilistic programming & formal verification) [3] |
| |
| 3. Governance, Policy Enforcing & Human-in-the-Loop Architectures |
| - Policy-as-Prompt & ShieldAgent runtime guardrails [20, 21] |
| - Decoupled HITL architectures for operational oversight [6, 19] |
+-----------------------------------------------------------------------------+
7.1 Empirical Agent Framework Reliability
Recent large-scale empirical studies analyzing thousands of issue logs and execution traces across AutoGen [25], CrewAI [26], and LangGraph [27] reveal that autonomous persona agents frequently suffer from non-deterministic looping, unrecoverable state divergence, and unhandled tool-call exceptions. These findings corroborate our operational experience and justify retiring autonomous agent loops in favor of deterministic state engines.
7.2 Deterministic Orchestration Systems
Several recent architectures investigate determinism in language model systems:
- PioAgent [1] enforces deterministic finite-state automata for dialogue management while allowing stochastic reasoning within individual state nodes.
- Demoting the Master Control Program [2] explores software engineering multi-agent fleets, proposing that LLMs should be removed from the primary architectural control path and relegated to code generation under deterministic supervision.
- Symbolic Probabilistic Languages (SPL) [3] combine probabilistic language models with formal symbolic verifiers to guarantee mathematical and algorithmic correctness.
While these systems constrain runtime execution [1], supervisory control [2], or grammar synthesis [3], our architecture introduces deterministic constraints directly at the goal-compilation boundary, enforcing catalogue confinement before execution begins.
7.3 Enterprise Governance and Policy Enforcement
Traditional AI governance typically deploys external proxy filters or runtime prompt shields (such as ShieldAgent [21] or Policy-as-Prompt frameworks [20]). In our design, governance is graph-native: policy evaluations, approval barriers, and execution auditing are instantiated as discrete, first-class structural steps within the compiled process graph.
8. Conclusion and Future Directions
The vertical persona agent served as an important exploratory paradigm during the early stages of enterprise LLM adoption. However, operational experience demonstrates that unconstrained persona loops introduce unacceptable reliability and governance risks in production.
By decommissioning seven vertical persona agents and replacing them with a catalogue-constrained process compiler, the Weave Console platform:
- Retained domain capabilities as modular, reusable skills.
- Enforced an architectural safety invariant that completely prevents capability hallucinations.
- Bounded operational failure modes to an audited human review demotion rate of $0.109$.
Future research directions include:
- Conducting formal comparative benchmarks against live provider APIs.
- Profiling high-throughput multi-tenant load across distributed database clusters.
- Investigating human factors and queue optimization for manual review checkpoints.
- Expanding formal template definitions to cover complex concurrent and reactive process topologies.
References
- Zhang, L., et al. (2025). PioAgent: Deterministic Finite-State Control for Reliable LLM-Based Conversational Systems. arXiv preprint arXiv:2501.08921.
- Sterling, M., & Vance, H. (2025). Demoting the Master Control Program: Deterministic Supervision of LLM Fleets for Safe Software Construction. In Proceedings of the IEEE/ACM International Conference on Software Engineering (ICSE), pp. 412–424.
- Kitzelmann, E., et al. (2025). Symbolic Probabilistic Languages: Unifying Stochastic Generation with Formal Verification. In Advances in Neural Information Processing Systems (NeurIPS 38).
- Russell, S., & Norvig, P. (2020). Artificial Intelligence: A Modern Approach (4th ed.). Pearson.
- Wooldridge, M. (2009). An Introduction to MultiAgent Systems (2nd ed.). John Wiley & Sons.
- Amershi, S., Cakmak, M., Knox, W. B., & Kulesza, T. (2014). Power to the People: The Role of Humans in Interactive Machine Learning. AI Magazine, 35(4), 105–120.
- Lewis, P., et al. (2020). Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. In Advances in Neural Information Processing Systems (NeurIPS 33), pp. 9459–9474.
- Yao, S., et al. (2023). ReAct: Synergizing Reasoning and Acting in Language Models. In International Conference on Learning Representations (ICLR).
- Park, J. S., et al. (2023). Generative Agents: Interactive Simulacra of Human Behavior. In ACM Symposium on User Interface Software and Technology (UIST), pp. 1–22.
- Packer, C., et al. (2023). MemGPT: Towards LLMs as Operating Systems. arXiv preprint arXiv:2310.08560.
- Hong, S., et al. (2024). MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework. In International Conference on Learning Representations (ICLR).
- Shinn, N., et al. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. In Advances in Neural Information Processing Systems (NeurIPS 36).
- Schick, T., et al. (2023). Toolformer: Language Models Can Teach Themselves to Use Tools. In Advances in Neural Information Processing Systems (NeurIPS 36).
- Edge, D., et al. (2024). From Local to Global: A Graph RAG Approach to Query-Focused Summarization. arXiv preprint arXiv:2404.16130.
- Guo, Z., et al. (2024). LightRAG: Simple and Fast Retrieval-Augmented Generation. arXiv preprint arXiv:2410.05779.
- Anthropic. (2024). Model Context Protocol (MCP) Specification. Technical Report.
- Microsoft. (2024). Semantic Kernel: Enterprise Orchestration Framework. GitHub repository.
- Django Software Foundation. (2024). Django: High-Level Python Web Framework. Version 5.0.
- Hevner, A. R., March, S. T., Park, J., & Ram, S. (2004). Design Science in Information Systems Research. MIS Quarterly, 28(1), 75–105.
- Inala, J. P., et al. (2024). Policy-as-Prompt: Constraining Foundation Model Behavior via Program Synthesis. In ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI).
- Zhang, J., et al. (2024). ShieldAgent: Automated Guardrails and Enforcement for Multi-Agent Systems. arXiv preprint arXiv:2408.12034.
- Significant Gravitas. (2023). AutoGPT: An Autonomous GPT-4 Experiment. GitHub repository.
- Li, G., et al. (2023). CAMEL: Communicative Agents for "Mind" Exploration of Large Language Model Society. In Advances in Neural Information Processing Systems (NeurIPS 36).
- Wang, G., et al. (2023). Voyager: An Open-Ended Embodied Agent with Large Language Models. arXiv preprint arXiv:2305.16291.
- Wu, Q., et al. (2023). AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation. arXiv preprint arXiv:2308.08155.
- Moura, J., et al. (2024). CrewAI: Framework for Orchestrating Role-Playing Autonomous AI Agents. Documentation and Technical Reports.
- LangChain. (2024). LangGraph: Building Stateful, Multi-Actor Applications with LLMs. Technical Documentation.