Generative Layers

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

  1. An ASTRA or Jason agent reaches a goal, plan step, action, or module call that requires generative support.
  2. The platform adapter sends a structured request to Generative Layers.
  3. The governance layer checks policies, context, admissibility rules, limits, and audit requirements.
  4. A provider module invokes the selected external resource, such as an LLM, API, tool, service, or assessment module.
  5. The response is normalised into a structured result with status, evidence, warnings, metadata, and audit information.
  6. 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 began as MSc thesis-oriented research in Advanced Software Engineering at University College Dublin.

Academic context

Origin: MSc thesis-oriented research in Advanced Software Engineering at University College Dublin.

Status: independently developed project with an academic research origin.

Collaborators

Dimitrios Kyriakidis — founder and MSc researcher at University College Dublin.

Associate Professor Rem Collier — academic supervisor and Multi-Agent Systems researcher at University College Dublin.