Developer Documentation

ind.ai Agent OS Architecture

How ind.ai structures AI agents using a modular operating system.

ind.ai agents are not single prompt blobs. They are built from modular governance layers that define identity, behaviour, decision rules, and runtime state.

Consistency across agents

Safe behaviour

Scalable architecture

Easier debugging

Reusable components

Every agent on ind.ai is assembled from a set of reusable modules called the Agent OS.

Explore the architecture

User

Runtime Layer

session state · memory

Tenant Layer

user identity & goals

Personality Layer

behavioural style

Role Layer

functional capability

Core Layer

global governance rules

Every ind.ai agent is assembled from reusable layers.

Core rules provide safety and consistency.

Roles define capabilities.

Personality shapes behaviour.

Tenant data personalizes the agent.

Runtime state manages live interactions.

Architecture Philosophy

Why modular agent architecture

Traditional AI agents suffer from fundamental structural problems that make them brittle at scale.

The Problem

Large, monolithic prompt files
Overlapping and conflicting instructions
Prompt collisions across agent contexts
Behavioural drift over time
Difficulty maintaining thousands of agents

The ind.ai Solution

Core governance — shared safety rules
Role definitions — functional specialisation
Personality overlays — behavioural style
Tenant-specific identity — personalisation
Runtime context — dynamic session state

Consistent behaviourScalable infrastructureEasier upgradesReusable agent templates

Structure

Agent OS folder structure

Each folder represents a layer of the agent operating system.

/agent-os
    /core
        constitution.md
        context-priority.md
        risk-engine.md
        tool-use-policy.md
        workflow-engine.md
        memory-policy.md

    /roles
        personal-chief-of-staff.md
        marketer.md
        finance.md
        researcher.md

    /personalities
        calm-strategic.md
        concise-operator.md
        warm-guide.md

    /tenants
        /ajay
            identity.md
            mission.md
            authority.md
            delegation-tree.md
            voice.md

    /runtime
        active-stack.json
        session-context.md
        working-memory.md

Governance

Core Layer

The /core layer contains the global governance rules shared across all agents. These files rarely change and define the foundational behaviour of the system.

constitution.md

Defines the agent's highest-level ethical principles and safety rules.

context-priority.md

Defines how conflicting instructions are resolved.

risk-engine.md

Provides a framework for evaluating risk before recommending actions.

tool-use-policy.md

Defines how the agent should use external tools.

workflow-engine.md

Defines the default task execution pipeline.

memory-policy.md

Defines what the agent should remember and what it should ignore.

Capabilities

Roles Layer

Roles define the functional job of the agent. The /roles directory contains specialist role definitions that specify responsibilities, reasoning approach, domain expertise, and operational style.

These roles can be combined with any personality and tenant layer to create starter agents tailored to specific users and use cases.

personal-chief-of-staff.md

Supports planning, synthesis, prioritisation, and decision framing.

marketer.md

Handles messaging, campaigns, and growth ideas.

finance.md

Handles pricing models, unit economics, and financial reasoning.

researcher.md

Handles information gathering, analysis, and structured synthesis.

Behaviour

Personality Layer

Personality modules in /personalities shape how the agent behaves — without affecting its responsibilities. The same role can behave differently when combined with a different personality overlay.

calm-strategic.md

Strategic, composed, analytical.

concise-operator.md

Efficient, minimal communication style.

warm-guide.md

Friendly, explanatory, and supportive.

Identity

Tenant Layer

The /tenants layer defines the specific identity of the agent for each user or organisation. This is the AI identity layer that personalises each agent instance.

Example: /tenants/ajay

identity.md

Defines who the agent is and its relationship to the user.

mission.md

Defines the long-term purpose and goals of the agent.

authority.md

Defines what the agent can decide autonomously.

delegation-tree.md

Defines how work is routed to specialist sub-agents.

voice.md

Defines tone, communication style, and personality nuance.

Dynamic State

Runtime Layer

The /runtime layer stores temporary operational state. Unlike the governance layers, runtime files are dynamic and change frequently during live interactions.

active-stack.json

Defines which modules are currently loaded for the agent.

session-context.md

Stores context for the current conversation or task.

working-memory.md

Stores short-term information relevant to ongoing work.

Composition

How an agent is assembled

Agents are created by combining modules from each layer. This approach allows ind.ai to scale to millions of agents while maintaining consistent behaviour across the India Agent Stack.

Agent

=Core Rules

+Role Definition

+Personality Overlay

+Tenant Identity

+Runtime Context

Agents are composed dynamically from reusable modules.

Agent = Core + Role + Personality + Tenant + Runtime

Impact

Why this matters

The modular Agent OS architecture delivers key structural advantages for the Starter Agent Fabric.

Prevents prompt collisions

Prevents behavioural drift

Simplifies debugging

Enables reusable agent templates

Allows scalable multi-agent ecosystems

This modular architecture forms the foundation of the ind.ai agent network.

Starter Agent Fabric India Agent Stack