Welcome to Generative Layers
A governed generative agent framework for semantically controlled interaction with external models, tools, services, APIs, and resources.
Generative Layers is framework infrastructure for agent systems that need controlled access to modern generative and agentic AI capabilities while preserving the reasoning semantics of established agent platforms.
The project separates agent-side decisions from external resource calls so that interaction can be checked, logged, governed, tested, and handled through explicit framework boundaries.
What it is
Generative Layers is not a chatbot wrapper and it is not a replacement for ASTRA, Jason, JaCaMo, CArtAgO, or other agent-oriented platforms. It is a framework layer that sits between an agent system and external generative resources.
The framework exposes external capabilities as governed resources. An agent can ask for a generated answer, a tool assessment, a candidate plan, a structured analysis, or a resource action. The result is returned as candidate material. The agent system still decides whether that material becomes a belief, supports a goal, triggers an action, or is rejected.
Target platforms and source material
The first implementation direction is BDI-first. These platforms provide the language, runtime, environment, and organisation material needed to test Generative Layers across real agent-oriented systems.
Jason
Official site: jason-lang.github.io
Jason is the primary academic reference target for AgentSpeak-style BDI examples. Generative Layers should provide a Jason adapter where generated outputs are returned as structured candidate material and only become beliefs, plans, or actions through explicit Jason-side reasoning.
ASTRA
Official site: astralanguage.com
ASTRA is the practical implementation and experimentation target. Generative Layers should integrate through ASTRA modules, actions, sensors, predicates, or events while keeping ASTRA's agent cycle and language semantics intact.
JaCaMo
Official site: jacamo-lang.github.io
JaCaMo is relevant for experiments that combine agents, shared environments, and organisational abstractions. Generative Layers can later be evaluated in richer MAS scenarios where governance applies across agents, roles, artefacts, and coordinated tasks.
CArtAgO
Repository: github.com/CArtAgO-lang/cartago
CArtAgO is relevant for modelling environments and external resources through artifacts. It is a strong candidate for treating generative tools, LLM services, APIs, and assessment modules as governed resources available to agents.
Why this framework is needed
Current agentic AI systems often rely on large language models to plan, choose tools, call services, and revise behaviour. That is powerful, but it can blur the boundary between reasoning, execution, tool use, and external generation.
Generative Layers aims to make that boundary explicit. LLM output is treated as external candidate material, not as automatic belief, intention, or action. The agent platform remains responsible for adoption, admissibility, execution, and traceability.
How it is used
- An ASTRA or Jason agent reaches a goal, plan step, action, or module call that requires generative support.
- The platform adapter sends a structured request to Generative Layers.
- The governance layer checks policies, context, admissibility rules, limits, and audit requirements.
- A provider module invokes the selected external resource, such as an LLM, API, tool, service, or assessment module.
- The response is normalised into a structured result with status, evidence, warnings, metadata, and audit information.
- The agent receives the result and decides what to do using its own language semantics.
Framework shape
Core
Shared request, response, policy, audit, provider, and execution abstractions.
Adapters
Thin integrations for ASTRA, Jason, and later JaCaMo or CArtAgO-style environments.
Providers
Modules that connect governed requests to LLMs, APIs, tools, services, and external resources.
Tests
Experiments comparing direct generative behaviour against BDI-controlled generative resource usage.
Research direction
The framework is intended to support experiments in ASTRA and Jason, with extensions toward JaCaMo and CArtAgO-style environments. The goal is to make agentic AI techniques testable within agent programming languages, so implementation results can be evaluated and developed into academic publications.
The broader research direction is BDI-first, not BDI-only. The initial focus is on BDI agent systems because they provide clear semantics for beliefs, goals, intentions, plans, actions, and deliberation. Later work may generalise the framework to other agent-oriented and autonomous software systems.
Project origin
Generative Layers started as thesis-oriented research by Dimitrios Kyriakidis as part of the MSc in Advanced Software Engineering at University College Dublin. The work investigates how governance, decision constraints, and external generative capabilities can be layered around agent systems without collapsing those concerns into the agent's internal reasoning process.
Academic context
University: University College Dublin.
Programme: MSc in Advanced Software Engineering.
Collaborators
Dimitrios Kyriakidis — MSc Advanced Software Engineering, University College Dublin.
Associate Professor Rem Collier — Multi-Agent Systems researcher, University College Dublin.