A TRUST is the programmable company you create inside aeqi's Company OS: humans set direction, agents execute through roles and quests, and work compounds into operating memory. It has roles, quests, permissions, sessions, events, and decisions that let work continue beyond one person's immediate attention.

What is the agent economy?

The agent economy starts when execution becomes programmable. The harder thesis is incentive alignment: if agents can create value at software speed, companies need a vehicle where execution, authority, ownership, and capital live in the same system. aeqi is the Company OS for those programmable companies.

aeqi is the Company OS for the agent economy. It lets you create a TRUST: a programmable company where humans direct, agents execute, memory compounds, and authority, treasury, governance, and ownership primitives stay in one operating context.

Can AI agents run a business?

AI agents can run meaningful company work when they operate inside a TRUST with human direction, roles, permissions, memory, and escalation. aeqi is built for that structure: founders define mission and judgment, agents execute, and decisions become operating memory.

How do I start a TRUST with AI agents?

With aeqi, starting a TRUST takes three steps: (1) Request access and define the mission and operating context. (2) Staff the gaps with agents and roles. (3) Run work through quests, events, sessions, and memory so every decision compounds into the TRUST.

How do you invest in a TRUST?

Ownership is optional and belongs inside the TRUST, not in a disconnected spreadsheet. Execution creates the operating context around ownership: who acted, under which role, with which authority, and with what outcome. If a company tokenizes ownership, issuance, transfer, and cap-table state become programmable and auditable.

What types of businesses can become programmable companies?

The strongest starting points are software studios, research operations, content and growth engines, support operations, portfolio workflows, and other work that can be described, executed, reviewed, and improved over time.

aeqi is source-available under the Business Source License 1.1, with a scheduled conversion to Apache 2.0. The full codebase is on GitHub. You can inspect the code, self-host on your own infrastructure, and retain complete control over your TRUSTs, data, and agents.

How much does aeqi cost?

aeqi is in pre-launch. Pricing is organized per hosted TRUST, with capacity tiers covering LLM tokens, runtime size, and storage. Standard is $49/month. Pro is $69 for the first month, then $149/month. Both include one hosted TRUST and unlimited agent definitions. Enterprise arrangements with dedicated infrastructure and SLAs are available on request.

What makes aeqi different from LangChain or CrewAI?

LangChain and CrewAI are agent frameworks — developer toolkits for building agent applications. aeqi is the Company OS that creates the TRUST those agents operate inside: roles, quests, events, memory, permissions, authority, and optional ownership primitives in one programmable company.

CLI

aeqi is the command-line control surface for aeqi.

For a hosted TRUST, the CLI is a client: it authenticates to the platform and talks to the TRUST's managed runtime. It does not run that hosted runtime on your laptop. For self-hosting, aeqi start runs a local single-TRUST runtime with the API, dashboard, scheduler, MCP socket, and agent execution in one process.

In aeqi, the product edge is the TRUST. Company, organization, and entity are only explanatory or API-adjacent words. A hosted account can have one or more TRUSTs, and each TRUST has its own runtime, agents, quests, ideas, events, sessions, and memory.

Installation

curl -fsSL https://raw.githubusercontent.com/aeqiai/aeqi/main/scripts/install.sh | sh

Or build from source:

git clone https://github.com/aeqiai/aeqi.git
cd aeqi
cargo build --release
# binary at target/release/aeqi

Mental model

The CLI has three jobs:

Job	Command path	What it means
Talk to a hosted TRUST	`aeqi chat`	Opens a terminal chat with an existing runtime agent, using your account key.
Expose aeqi to an AI coding client	`aeqi mcp`	Starts an MCP server process so Codex, Claude Code, or another MCP client can use aeqi tools.
Run a local runtime	`aeqi setup`, `aeqi start`	Creates and runs a self-hosted single-TRUST runtime on your machine.

The most common hosted path is:

Create or join a TRUST in the dashboard.
Create keys in the dashboard.
Use aeqi chat when you want a terminal conversation with an existing agent.
Use aeqi mcp when you want Codex or Claude Code to work with TRUST memory, quests, agents, and code graph tools.

Hosted TRUST setup

Create two keys:

Account key (ak_...) from Account -> API.
TRUST secret key (sk_...) from the TRUST API keys page.

For terminal chat:

export AEQI_API_KEY=ak_...
export AEQI_API_URL=https://app.aeqi.ai
aeqi chat

If your account has multiple TRUSTs or roles, the CLI asks which one to use. You can also pin the context:

aeqi chat \
  --api-url https://app.aeqi.ai \
  --api-key ak_... \
  --entity <trust_runtime_id> \
  --agent "Executive Assistant"

aeqi chat lists your TRUSTs, filters to your human roles when possible, lists active agents in the selected TRUST, then opens a streaming session with the selected agent. Messages are sent to the hosted runtime over the platform API and WebSocket stream.

For MCP clients:

export AEQI_SECRET_KEY=sk_...
export AEQI_API_KEY=ak_...
export AEQI_PLATFORM_URL=https://app.aeqi.ai
aeqi mcp

Most users do not run aeqi mcp by hand. They configure Codex, Claude Code, or another MCP client to spawn it. See MCP.

Hosted user stories

Use the CLI like a terminal agent client

You already have a TRUST and an Executive Assistant agent. Run:

AEQI_API_KEY=ak_... AEQI_API_URL=https://app.aeqi.ai aeqi chat

Pick the TRUST, role, and agent. The CLI becomes a terminal chat surface for that runtime agent. The agent still runs inside aeqi, with its role, memory, tools, sessions, and event history. The CLI is only the transport.

Use Codex or Claude Code with the TRUST

Configure your MCP client to run aeqi mcp with AEQI_SECRET_KEY, AEQI_API_KEY, and AEQI_PLATFORM_URL.

The MCP client can then:

call me to confirm which user and TRUST it is operating as;
search and store Ideas for durable memory;
create, update, and close Quests;
inspect and hire Agents;
trigger or inspect Events;
use the code graph before changing source.

This is the aeqi version of an AI coding workspace: the chat client supplies the interface, while aeqi supplies TRUST context, memory, work ledger, agents, and execution history.

Interact with existing agents

In a terminal, use aeqi chat --agent <name-or-id> to talk to one existing agent.

From MCP, use:

agents(action='list')
agents(action='get', agent='Executive Assistant')
quests(action='create', subject='Draft the launch checklist', agent='Executive Assistant')

Creating a Quest with an agent or agent_id delegates work to that runtime agent. Omitting the agent creates user/TRUST-scoped work that is not automatically owned by one agent.

Create a new agent

From MCP, hire a runtime agent:

agents(action='hire', template='analyst')

Then delegate work:

quests(
  action='create',
  subject='Map the onboarding funnel',
  description='Review the current docs and produce a prioritized improvement plan.',
  agent='analyst'
)

The MCP client did not become the new agent. It asked the aeqi runtime to create one, then created work for that agent to execute.

Act as yourself, not as an agent

The normal hosted MCP connection acts as your account inside the selected TRUST. AEQI_SECRET_KEY selects the TRUST runtime, and AEQI_API_KEY binds the request to your user account.

AEQI_AGENT is only a client hint for logs and context. It does not make the connection own Quests or impersonate a runtime agent. Pass agent or agent_id explicitly when you want to delegate to, inspect, or filter for an agent.

AEQI_AGENT_ID is reserved for cases where a client intentionally needs to bind to a specific runtime agent. Most human-operated CLI and MCP setups should leave it unset.

Local self-host commands

`aeqi init`

Initialize aeqi in the current directory. Lightweight — writes a stub config and leaves the rest to aeqi setup. Use this when you want to author a runtime config by hand instead of taking the wizard's choices.

aeqi init

`aeqi setup`

Bootstrap a local runtime. The wizard detects context:

Inside a git repo: configures the current workspace.
Outside a repo: writes to ~/.aeqi/.

aeqi setup
aeqi setup --runtime anthropic_agent
aeqi setup --service

Creates SQLite databases (aeqi.db, sessions.db), starter agents, and a default config. --service installs a per-user daemon service after bootstrap; --force overwrites existing starter files.

`aeqi start`

Run the local daemon, REST API, scheduler, dashboard, and runtime in one process. Default bind comes from config.

aeqi start
aeqi start --bind 127.0.0.1:8400

Hosted users usually do not run this. The hosted platform already runs the tenant runtime.

`aeqi daemon`

Manage a local daemon service.

aeqi daemon start
aeqi daemon status
aeqi daemon stop
aeqi daemon query status
aeqi daemon install --start
aeqi daemon uninstall --stop

`aeqi secrets`

Manage local provider keys and secrets.

aeqi secrets set OPENROUTER_API_KEY sk-or-...
aeqi secrets set ANTHROPIC_API_KEY sk-ant-...
aeqi secrets get OPENROUTER_API_KEY
aeqi secrets list
aeqi secrets delete OPENROUTER_API_KEY

`aeqi agent`

Manage local persistent agents.

aeqi agent list
aeqi agent spawn "Research Bot" --model anthropic/claude-sonnet-4.6
aeqi agent show "Research Bot"
aeqi agent registry
aeqi agent retire "Research Bot"
aeqi agent activate "Research Bot"

For hosted agent management from AI clients, prefer MCP agents(...).

`aeqi chat`

Open the interactive terminal chat. With AEQI_API_KEY set, it uses hosted account-key mode. Without it, it uses the local runtime config.

aeqi chat
aeqi chat --agent assistant
aeqi chat --entity <trust_runtime_id> --role <role_id> --agent <agent_id>

`aeqi mcp`

Run the MCP server over stdio. MCP clients spawn this process and call tools through it.

aeqi mcp

Hosted mode requires AEQI_SECRET_KEY, AEQI_API_KEY, and AEQI_PLATFORM_URL. Self-hosted mode uses the local runtime socket from the config.

`aeqi ideas`

Manage local Ideas.

aeqi ideas search "auth patterns"
aeqi ideas store "JWT refresh" "Use rotating refresh tokens with 7-day expiry"
aeqi ideas export --vault ~/notes/aeqi
aeqi ideas import --vault ~/notes/aeqi

`aeqi quests`

List and close local Quests. assign creates a Quest for a root agent.

aeqi assign "Write the onboarding checklist" --root assistant --priority high
aeqi ready
aeqi quests
aeqi quests --all
aeqi close <quest_id> --reason "shipped"

For hosted Quest operations from Codex or Claude Code, prefer MCP quests(...).

`aeqi graph`

Operate the local code intelligence graph.

aeqi graph index --root assistant
aeqi graph index --root assistant --full
aeqi graph stats --root assistant

`aeqi doctor`

Run diagnostics across the local install — config presence, database reachability, missing secrets, broken sockets.

aeqi doctor
aeqi doctor --fix       # auto-fix what can be auto-fixed
aeqi doctor --strict    # non-zero exit if any issues remain

`aeqi status`

One-shot snapshot of the local runtime state. Prints daemon health, active agents, recent quests, and config locations.

aeqi status

`aeqi monitor`

Consolidated operator monitor view. Either one-shot or streaming.

aeqi monitor
aeqi monitor --root assistant       # focus a single root agent
aeqi monitor --watch                # refresh continuously
aeqi monitor --watch --interval 5
aeqi monitor --json                 # emit as JSON for piping

`aeqi team`

Show system team and per-root teams. Useful for inspecting who works for whom inside a TRUST runtime.

aeqi team
aeqi team --root assistant

`aeqi trust`

Trust-kernel utilities — read or update the on-chain TRUST account for a local runtime entity id. Subcommands cover account inspection, role management, and chain-side actions.

aeqi trust --help

`aeqi audit`

Query the decision audit trail. Filter by root agent, quest, or recency.

aeqi audit
aeqi audit --root assistant
aeqi audit --quest 67-123
aeqi audit --last 20

`aeqi config`

Reload the local configuration after editing aeqi.toml. Subcommands cover showing, validating, and refreshing the daemon's view of config.

aeqi config --help

`aeqi primer`

Emit the session-primer context the daemon would inject at session start. Used by Claude Code's session-start hook; not normally invoked by hand.

aeqi primer

Less-used commands

These exist but most operators won't reach for them:

aeqi run — one-shot agent invocation with a prompt; useful for scripts.
aeqi pipeline — explicit pipeline workflow operations.
aeqi operation — track work across root agents.
aeqi prompt — legacy prompt-template ops (the four primitives are agents/ideas/quests/events; prompt predates the renaming).
aeqi hooks / aeqi hook — Claude Code hook helpers and worker pin.
aeqi done — alternate quest-close path used by hook scripts.
aeqi deps — suggest or auto-apply quest dependencies.
aeqi web — start the web API server standalone (aeqi start is the usual entry point).
aeqi seed — seed local databases for fresh installs.

Run aeqi <cmd> --help for the current flags.

Environment variables

Variable	Used by	Description
`AEQI_API_KEY`	`aeqi chat`, `aeqi mcp`	Account key (`ak_...`). In chat, this is the bearer token. In MCP, it binds the call to your user account.
`AEQI_API_URL`	`aeqi chat`	Hosted platform URL for chat, for example `https://app.aeqi.ai`.
`AEQI_SECRET_KEY`	`aeqi mcp`	TRUST secret key (`sk_...`) that selects and authenticates the TRUST runtime.
`AEQI_PLATFORM_URL`	`aeqi mcp`	Hosted platform URL for MCP validation, for example `https://app.aeqi.ai`.
`AEQI_CONFIG`	self-hosted MCP clients	Path to a local runtime config when not using hosted keys.
`AEQI_AGENT`	MCP clients	Optional client hint. It is not account identity and does not own Quests.
`AEQI_AGENT_ID`	MCP clients	Explicit runtime agent binding for special cases. Leave unset unless you know you need it.

CLI