Research

Governed generative resource layers for agent-oriented systems.

The Problem

Semantic Breakdown: In multi-agent systems, communication has strict, formal semantics based on Speech Act Theory (e.g., tell(belief)). Interacting with probabilistic neural models lacks these guarantees, exposing the agent's epistemic base to unverified, unstructured assertions.

The Contribution

Mediated Neuro-Symbolic Boundary: Quarantines unstructured neural messages as uncommitted candidate material (cand_). This establishes a transactional protocol where the agent evaluates, structure-maps, and records an adoption decision only when candidate material satisfies the agent’s admissibility conditions; any host-agent materialisation remains explicit.

Research Questions

The framework addresses three foundational questions at the intersection of BDI theory and generative models:

RQ1

State Isolation

How can a mediated communication protocol preserve a BDI agent's epistemic integrity when interacting with probabilistic neural models?

RQ2

Auditable Boundaries

How can out-of-band policies govern this communication link without cluttering the agent's operational plans or breaking plan selection semantics?

RQ3

Cross-Platform Parity

Can a unified generative resource lifecycle interface provide semantic and functional parity across heterogeneous agent languages like Jason and ASTRA?

Academic Context

Generative Layers supports the MSc thesis Implementing Generative Resource Layers for BDI Agent Systems in Advanced Software Engineering at University College Dublin (UCD).

Dimitrios Kyriakidis

MSc Researcher

Author and core project maintainer of Generative Layers, developed as a research prototype for governed generative resource use in BDI agent systems.

Assoc. Prof. Rem Collier

Academic Supervisor

Academic supervisor, Multi-Agent Systems researcher, and founder of the ASTRA programming language.

Scope and Limitations

1. Generative Layers can influence BDI reasoning, plan execution, intention flow, and agent behaviour when an agent program is explicitly designed to use generated candidate material. It does not, however, modify or extend the internal BDI reasoning cycle itself. Work in that direction is Riccardo Battistini's Exploiting GenAI for Plan Generation in BDI Agents . The role of Generative Layers is not to bypass the host agent platform, but to provide governed points at which external generative outputs may be requested, inspected, validated, rejected, refined, or adopted by the agent.

2. Consistent with the acceptance patterns, LLMs are tools, not decision-makers. The implemented patterns should be read as evaluation scenarios and design idioms, not as universal guarantees that generated outputs are correct, safe, or automatically suitable for adoption. They demonstrate concrete governance controls such as validation, inspection, confidence gating, cross-provider verification, peer review, belief-consistency checking, majority voting, and iterative refinement before candidate material is explicitly used by the agent to affect state or behaviour.

3. Apparent Missing Capabilities — Why they belong to the agent, not the framework

Four capabilities might appear absent from the Generative Layers framework: adaptive feedback, cost management, temporal validity, and deciding when to consult an LLM. These are not missing — they are deliberately excluded from the governance layer because they belong to the BDI agent's reasoning cycle. GL provides the governed infrastructure; the agent provides the reasoning about when and how to use it, using the same practical reasoning programming style it uses for any other domain. The following examples illustrate how these patterns are expressed in ASTRA using the GL framework.

3.1 Adaptive Feedback

If an agent consistently rejects candidates from a particular provider, it can track that experience as beliefs and adopt a goal to rebind — using standard BDI deliberation and means-end reasoning:

// Deliberation: threshold hit, trigger rebind
rule +rejected(string provider) : rejection_count(int count) & count >= 3 {
    -+rejection_count(count + 1);
    !rebound(provider);
}

// Below threshold, just count
rule +rejected(string provider) : rejection_count(int count) {
    -+rejection_count(count + 1);
}

// Means-End Reasoning: rebind to alternative
rule +!rebound(string provider) : ~rebound_done(provider) {
    -+active_binding(gl.bind("feedback_agent", "gemini", "gemini-2.5-flash", ""));
    +rebound_done(provider);
}

// Serendipity: already rebound
rule +!rebound(string provider) { }

3.2 Cost & Budget

Budget tracking can be implemented as agent beliefs with context-guarded plan selection, or as a custom GovernancePolicy via the pluggable SPI:

// Context guard: only call if budget remains
rule +!classify(string item) : budget(int b) & b > 0 & active_binding(string bid) {
    +last_result(gl.call(bid, "classify", "llm.answer", "CLASSIFY", item, "label", ""));
    -+budget(b - 1);
}

// Budget exhausted — no LLM call
rule +!classify(string item) : budget(int b) & b <= 0 {
    +budget_exhausted(item);
}

3.3 Temporal Validity

Whether a classification is stale depends on the domain — only the agent knows its own context. BDI plan contexts handle this naturally:

// Serendipity: fresh belief exists — use it directly
rule +!classify(string item) : label(item, string lbl) &
        label_time(item, int t) & t > 0 {
    // already known and fresh — no GL call
}

// No belief or stale — consult GL
rule +!classify(string item) : active_binding(string bid) {
    !evaluate(gl.candidate(gl.call(bid, "classify",
        "llm.answer", "CLASSIFY", item, "label", "")), item);
}

// Evaluate candidate admissibility
rule +!evaluate(string cid, string item) {
    !maybe_accept(cid, gl.decide(cid), item);
}

3.4 When to Consult the LLM

This is the most fundamental BDI decision. Plan selection with context conditions determines when the agent reasons from its own beliefs versus consulting GL — no framework can or should dictate this:

// Agent already knows — GL is never consulted
rule +!classify(string item) : label(item, string lbl) {
    // serendipity: belief already held
}

// Agent doesn't know — governed LLM lifecycle
rule +!classify(string item) : active_binding(string bid) {
    !evaluate(gl.candidate(gl.call(bid, "classify",
        "llm.answer", "CLASSIFY", item, "label", "")), item);
}

// Evaluate candidate admissibility
rule +!evaluate(string cid, string item) {
    !maybe_accept(cid, gl.decide(cid), item);
}

// Means-End: accept if admissible
rule +!maybe_accept(string cid, string adm, string item) : adm == "ADMISSIBLE" {
    gl.accept(cid, "needed classification");
    +label(item, gl.get(cid, "label"));  // explicit belief adoption
}

// Not admissible — agent decides how to proceed
rule +!maybe_accept(string cid, string adm, string item) {
    +rejected_candidate(item, adm);
}

No additional framework is required. An ASTRA developer using Generative Layers has everything needed to implement adaptive, budget-aware, temporally-valid, selectively-governed LLM integration — using the same BDI programming model they already know. GL's contribution is to give the agent a governed, auditable, type-safe channel to generative resources — and then to get out of the way and let the BDI architecture do what it was designed to do.

Cite This Work

If you use Generative Layers in your research, please cite:

@software{kyriakidiscollier2026generativelayers,
  title        = {Generative Layers: A Java Framework for Governed Generative Resource Layers in Agent-Oriented Systems},
  author       = {Kyriakidis, Dimitrios and Collier, Rem},
  year         = {2026},
  url          = {https://www.generativelayers.com},
  repository  = {https://github.com/generativelayers/framework},
  note         = {Software framework and research artefact}
}

References

Selected academic references supporting the theoretical and technical basis of Generative Layers.

Top Journals (AI, TOSEM, KER, MIS Quarterly) — 5 refs

Other Journals — 6 refs

Books — 1 ref

Top Conferences (AAMAS, AAAI, ICMAS, NeurIPS) — 10 refs

Conferences, Workshops & Book Chapters — 11 refs

Theses — 1 ref

Online, Preprints & White Papers — 6 refs