> ## Documentation Index
> Fetch the complete documentation index at: https://docs.anthid.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Anthid is more than an EMS/OMS

> How Anthid brings broker connectivity, durable instructions, trading controls, live operations, and execution history into one managed platform.

Anthid brings order and execution management into a broader platform for running a trading operation. It connects broker accounts, records instructions, enforces configured controls, exposes live activity, and gives your team a shared record to work from.

That scope matters as soon as trading involves more than one application or one person. A strategy needs to submit an order. An operator needs to know whether it reached the broker. An administrator needs to restrict what the strategy can do. Later, someone needs to explain why the order was placed, amended, or refused. Anthid connects those jobs through the same accounts, instructions, and history.

EMS and OMS are useful starting points for understanding the product. The fuller description is **managed trading infrastructure**: the services and operational tools between the applications making trading decisions and the brokers carrying them out.

## The order is part of a longer workflow

Consider a team running a strategy against a connected account. The strategy submits a limit order, changes its price, and eventually asks to cancel the remainder. Meanwhile, an operator watches fills and positions, and an administrator changes the account's trading window.

The team needs to answer several questions about the same activity:

| Question                                                   | Where Anthid answers it                                 |
| ---------------------------------------------------------- | ------------------------------------------------------- |
| Is the broker account connected?                           | Trading accounts and connection status                  |
| What did the strategy ask for, including its amendments?   | The intent and its action chain                         |
| Was the instruction allowed under the configured controls? | Pre-trade evaluation and refusal records                |
| Did Anthid dispatch it, and what did the broker do?        | Separate intent dispatch state and broker order outcome |
| What is happening now?                                     | Live intent, order, and position streams                |
| How did the activity behave over the session?              | Ledger queries and order and exposure analytics         |

Each answer is useful by itself. Their connection is what makes Anthid a platform. You can follow an instruction from the application that sent it into the operational view your team uses, then into the history you investigate afterwards.

## An instruction has a life before the broker responds

Anthid models what you ask for as an [intent](/pages/concepts/intents). After the submission passes validation, authorization, and the applicable controls, the accepted instruction is committed in the same transaction that queues its execution.

That gives the instruction a durable identity before the broker answers. If the connection fails or the broker refuses the order, you can still inspect what Anthid accepted and how far it got.

A replace or cancel adds a sequenced action to the same intent. The original request remains part of the history. Each action records the credential behind that action, so a person cancelling an order submitted by a strategy does not erase the distinction between them. A client reference lets your application carry its own correlation identifier into that history.

The webapp makes this model visible. An intent detail page shows the latest action and the action chain. The related order shows the broker's execution state. Your software can read the same underlying records through the API.

This separation also makes operational questions more precise. `SENT` describes dispatch. `FILLED` describes a broker outcome. An instruction can be sent successfully and still be rejected by the broker. See [SENT is not FILLED](/pages/blog/articles/sent-is-not-filled) for the distinction.

## Controls live outside the strategy

A team should be able to change an account's trading permissions without changing every application that uses it. Anthid gives those constraints a shared enforcement point on the submission path.

You can enable or disable trading at organization, account, and symbol scope. Account and symbol controls also support trading windows and maximum order size. The applicable controls combine restrictively: permission at one level does not override a refusal at another.

For example, a strategy might request 500 shares while the account's maximum order size is 100. Anthid refuses that submission before dispatch and returns the controls that triggered. The team can inspect the refusal separately from accepted intents and broker rejections. It can also evaluate a hypothetical order before submitting it.

The webapp exposes account and symbol controls so authorized operators can manage them alongside the activity they govern. Control changes have their own attributed history, making a changed limit part of the operational record.

The current boundaries are specific. Organization scope provides a trading enable/disable control. Risk and time controls live at account and symbol scope, with availability depending on the plan. Maximum daily loss and maximum position size can be stored today, but are not enforced by the pre-trade evaluation. A control change also takes time to propagate; a kill switch should not be read as an instantaneous cancellation of working broker orders. The [controls guide](/pages/controls/overview) describes the current behavior.

## People and applications work from the same platform

The API and the webapp serve different parts of the same workflow.

Your application submits intents and consumes events. In the webapp, your team can inspect activity across accounts, open intent and order details, follow live streams, manage broker connections, and review controls. Authorized administrators can also place and cancel orders through the order ticket.

This is useful during an ordinary handoff. A strategy submits an order, another person investigates it, and an administrator changes what the account is allowed to do next. They can refer to the same intent, order, and account instead of reconciling several private versions of the activity.

Organization membership and permissions determine who can act. The ability to view a control does not automatically grant permission to change it, and access to a dashboard does not itself grant permission to submit orders.

Broker connectivity belongs to this shared platform too. Anthid stores broker credentials encrypted and manages the sessions behind connected accounts. Your applications use Anthid's contract while the broker adapters handle the broker-specific exchange.

[Alpaca and Lightspeed Connect](/pages/brokers/overview) are available today, both in beta. Their supported order types, destinations, and time-in-force combinations still differ. A common interface preserves your application's model while keeping those broker capabilities explicit.

## The record stays useful after the trade

A live stream tells you what is arriving now. The [ledger](/api-reference/ledger/overview) lets you query the activity later, including order and position history across the accounts your organization can access.

The webapp builds operational analytics on that record. Order analytics show acknowledgement and fill timing, outcomes, and amendments. Exposure analytics show how recorded positions changed over time. Exposure is valued using the broker's average cost, so read it as that view of the book rather than a live market valuation.

Those views help a team ask better questions. Did acknowledgements slow down during the session? Were orders repeatedly amended? Which orders were rejected? How did the recorded exposure change? You can investigate through the webapp or use the API to feed your own reporting and reconciliation workflow.

The record also extends beyond successful execution. Accepted instructions, control changes, and qualifying submission refusals preserve different parts of the explanation. An account where no order reached the broker can still have meaningful activity to review.

## Build the trading logic on top

Anthid's role is to provide the operational foundation around your trading decisions. Your team chooses what to trade and supplies the strategy. Your broker carries out the supported orders. Anthid connects the instruction, the controls, the broker interaction, and the record your team uses to operate the system.

That is the value beyond an EMS/OMS label: a common platform for the applications sending instructions and the people responsible for them.

To see the workflow end to end, start with a paper account. Submit an intent, inspect its action chain and broker outcome, follow the live updates, and query the resulting history. Then configure an order-size limit and inspect a refusal. The [quickstart](/pages/intro/quickstart) is the place to begin.