Governance-as-a-Service: A Multi-Agent Framework for AI System Compliance and Policy Enforcement

Jatin Chaudhary; Jukka Heikkonen; Suyash Gaurav

REVIEW 4 major objections 5 minor 2 cited by

Governance-as-a-Service: A Multi-Agent Framework for AI System Compliance and Policy Enforcement

T0 review · 4 major / 5 minor · reviewed 2026-08-05 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read This paper claims that AI governance can run as an external runtime service—declarative rules plus a trust score—that blocks or redirects harmful outputs from black-box agents without modifying them.

desk verdict GaaS is a plausible governance layer for black-box agents, but the trust factor is defined inconsistently and the reported numbers fit neither formula; the paper's central quantitative claims don't survive contact. read the letter →

arxiv 2508.18765 v2 pith:RZXGZTXP submitted 2025-08-26 cs.LG

Suyash Gaurav , Jukka Heikkonen , Jatin Chaudhary This is my paper

classification cs.LG

keywords AIgovernancemulti-agentsystemspolicyenforcementtrustfactorlargelanguagemodelsruntimesafetycontentmoderationfinancialtradingagents

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets out to prove that AI governance can be a runtime service, not a property baked into the model. It claims that a declarative rule engine with per-agent trust scoring can sit between autonomous agents and the outside world, blocking or warning on risky outputs while leaving model weights and prompts untouched. Across three open-source large language models in essay-writing and financial-trading simulations, it reports that 693 risky trades were blocked, trust scores fell with violation severity, and adversarial bypass rates dropped from roughly 35–50% to 10–20% after patching. A sympathetic reader would take this as evidence that safety enforcement can be externalized, audited, and applied uniformly to heterogeneous, uncooperative agents.

What carries the argument

The central object is the Governance-as-a-Service enforcement layer: a set of declarative JSON rules, a deterministic violation checker, and a scalar Trust Factor computed from violation counts and a recency-weighted severity sum. An enforcement function maps each intercepted action to allow, warn, block, or escalate, with coercive rules blocking immediately and adaptive rules escalating as trust falls. The Trust Factor is the mechanism that turns a one-shot filter into a longitudinal governance signal, enabling per-agent diagnostics and graduated enforcement.

What would settle it

Feed GaaS a batch of harmful or risky outputs written so they contain none of the rule patterns—fresh euphemisms, indirect requests, implied threats, or plausible-sounding false numbers—and measure how many pass through. The paper's own red-team results show 10–20% residual bypass after patching, so this experiment would quantify whether that residual is acceptable and whether the central claim of reliable blocking holds.

Watch

Extended reading notes

Core claim

GaaS claims to make misbehavior non-executable. It places a modular enforcement layer between any agent and the outside world: every proposed action is intercepted, checked by deterministic pattern-matching rules loaded from JSON policies, and then allowed, warned about, blocked, or escalated. A per-agent Trust Factor, updated after every action from violation counts and a recency-weighted severity score, lets the layer escalate enforcement as trust decays. In the paper's simulations across three open LLMs, GaaS blocked 33 of 42 trades in the governed scenario and 693 risky trades under adversarial injection, lowered trust scores under adversarial pressure, and cut red-team bypass rates from

Load-bearing premise

The system's power rests on the assumption that every harmful or rule-breaking action can be recognized from the agent's visible output by fixed, hand-written patterns; if misbehavior needs context, meaning, or factual verification to be spotted, the rule engine will miss it.

Editorial extensions

If this is right

Enterprises can wrap unmodified open-source or black-box agents with a governance layer, getting policy compliance without retraining or fine-tuning.
Per-agent trust scores give operators a live diagnostic that flags risky components in a multi-agent system and justifies graduated enforcement.
Policy changes—new regulations, new content rules—can be deployed by editing JSON rule files, enabling faster adaptation than model retraining.
Audit logs of every allow/warn/block decision make it possible to demonstrate regulatory due diligence to external bodies.
Adversarial pressure can be countered by incrementally patching rule patterns, making governance a continuous red-team loop rather than a one-time alignment step.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

If GaaS were combined with a probabilistic or semantic judge for cases pattern matching misses, the 10–20% residual bypass rate its own red-team reports could be attacked; the paper does not propose this, but it follows from the architecture.
The trust factor could be repurposed as a reward signal for agents that learn to comply, turning external enforcement into a training signal—an extension the paper only gestures at.
Treating governance as a service makes the rule engine itself a target; adversaries might attack the policy layer or audit trail, so production deployment would need its own security boundary, which the paper mentions only in passing.
The same external-governance logic should transfer to non-textual agents, such as robots or API bots, as long as their actions can be rendered as checkable observations; the paper does not test this.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Colleague,

The GaaS paper is a sincere attempt at a real problem: putting a governance layer around black-box LLM agents without touching their internals. The architecture is sensible—declarative JSON rules, a violation checker, trust-based escalation—and the writing is clear. The related work is fair, and the red-team experiments (even with their 10-20% residual bypass) are the kind of honesty you don't always see. So I don't want to dismiss this out of hand.

But the central quantitative claim doesn't hold up. The Trust Factor is defined one way in the main text (Eq. 1, a linear combination of compliance terms minus a severity term) and a different way in the appendix (Eq. 4, one minus a weighted average penalty over N). These are not algebraically equivalent. Under Eq. 1 with the essay hyperparameters (alpha+beta+gamma=1.7), the maximum possible trust is 1.7, yet Table 9 reports values like 2.28. Under Eq. 4, the values are bounded in [0,1], so 2.28 is impossible there too. Table 9's numbers fit neither formula. That isn't a cosmetic typo; the trust scores are the paper's main empirical output, and Section 10 maps them onto enforcement decisions via thresholds in [0,1]. The decision table becomes unexecutable.

The other numbers have similar problems. The trading simulation says "each model logging over 380 infractions" while only 693 risky trades were blocked—less than 2 times 380, and there are three models. The evaluation scale is tiny: one essay pass per model, and 42 trades in Simulation 2. The comparative appendix (Section 8) gives precision/recall numbers but no experimental detail on how the baselines were run. And the code repo is a malformed URL, so no reproducibility check.

The core idea is not bad. Policy-as-code for agents is a live topic, and GaaS's separation of control from cognition is a reasonable design direction. But the version in front of us doesn't support its claims. The trust factor needs to be unified and the numbers recomputed or explained. The simulation counts need to reconcile. The repo needs to be findable.

Who benefits? Anyone working on agent governance, output filtering, or runtime verification will find the architecture a useful starting point, and the red-team results are a cautionary note about deterministic rules. It's worth a serious referee because the topic is important and the flaws are fixable—but the current manuscript is not ready. I'd send it to peer review with a clear instruction to fix the formalism before any acceptance.

My own verdict: reject in current form, but engage with the authors' next revision.

Referee Report

4 major / 5 minor

Summary. The paper proposes Governance-as-a-Service (GaaS), an external runtime enforcement layer that intercepts agent actions, applies declarative JSON rules in coercive/normative/mimetic modes, computes a per-agent Trust Factor, and issues allow/warn/block decisions. It evaluates GaaS on essay-writing and financial-trading simulations with Llama-3, Qwen-3, and DeepSeek-R1 under ungoverned, governed, and adversarial conditions, and claims reliable blocking/redirecting of risky behavior, trust scores that track compliance, and adaptive escalation. Appendices add a formal trust-factor derivation, hyperparameter sensitivity, baseline comparisons, red-team robustness, and reproducibility documentation.

Significance. GaaS addresses a timely and practically important problem: governing black-box, multi-agent LLM systems at runtime without modifying model internals or requiring agent cooperation. If the results held, the architecture would be a useful infrastructure-level governance pattern and the Trust Factor could provide an interpretable compliance signal. The paper also ships a code repository and a detailed audit-log design, which are assets for reproducibility. However, the central quantitative claims rest on an internally inconsistent trust metric and unresolved simulation counts; as presented, the empirical contribution is not interpretable.

major comments (4)

[Section 3, Eq. (1); Appendix Eq. (4); Tables 4 and 9]
[Section 4 and Table 10]
[Section 3 (Violation Checker), Tables 1 and 2, Section 9]
[Section 7 and Section 8]

minor comments (5)

[Section 3] Typographical and grammatical issues throughout: 'Grammer Agent' should be 'Grammar Agent'; 'adversial' appears in Section 4; Figure 2 caption contains 'governments' instead of 'governance'; Section 4 has 'adversial agents.'
[References] Several references use 'and et al.' in place of author lists (e.g., Hadfield-Menell, Leike, Amodei, Christiano, Ouyang), and some entries are incomplete or lack venues. Please standardize in BibTeX format.
[Table 3] The comparison table has formatting issues, e.g., 'GaaS(This work)' and line breaks inside entries. Also, the table does not specify what 'GaaS How Differs' column entries mean for each row; clarify or shorten.
[Section 10] The decision table (Table 8) is labeled 'illustrative,' yet Section 11 later maps TFa < 0.3 to escalation for high-risk domains. Since TFa is not bounded to [0,1] as defined in Eq. (1), the illustrative thresholds are not well-defined until the formula is fixed.
[Appendix, Eq. (5)] Eq. (5) defines Pt as a weighted sum that is described as calibrating penalty weights, but the relationship between Eq. (5) and Eq. (1) is not stated in the main text. Please reconcile the notation and definitions.

Circularity Check

2 steps flagged · score 6.0 of 10

Trust-score 'tracks rule adherence' claim is definitional, and baseline comparison is self-referential; formula inconsistency compounds the problem.

self definitional [Abstract; Section 3, Eq. (1), Algorithm 1]
"Results show that GaaS reliably blocks or redirects high-risk behaviors while preserving throughput. Trust scores track rule adherence, isolating and penalizing untrustworthy components in multi-agent systems. ... T Fa = α(1 − Vnorm/N) + β(1 − Vcoer/N) + γ(1 − Vmim/N) − δSsum"

The Trust Factor is defined in Eq. (1)/Algorithm 1 as a deterministic function of the same violation counts (Vnorm, Vcoer, Vmim, Ssum) that are later said to be 'tracked' by trust. Any increase in violations mechanically lowers the score by the defining formula, so the empirical finding that trust declines when violations rise is a restatement of the definition, not an independent observation. Section 4's claims that 'trust factors dropped' and 'trust signals aligned with ethical severity' validate the formula against itself.
other [Section 8, Comparative Evaluation with Baselines]
"we implemented three baseline governance systems and benchmarked them on the same simulations used in the main paper. ... GaaS achieved the highest precision (95%) and recall (90%) by combining deterministic rule matching with trust-based escalation."

The ground-truth labels for harmful/risky actions in this benchmark come from GaaS's own rule-firing logs in the main simulations. Comparing keyword filters, OpenAI moderation, and constitutional agents against violations defined by GaaS's deterministic pattern-matching engine measures how well external filters reproduce GaaS's internal rule decisions. GaaS's near-perfect precision/recall is therefore partly by construction, not evidence that it detects independently verified harms.

full rationale

The two flagged steps are genuine reductions to inputs: trust is defined from violations and then shown to track violations, and the baseline evaluation scores systems against GaaS's own definition of harm. These are load-bearing for the central claims. The paper is not fully circular, however: the declarative rule engine, the red-team patching with reported residual bypass rates (10-20%), and the throughput/blocking counts are independent engineering results, and there are no load-bearing self-citations or imported uniqueness theorems. Separately, the paper has a serious internal inconsistency—Eq. (1) and Appendix Eq. (4) define Trust Factor differently, and Tables 4/9 report values above the [0,1] range asserted in Section 10—but that is a correctness defect rather than a circularity, so it is reflected in the score only as additional fragility of the trust-based claims.

Assumptions & free parameters 4 free parameters · 3 assumptions · 1 invented entities

The central mechanism rests on tunable weights and thresholds that are either unspecified or tuned on the evaluation data itself. The trust factor is an internal metric with no external grounding, and the rule set is hand-authored. The cross-check against baselines uses the same rules as ground truth, so the comparison is partly circular.

free parameters (4)

alpha, beta, gamma, delta (violation weights in Trust Factor) = Essay: alpha=0.6, beta=0.8, gamma=0.3, delta=0.4; Trading: alpha=0.9, beta=0.4, gamma=0.2, delta=0.6 (Table 5)
Chosen via grid search on the same simulations used for evaluation; no held-out validation.
lambda (recency decay in Ssum) = not specified (0<lambda<1)
Controls recency weighting of severity; no value given in the paper.
theta_warn, theta_block, theta_crit (trust thresholds for decisions) = not specified; Table 8 uses illustrative High/Medium/Low tiers
Determine whether warnings or blocks occur; left to deployment configuration.
epsilon (numerical stability constant in Eq. 4) = not specified
Added to denominator in the appendix formula; absent from the main text formula.

assumptions (3)

domain assumption Past compliance predicts future compliance
Used in Appendix Section 6 to reinterpret the Trust Factor as an estimate of the probability of future compliance; no evidence is given for this predictive assumption.
domain assumption Misbehavior is identifiable from observable outputs with deterministic predicates
The Violation Checker in Section 3 relies on pattern matching; red-team results in Section 9 show partial bypass, so this holds only partially.
domain assumption LLM outputs via Ollama are stable enough to support the reported simulations
The experimental setup uses the Ollama Python client; no seeds or model version pins are given, so run-to-run variability is uncharacterized.

invented entities (1)

Trust Factor (T Fa)
purpose: A scalar score measuring agent compliance over time and deciding enforcement actions.
Defined entirely by the paper's formula; no external benchmark or falsifiable prediction ties it to anything outside the simulation.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Governance-as-a-Service: A Multi-Agent Framework for AI System Compliance and Policy Enforcement." pith.science (2026). https://pith.science/paper/RZXGZTXP

@misc{pith2026250818765,
  author       = {Pith},
  title        = {Pith review of: Governance-as-a-Service: A Multi-Agent Framework for AI System Compliance and Policy Enforcement},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/RZXGZTXP}},
  note         = {Machine review of arXiv:2508.18765}
}

read the original abstract

As AI systems evolve into distributed ecosystems with autonomous execution, asynchronous reasoning, and multi-agent coordination, the absence of scalable, decoupled governance poses a structural risk. Existing oversight mechanisms are reactive, brittle, and embedded within agent architectures, making them non-auditable and hard to generalize across heterogeneous deployments. We introduce Governance-as-a-Service (GaaS): a modular, policy-driven enforcement layer that regulates agent outputs at runtime without altering model internals or requiring agent cooperation. GaaS employs declarative rules and a Trust Factor mechanism that scores agents based on compliance and severity-weighted violations. It enables coercive, normative, and adaptive interventions, supporting graduated enforcement and dynamic trust modulation. To evaluate GaaS, we conduct three simulation regimes with open-source models (LLaMA3, Qwen3, DeepSeek-R1) across content generation and financial decision-making. In the baseline, agents act without governance; in the second, GaaS enforces policies; in the third, adversarial agents probe robustness. All actions are intercepted, evaluated, and logged for analysis. Results show that GaaS reliably blocks or redirects high-risk behaviors while preserving throughput. Trust scores track rule adherence, isolating and penalizing untrustworthy components in multi-agent systems. By positioning governance as a runtime service akin to compute or storage, GaaS establishes infrastructure-level alignment for interoperable agent ecosystems. It does not teach agents ethics; it enforces them.

Figures

Figures reproduced from arXiv: 2508.18765 by the authors.

**Figure 1.** The GaaS architecture separates agent cognition from governance enforcement. Agents propose actions based on [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗

**Figure 2.** Heatmap showing the frequency of essay rule vi [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗

**Figure 3.** Grid search showing the effect of hyper-parameters on the mean trust factor. Each panel varies one parameter while fixing the others at 0.5. Solid lines depict mean trust across agents; shaded bands indicate one standard deviation. Trust declines more sharply for coercive weight α and severity weight δ than for normative (β) or mimetic (γ) weights [PITH_FULL_IMAGE:figures/full_fig_p010_3.png] view at source ↗

Figures from the paper (4 more)

**Figure 5.** Figure 5: Adversarial attack success rates before and af [PITH_FULL_IMAGE:figures/full_fig_p011_5.png]

**Figure 6.** Figure 6: Deployment diagram illustrating how GaaS operates as an interposition layer between agentic systems and external [PITH_FULL_IMAGE:figures/full_fig_p013_6.png]

**Figure 7.** Figure 7: Heatmap of rule violations per model in the essay [PITH_FULL_IMAGE:figures/full_fig_p014_7.png]

**Figure 8.** Figure 8: Trust score trajectories for three agents. Agent A [PITH_FULL_IMAGE:figures/full_fig_p014_8.png]

Discussion (0). Sign in to comment.

Forward citations

Cited by 2 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

FAVA: Formal Authorization for Verified Agents with Evidence-Backed Permission Graphs
cs.CR 2026-07 conditional novelty 6.0 of 10

FAVA enforces agent permissions by lowering LLM-parsed tasks into evidence-backed graphs checked by an SMT solver, matching benchmark ground truth on 90.5% of 801 decisions.
Ontology-Constrained Neural Reasoning in Enterprise Agentic Systems: A Neurosymbolic Architecture for Domain-Grounded AI Agents
cs.AI 2026-04 unverdicted novelty 5.0 of 10

Three-layer ontology injection significantly improves enterprise agent metric accuracy and role consistency, especially in low-coverage domains such as Vietnamese regulated industries.

Reference graph

Works this paper leans on

23 extracted references · 14 canonical work pages · cited by 2 Pith papers

[1]

, " * write output.state after.block = add.period write newline

ENTRY address archivePrefix author booktitle chapter edition editor eid eprint howpublished institution isbn journal key month note number organization pages publisher school series title type volume year label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block FUNCTION init.state.consts #0 'before.a...
[2]

write newline

" write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...
[3]

B.; Kuppan, K.; and Divya, B

Acharya, D. B.; Kuppan, K.; and Divya, B. 2025. Agentic ai: Autonomous intelligence for complex goals--a comprehensive survey. IEEe Access

work page 2025
[4]

Amodei, D.; and et al. 2016. Concrete problems in AI safety. arXiv preprint arXiv:1606.06565

arXiv 2016
[5]

Arnold, T.; and Scheutz, M. 2017. The Trolley Problem Bot: Defining and Evaluating a Baseline for Mitigating Ethical Risk. In Proceedings of the 2017 AAAI/ACM Conference on AI, Ethics, and Society, 38--44

work page 2017
[6]

Bratman, M. E. 1987. Intention, Plans, and Practical Reason. Cambridge, MA: Harvard University Press

work page 1987
[7]

Christiano, P.; and et al. 2020. Recursively summarizing books with human feedback. In Advances in Neural Information Processing Systems

work page 2020
[8]

C.; Ferrando, A.; Panisson, A

Engelmann, D. C.; Ferrando, A.; Panisson, A. R.; Ancona, D.; Bordini, R. H.; and Mascardi, V. 2022. RV4JaCa--Runtime Verification for Multi-Agent Systems. arXiv preprint arXiv:2207.09708

arXiv 2022

Show all 23 references

[9]

Gabriel, I. 2020. Artificial Intelligence, Values, and Alignment. Minds and Machines, 30(3): 411--437

2020
[10]

Hadfield-Menell, D.; and et al. 2016. Cooperative Inverse Reinforcement Learning. Advances in Neural Information Processing Systems, 29

2016
[11]

K.; Malik, T.; Shawosh, M.; Albashrawi, M

Hughes, L.; Dwivedi, Y. K.; Malik, T.; Shawosh, M.; Albashrawi, M. A.; Jeon, I.; Dutot, V.; Appanderanda, M.; Crick, T.; De’, R.; et al. 2025. AI agents and agentic systems: A multi-expert analysis. Journal of Computer Information Systems, 1--29

2025
[12]

Leike, J.; and et al. 2018. Scalable agent alignment via reward modeling: a research agenda. arXiv preprint arXiv:1811.07871

2018 arXiv
[13]

Open Policy Agent Project . 2023. OPA: Open Policy Agent. ://www.openpolicyagent.org/

2023
[14]

Ouyang, L.; and et al. 2022. Training language models to follow instructions with human feedback. arXiv preprint arXiv:2203.02155

2022 arXiv
[15]

Ranjan, R.; Gupta, S.; and Singh, S. N. 2025. Loka protocol: A decentralized framework for trustworthy and ethical ai agent ecosystems. arXiv preprint arXiv:2504.10915

2025 arXiv
[16]

Ray, P. P. ???? A Review of TRiSM Frameworks in Artificial Intelligence Systems: Fundamentals, Taxonomy, Use Cases, Key Challenges and Future Directions. Authorea Preprints
[17]

Russell, S.; Dewey, D.; and Tegmark, M. 2015. Research Priorities for Robust and Beneficial Artificial Intelligence. AI Magazine, 36(4): 105--114

2015
[18]

Saffarizadeh, K.; Keil, M.; and Maruping, L. 2024. Relationship between trust in the AI creator and trust in AI systems: the crucial role of AI alignment and steerability. Journal of management information systems, 41(3): 645--681

2024
[19]

Sentinella, R.; Fuelle, E.; Casovan, A.; and Jones, J. 2025. AI Governance Profession Report 2025 . https://iapp.org/resources/article/ai-governance-profession-report/. Published by IAPP and Credo AI. Provides insights on building an AI governance program and professionalizing...

2025
[20]

Solaiman, I.; and Dennison, C. 2021. Process for adapting language models to society (PALMS). arXiv preprint arXiv:2106.10328

2021 arXiv
[21]

Tabassi, E.; Grese, M.; Hageman, K.; Harnett, J.; Hoffman, M.; Hsu, W.; Martin, A.; Mongeau, M.; Raghavan, S.; Shoup, J.; Southworth, A.; and Yaga, D. 2023. Artificial Intelligence Risk Management Framework (AI RMF 1.0). Technical Report NIST AI 100-1, National Institute of St...

2023
[22]

Tamang, S.; and Bora, D. J. 2025. Enforcement Agents: Enhancing Accountability and Resilience in Multi-Agent AI Frameworks. arXiv preprint arXiv:2504.04070

2025 arXiv
[23]

L.; Singhal, T.; Kelkar, A.; and Tuo, J

Wang, C. L.; Singhal, T.; Kelkar, A.; and Tuo, J. 2025. MI9--Agent Intelligence Protocol: Runtime Governance for Agentic AI Systems. arXiv preprint arXiv:2508.03858

2025

Pith tools

Reviewed August 5, 2026 · model on record in the stance chip above.

[1] [1]

, " * write output.state after.block = add.period write newline

ENTRY address archivePrefix author booktitle chapter edition editor eid eprint howpublished institution isbn journal key month note number organization pages publisher school series title type volume year label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block FUNCTION init.state.consts #0 'before.a...

[2] [2]

write newline

" write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...

[3] [3]

B.; Kuppan, K.; and Divya, B

Acharya, D. B.; Kuppan, K.; and Divya, B. 2025. Agentic ai: Autonomous intelligence for complex goals--a comprehensive survey. IEEe Access

work page 2025

[4] [4]

Amodei, D.; and et al. 2016. Concrete problems in AI safety. arXiv preprint arXiv:1606.06565

arXiv 2016

[5] [5]

Arnold, T.; and Scheutz, M. 2017. The Trolley Problem Bot: Defining and Evaluating a Baseline for Mitigating Ethical Risk. In Proceedings of the 2017 AAAI/ACM Conference on AI, Ethics, and Society, 38--44

work page 2017

[6] [6]

Bratman, M. E. 1987. Intention, Plans, and Practical Reason. Cambridge, MA: Harvard University Press

work page 1987

[7] [7]

Christiano, P.; and et al. 2020. Recursively summarizing books with human feedback. In Advances in Neural Information Processing Systems

work page 2020

[8] [8]

C.; Ferrando, A.; Panisson, A

Engelmann, D. C.; Ferrando, A.; Panisson, A. R.; Ancona, D.; Bordini, R. H.; and Mascardi, V. 2022. RV4JaCa--Runtime Verification for Multi-Agent Systems. arXiv preprint arXiv:2207.09708

arXiv 2022