The Agentic Layer: Agent Runtime, Goal Engine, Action Gateway

Deep Dive | ~10 min read
Track 02: Architecture and Technology — Module 02.1: The Two-Layer Platform Architecture

Every enterprise HR platform claims intelligence. Most deliver search with better marketing. The difference between a system that retrieves information and one that acts on it comes down to architecture — specifically, how intelligence and execution are separated, governed, and orchestrated.

This article breaks down the Agentic Layer: the execution tier of Gloat’s two-layer platform architecture. We will walk through each of its three core components — Agent Runtime, Goal Engine, and Action Gateway — and show how they operate in concert with Loomra, Gloat’s AI Context Engine, to deliver autonomous HR actions that remain explainable, auditable, and aligned with business objectives.

The two-layer architecture: Loomra and the Agentic Layer

Before examining the Agentic Layer in isolation, it is essential to understand where it sits within the broader platform.

Gloat’s architecture separates intelligence from execution across two distinct layers:

Loomra is the intelligence layer — Gloat’s AI Context Engine. It provides the contextual foundation that makes agent reasoning possible. Loomra comprises five integrated components:

• Knowledge Graph: 2.4 million entities and 18.7 million edges representing the interconnected reality of skills, roles, people, organizations, and labor markets.
• Intelligent Tools: 14 purpose-built tools that have processed over 200 million matches, handling operations like skill inference, role matching, and gap analysis.
• Personalization Engine: Behavioral and preference models trained on 5 million+ employee interaction patterns.
• Retrieval & Embedding: Six specialized models delivering 90% accuracy across skill extraction, role matching, and semantic search tasks.
• Business Logic Engine: 24 rule categories evaluated at sub-15ms query latency, encoding the compliance, governance, and policy constraints that vary by customer, region, and business unit.

The Agentic Layer is the execution layer. It takes the intelligence Loomra provides and turns it into governed, auditable action. Where Loomra answers “what do we know and what does it mean,” the Agentic Layer answers “what should we do about it, and are we allowed to.”

This separation is not incidental. It is the architectural decision that makes enterprise-grade agentic HR possible. Intelligence without governance is a liability. Governance without intelligence is a bottleneck. The two-layer design eliminates both failure modes.

The Agent Runtime: lifecycle, context, reasoning

The Agent Runtime is the orchestration engine that manages every agent from activation through completion. It handles four critical functions: lifecycle management, context assembly, reasoning orchestration, and tool execution.

Lifecycle management

Each of Gloat’s 29 agents operates within a managed lifecycle. The Runtime handles instantiation, state management, error recovery, and graceful termination. When a succession planning query arrives, the Runtime does not simply dispatch it to a model. It identifies the relevant agent, loads its configuration (including any Playbook-defined behavioral parameters), establishes the execution context, and manages the entire interaction through to resolution — or escalation.

Context assembly

This is where the Runtime’s integration with Loomra becomes critical. For any given agent action, the Runtime must assemble the precise context window that makes intelligent reasoning possible. It queries Loomra’s Knowledge Graph for structural data, pulls behavioral signals from the Personalization Engine, retrieves relevant embeddings, and loads the applicable business rules — all before the agent’s reasoning cycle begins.

Context assembly is not retrieval. It is curation. The Runtime determines not just what information exists, but what information is relevant, permissible, and current for this specific action, this specific user, this specific organizational context.

Reasoning orchestration

The Agent Runtime is model-agnostic by design. Agents can reason using Anthropic, Google, IBM WatsonX, or customer-hosted infrastructure. The Runtime abstracts the reasoning layer so that model selection becomes a configuration decision rather than an architectural constraint. This means enterprises can align their AI infrastructure with existing vendor relationships, data residency requirements, or performance benchmarks without modifying agent behavior.

Reasoning orchestration also manages multi-step chains. A single agent action may require multiple reasoning cycles — an initial assessment, a refinement pass incorporating additional context, and a final recommendation synthesis. The Runtime manages these chains, maintaining coherence across steps and enforcing token budgets and latency constraints.

Tool execution

When an agent’s reasoning produces a tool call — query the Knowledge Graph, run a skill gap analysis, generate a development plan — the Runtime dispatches that call to Loomra’s Intelligent Tools, handles the response, and feeds the result back into the reasoning chain. This loop between reasoning and tool execution is where agents move beyond static recommendation into dynamic problem-solving.

The 29 agents: what the Runtime orchestrates

The Agent Runtime manages 29 purpose-built agents across four categories. Each agent encapsulates domain-specific reasoning patterns, tool access permissions, and behavioral parameters tuned for its function.

Talent Management (7 agents): Career Coach, Career Readiness, Development Plan, Internal Mobility, Leadership Pipeline, Succession Management, and Talent Marketplace. These agents operate on individual and cohort-level talent data, drawing heavily on the Knowledge Graph’s role-to-skill mappings and the Personalization Engine’s career trajectory models.

Talent Acquisition (6 agents): Candidate Discovery, Intelligent Referral, Intelligent Requisition, Job Description Optimizer, Talent Insight, and Talent Pipeline. These agents bridge internal talent data with external market intelligence, leveraging the Retrieval & Embedding layer’s semantic matching capabilities.

Skills (8 agents): Emerging Skills Radar, Skill Benchmarking, Skill & Task Framework, Skill Gap Resolver, Skill Intelligence Engine, Skill Portfolio, Skill Validation Engine, and Upskilling & Reskilling. This is the densest agent category because skills are the connective tissue of the entire platform. These agents interact with every component of Loomra’s stack.

Workforce Planning (8 agents): AI Impact Analysis, Critical Role Monitor, Org Design, Pay & Compensation, Scenario Simulator, Talent Redeployment, Transformation Planner, and Workforce Insights. These agents operate at the organizational and strategic level, requiring the broadest context windows and the most complex reasoning chains.

The Goal Engine: translating business objectives into agent behavior

The Goal Engine sits between organizational intent and agent execution. Its function is to translate high-level business objectives — “reduce time-to-fill for engineering roles by 20%,” “increase internal mobility in APAC,” “build a leadership pipeline for our new product division” — into the behavioral parameters that shape how agents reason and prioritize.

Objective decomposition

When a CHRO defines a strategic objective, the Goal Engine decomposes it into measurable sub-goals, assigns weighting factors, and maps those weights to the relevant agents. An objective to increase internal mobility does not simply tell the Internal Mobility agent to work harder. It adjusts weighting across the Career Coach (emphasizing lateral opportunities), the Skill Gap Resolver (prioritizing bridgeable gaps), the Talent Marketplace (surfacing cross-functional matches), and the Development Plan agent (creating accelerated readiness paths).

Dynamic weighting

Goal weights are not static. The Goal Engine continuously adjusts them based on progress signals, changing business conditions, and feedback loops from completed agent actions. If internal mobility targets are being met in EMEA but lagging in North America, the Goal Engine can shift weighting regionally without manual intervention — provided governance rules permit autonomous adjustment for that goal class.

Agent Studio and Playbooks

This is where the Goal Engine becomes configurable by non-technical users. Agent Studio provides a visual canvas — drag, drop, deploy — powered by Loomra’s semantic layer. HR leaders and administrators can create new agents using natural language descriptions (“I need an agent that monitors succession readiness for VP-level roles and alerts when bench strength drops below two candidates”) or start from pre-built templates like the Career Development Advisor or Retention Risk Analyzer.

Playbooks define the behavioral parameters for each agent: which goals it serves, what tools it can access, what reasoning patterns it should follow, what escalation thresholds apply. Playbooks are versioned, auditable, and composable. A single agent can operate under different Playbooks depending on the business unit, geography, or use case.

The combination of Agent Studio and Playbooks transforms agent configuration from an engineering task into an HR operations task. From idea to deployed agent: minutes, not months.

The Action Gateway: governance, execution, audit

The Action Gateway is the final control point before any agent action reaches an external system. It enforces three functions: business rule evaluation, approval workflow management, and audit logging.

Business rule evaluation

Every proposed agent action passes through the Business Logic Engine’s 24 rule categories at sub-15ms latency. These rules encode compliance requirements (GDPR, local labor law, pay equity regulations), organizational policies (approval hierarchies, budget thresholds, headcount caps), and operational constraints (system availability windows, data freshness requirements, rate limits).

Rule evaluation is not a binary gate. The Action Gateway can approve an action outright, reject it with an explanation, modify it to comply with applicable rules, or route it for human approval. The decision depends on the rule category, the action’s risk classification, and the governance configuration defined in the agent’s Playbook.

Approval workflows

For actions classified above the autonomous threshold — a compensation adjustment, an external job posting, a reorganization proposal — the Action Gateway routes the action to the appropriate approver with full context: the agent’s reasoning chain, the data it considered, the alternatives it evaluated, and the specific rules that triggered the approval requirement.

This is where the two-layer architecture pays its highest dividend. Because Loomra provides rich, structured context and the Agent Runtime preserves the full reasoning chain, approvers receive not just a recommendation but an explanation. The approval process becomes faster and more informed, not slower.

HCM write-back

When an action clears governance, the Action Gateway executes it against the target system. Gloat maintains native write-back integrations with Workday, SAP SuccessFactors, and Oracle HCM. This is not API translation. Gloat ingests each HCM’s data model, business logic, workflows, and configurations — HCM understood, not just connected. The Action Gateway writes back in the HCM’s native semantics, respecting its validation rules, triggering its downstream workflows, and maintaining referential integrity.

Audit logging

Every action — approved, rejected, modified, or escalated — is logged with its complete provenance: the triggering event, the assembled context, the reasoning chain, the rules evaluated, the decision rationale, the execution result, and the timestamp. Full audit trail: every action, every reason, every time.

This audit corpus is not just a compliance artifact. It feeds back into the Goal Engine’s performance tracking and Loomra’s Personalization Engine, creating a learning loop that improves agent behavior over time.

A complete agent action: succession planning walkthrough

To make the architecture concrete, here is a full agent action from trigger to completion.

Trigger. A VP of Engineering opens Gloat in Microsoft Teams and asks: “Who is ready to succeed Maria Chen as SVP of Product if she moves to the COO role we discussed?”

Agent selection. The Runtime identifies this as a Succession Management agent query with secondary involvement from the Leadership Pipeline and Career Readiness agents.

Context assembly. The Runtime queries Loomra:
– Knowledge Graph: Retrieves Maria Chen’s role profile, the SVP Product competency model, the reporting structure, and all director-and-above employees within two organizational hops. Returns 47 potential candidates with their skill profiles, tenure data, and current role mappings.
– Personalization Engine: Loads career trajectory patterns for the 47 candidates — who has expressed interest in senior leadership, who has demonstrated cross-functional capability, who has been actively developing product strategy skills.
– Retrieval & Embedding: Runs semantic similarity between the SVP Product competency model and each candidate’s demonstrated capabilities. Ranks the 47 candidates, surfacing a shortlist of 8 with readiness scores above the configured threshold.
– Business Logic Engine: Evaluates regional compliance rules (succession plans for SVP-level roles in this geography require at least two candidates from underrepresented groups), tenure policies, and budget constraints for potential development investments.

Reasoning. The Succession Management agent processes the assembled context across two reasoning cycles:
1. Assessment pass: Evaluates the 8 shortlisted candidates against the competency model, identifies 3 as “ready now,” 3 as “ready in 12 months with targeted development,” and flags 2 as strong but lacking a critical competency (P&L ownership experience).
2. Recommendation synthesis: Generates a ranked succession slate with specific development actions for the “ready in 12 months” candidates, leveraging the Development Plan agent to draft accelerated readiness paths.

Goal Engine adjustment. The Goal Engine notes this query aligns with the organization’s Q2 objective to strengthen leadership pipeline depth. It increases the weighting on proactive succession monitoring for SVP-level roles across the product organization.

Action Gateway. The proposed succession slate is classified as “advisory” (no system write required), so it passes governance without an approval workflow. The Action Gateway logs the complete reasoning chain, the data sources consulted, the candidates considered and excluded, and the compliance rules evaluated.

Delivery. The response is rendered back in the VP’s Teams interface with the ranked slate, readiness assessments, development recommendations, and a link to view the full reasoning chain in Gloat’s platform.

Audit. The complete interaction — from query to response, including all intermediate reasoning and data access — is logged and available for compliance review, with sensitive fields masked according to the organization’s data access policies.

Delivery surfaces: where agents meet employees

The Agentic Layer delivers agent interactions through the surfaces where work already happens. Gloat agents are accessible natively in Microsoft Teams, Slack, Google Chat, and Microsoft Copilot, in addition to the Gloat platform itself. This is not a redirect-to-portal model. Agents participate in conversations, respond to queries, and surface proactive recommendations within the collaboration tool the employee is already using.

The delivery surface abstraction is handled by the Agent Runtime. The same agent, the same reasoning chain, the same governance rules apply regardless of whether the interaction originates in Slack or in the Gloat platform. The Runtime adapts the response format to the surface’s capabilities — rich cards in Teams, threaded responses in Slack, embedded actions in Copilot — while maintaining identical behavioral semantics.

Why intelligence-action separation matters

The two-layer architecture — Loomra for intelligence, Agentic Layer for execution — is not an abstraction exercise. It solves three concrete enterprise problems:

Governance without bottleneck. Because the Action Gateway operates independently of the intelligence layer, governance rules can be updated, tightened, or relaxed without retraining models or modifying agent reasoning. When a new compliance requirement emerges, it is a rule update in the Business Logic Engine, not a platform release.

Intelligence without risk. Because Loomra’s reasoning outputs pass through the Goal Engine and Action Gateway before reaching any system of record, the blast radius of an incorrect inference is bounded. A hallucinated skill match cannot propagate into a Workday job assignment without passing through rule evaluation, confidence thresholds, and — for high-risk actions — human approval.

Evolvability without disruption. Because the Agent Runtime is model-agnostic and the Goal Engine is configuration-driven, the platform can adopt new models, add new agents, and adjust organizational objectives without architectural changes. The separation of concerns means each layer can evolve at its own pace.

Systems of record tell you what is. Systems of action decide what happens next. The Agentic Layer — Agent Runtime, Goal Engine, Action Gateway — operating on the intelligence foundation Loomra provides, is how Gloat bridges that gap at enterprise scale: 100+ customers, 5 million+ employees, 112 countries, 200+ deployments.

What to read next

• Loomra deep dive: Knowledge Graph, Intelligent Tools, and the five components — A detailed examination of each Loomra component and how they generate the context that powers agent reasoning.
• Agent Studio and Playbooks: configuring agents without code — Hands-on guide to creating, customizing, and deploying agents using Gloat’s visual canvas and behavioral configuration system.
• The Business Logic Engine: 24 rule categories for enterprise governance — How Gloat encodes compliance, policy, and operational constraints into sub-15ms rule evaluation.
• HCM write-back architecture: Workday, SAP SuccessFactors, Oracle HCM — How the Action Gateway maintains semantic fidelity when writing agent actions back to systems of record.
• Model-agnostic agent reasoning: Anthropic, Google, IBM WatsonX — How the Agent Runtime abstracts model selection and what it means for enterprise AI infrastructure decisions.