> For the complete documentation index, see [llms.txt](https://candora.gitbook.io/whitepaper/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://candora.gitbook.io/whitepaper/candora-pro/candora-edge/agent-builder.md).

# Agent Builder

### Natural Language Strategy Development

Agent Builder is the strategy development environment of Candora Edge. It enables users to create, test, deploy, and continuously refine intelligent trading agents through natural language rather than traditional software development. Instead of writing automation code or constructing execution pipelines manually, users describe trading objectives, market hypotheses, portfolio rules, execution preferences, and risk constraints conversationally. The system translates those instructions into structured trading agents that execute within the bounded architecture of Candora Edge.

The objective of Agent Builder is to reduce the complexity of algorithmic trading without reducing transparency or control. Every generated agent remains fully inspectable, permission-aware, and subject to the same validation, execution, and enforcement mechanisms regardless of how it was created. Users can construct anything from simple monitoring agents to sophisticated portfolio managers or coordinated multi-agent systems without managing infrastructure, deployment environments, or exchange integrations.

### Conversational Agent Development

Agent Builder replaces manual strategy implementation with conversational development. Users explain how an agent should behave using natural language, including which markets to monitor, which signals to evaluate, how risk should be managed, and under what conditions actions should be executed.

The AI incrementally converts these instructions into structured trading logic while preserving a transparent representation of every decision stage. During development, users may ask the system to modify parameters, improve risk management, introduce additional analytical models, simplify decision logic, or explain how individual decisions are reached. Development therefore becomes an iterative dialogue rather than a traditional programming process.

Natural language serves as the interface for strategy construction, while the resulting agent is represented internally as deterministic execution logic. The conversational interface simplifies development without introducing ambiguity into execution.

### Modular Strategy Architecture

Although strategies are created conversationally, every agent is constructed from standardized decision modules that represent individual stages of the trading process. These include market observation, feature extraction, signal generation, portfolio construction, execution management, position sizing, risk controls, notification systems, and analytical workflows.

The AI assembles these modules into a structured decision graph based on the user's objectives. Information flows through this graph in a deterministic manner, allowing every recommendation and execution decision to be traced back to the underlying strategy components.

Separating conversational development from execution architecture provides two advantages. Users benefit from an intuitive development experience, while the platform preserves a consistent execution model that can be validated, monitored, and audited independently of the AI responsible for constructing it.

### Adaptive Strategy Refinement

Strategy development does not end after initial creation. Users may continuously refine deployed or simulated agents by describing desired improvements through natural language.

An agent may be instructed to become more conservative during periods of elevated volatility, incorporate additional market signals, adjust portfolio allocation methodology, improve execution efficiency, or respond differently to changing liquidity conditions. Rather than rebuilding the strategy manually, the AI proposes modifications while preserving compatibility with the existing architecture.

This iterative approach allows strategies to evolve alongside changing market conditions while maintaining complete transparency over every modification introduced throughout the development lifecycle.

### Event-Driven Automation

Financial markets evolve continuously, requiring automation systems capable of responding to changing conditions rather than executing on fixed schedules. Agent Builder therefore constructs event-driven strategies capable of reacting to market movements, volatility changes, liquidity shifts, portfolio conditions, macroeconomic developments, external information feeds, and user-defined events.

For example, an agent may reduce exposure during abnormal liquidity deterioration, tighten risk parameters as volatility increases, rebalance allocations following macroeconomic announcements, or coordinate execution timing based on changing market structure.

The event-driven architecture enables intelligent adaptation while ensuring every response remains constrained by the user's predefined permissions and operational limits.

### Integrated Testing and Simulation

Before deployment, every strategy may be evaluated within Candora's simulation and historical replay infrastructure. Users can observe how an agent would have behaved under previous market conditions, including periods of elevated volatility, liquidity disruptions, sentiment-driven events, and broader market stress.

Simulation is intended to evaluate behavioural consistency rather than predict future performance. It allows assumptions to be tested, weaknesses to be identified, and decision logic to be refined before capital is exposed to live markets. Historical replay also enables users to compare multiple strategy revisions and evaluate the effects of individual modifications throughout the development process.

### Permission-Aware Deployment

Every agent created through Agent Builder ultimately operates within a user-defined Permission Envelope enforced by Candora Edge.

Before deployment, users define the operational boundaries within which an agent may function, including supported markets, asset classes, maximum position sizes, exposure limits, execution permissions, leverage restrictions, risk thresholds, and emergency controls. These permissions represent immutable runtime constraints rather than advisory guidelines.

Agents cannot expand their authority, modify their own permissions, access unauthorized functionality, or perform actions outside the delegated scope. All execution requests are continuously validated by Edge Infrastructure before reaching the exchange.

This architecture ensures users retain complete authority over delegated automation while benefiting from AI-assisted decision making.

### Multi-Agent Architectures

Agent Builder supports both individual agents and coordinated multi-agent systems.

Rather than assigning every responsibility to a single model, complex strategies may be distributed across specialized agents responsible for different aspects of the investment process. One agent may analyse macroeconomic developments, another may evaluate market structure, another may supervise portfolio risk, while additional agents optimize execution or monitor operational health.

These agents collaborate through structured information exchange while remaining independently permissioned, observable, and enforceable through Edge Infrastructure. This architecture reflects the functional specialization commonly found within professional trading organizations while preserving accountability for every autonomous decision.

### Marketplace Publishing

Strategies developed through Agent Builder may remain private, be shared with selected users, or be published to the Candora Edge Marketplace.

Developers may monetize successful agents through subscriptions, licensing models, performance-based compensation, or other marketplace mechanisms settled in CAN. Marketplace participants can evaluate published agents using operational history, deployment statistics, supported markets, permission requirements, historical simulations, and documented strategy behaviour before deployment.

This creates an ecosystem where trading intelligence becomes a reusable digital asset while preserving transparency, accountability, and permission-aware execution.

### Relationship to Candora Edge

Agent Builder serves as the creation layer of Candora Edge. It transforms trading knowledge expressed through natural language into deployable automation while relying on Edge Infrastructure for execution, validation, monitoring, and enforcement.

Agent Builder does not execute trades directly, modify exchange behaviour, or bypass platform controls. Its responsibility is strategy construction. Execution authority always remains under the governance of Candora Edge.

### System Role

Agent Builder provides the development environment through which users transform investment ideas into operational AI trading systems. By combining natural language interaction, AI-assisted strategy construction, modular decision architectures, event-driven automation, simulation infrastructure, permission-aware execution, multi-agent coordination, and marketplace distribution, Agent Builder removes much of the engineering complexity traditionally associated with algorithmic trading while preserving the transparency, control, and deterministic execution required for institutional-grade financial automation.