DEV Community

Empire Labs Pty Ltd
Empire Labs Pty Ltd

Posted on • Originally published at dev.to

Announcing the Empire Stack: ACI + AIP + AJSON — Three Layers for Autonomous Agent Commerce

#agents #opensource #standards #python

Announcing the Empire Stack: ACI + AIP + AJSON

Three open-source specifications. One complete stack. Zero vendor lock-in.

Autonomous agents are coming for your APIs. They're coming for your pricing pages. They're coming for your contracts. But there's a problem: today's web wasn't built for them.

A human can look at a landing page, click "Pricing," read a table, and decide. An agent can't do that reliably — not without scraping, guessing, hallucinating, and hoping.

We've spent the past year building the missing infrastructure. Three specifications that form a complete stack for autonomous agent commerce:

Layer Spec Job
🔍 Discover ACI Tell agents who you are and what you offer
🤝 Interact AIP Negotiate contracts and execute actions
✍️ Author AJSON Write clean manifests that compile to canonical JSON

Each solves one problem. Together, they let an agent go from "I've never heard of this company" to "I've signed a contract and executed a transaction" — without a human in the loop.

The Problem in One Paragraph

An autonomous agent today faces three broken layers:

  1. Discovery is broken. There's no standard for an organization to declare "here's who I am, here's what I can do, here's how to authenticate." Agents scrape HTML and pray.
  2. Interaction is broken. There's no standard for an agent and an organization to negotiate terms, sign contracts, execute actions, and settle payments. Every integration is custom.
  3. Authoring is broken. JSON is the wire format for agents, but writing JSON by hand (or by agent) is error-prone. No comments, no refs, no multi-line strings.

Each of these is a solvable problem. The trick is solving them together so they compose.

Layer 1: ACI — Autonomous Company Interface

ACI is the discovery layer. It answers three questions:

  • Who are you? (identity, jurisdiction, identifiers like ABN/ACN/DUNS)
  • What can you do? (capabilities, endpoints, auth requirements)
  • Where do I find the details? (pointers to llms.txt, agent manifests, knowledge bases)

It's designed to be static-hosted — a few JSON files behind /.well-known/aci/ or linked from /llms.txt. Zero server-side logic. Zero build step.

# Install the validator
pip install aci-spec

# Discover what an ACI-compatible organization exposes
aci-explore empirelabs.com.au

# Validate their deployment
aci-validate empirelabs.com.au
Enter fullscreen mode Exit fullscreen mode

We've already dogfooded ACI on empirelabs.com.au — it's Level 3 compatible with all five manifest types.

Want to adopt ACI? Fork the deployment template, replace the placeholders, and deploy to GitHub Pages in 5 minutes.

Layer 2: AIP — Agent Interaction Protocol

AIP is the interaction layer. It sits on top of ACI and answers: "Now that you know who I am and what I offer, how do we actually do business?"

AIP defines:

  • Action Schemas — typed input/output contracts for every capability (OpenAPI-like, but agent-native)
  • Contract Templates — machine-readable terms: price, SLA, retries, jurisdiction, dispute process
  • Negotiation Flows — offer, counter, accept, reject between two autonomous parties
  • Execution Bindings — how to actually invoke an action once terms are agreed
  • Settlement Hooks — what happens after execution (payment, receipt, evidence)

It ships with a Go reference implementation that compiles to a single binary:

go install github.com/narko4u/aip-spec/cmd/aip@latest
aip negotiate --template contract.json --counterparty acme.corp
Enter fullscreen mode Exit fullscreen mode

AIP is still draft (v0.1), but the architecture is locked and the Go implementation is functional. We're looking for early feedback from teams building multi-agent systems.

Layer 3: AJSON — Agent JSON

AJSON is the authoring layer. It's a superset of JSON purpose-built for writing manifests by hand (or by agent) that need to compile to clean, canonical JSON.

Standard JSON is a terrible authoring format — no comments, no multi-line strings, no reusable schemas. YAML has those things but introduces its own problems (yes/NO/true/false traps, indentation fragility, multiple valid representations of the same data).

AJSON gives you YAML's ergonomics with JSON's determinism:

// AIP Contract in AJSON
{
  "contract_name": "Data Processing",
  "description": "A data processing contract between two autonomous agents.",
  // Reusable terms template
  "&terms": {
    "max_retries": 3,
    "sla_seconds": 60,
    "jurisdiction": "AU"
  },
  "contract_terms": {"*terms": null}
}
Enter fullscreen mode Exit fullscreen mode

Compiles to clean, canonical JSON:

{"contract_name":"Data Processing","contract_terms":{"jurisdiction":"AU","max_retries":3,"sla_seconds":60},"description":"A data processing contract between two autonomous agents."}
Enter fullscreen mode Exit fullscreen mode 
# Install
pip install ajson-spec

# Compile AJSON to canonical JSON
ajson compile contract.ajson -o contract.json
Enter fullscreen mode Exit fullscreen mode

Zero dependencies. Pure Python stdlib. Every valid JSON file is valid AJSON — zero migration cost.

How They Fit Together

Here's the end-to-end flow:

  1. Agent discovers Organization X via ACI. It fetches identity.json and capabilities.json. It learns: "X is an Australian company with ABN XX XXX XXX XXX. They offer data processing and identity verification. Their agent endpoint is at https://x.corp/agent."

  2. Agent negotiates with Organization X via AIP. It selects a contract template from X's capabilities, makes an offer, receives a counter-offer with pricing and SLA terms, and signs. The signed contract becomes an AJSON-authored receipt.

  3. Agent authors the contract in AJSON — with inline comments, reusable terms, and multi-line descriptions. It compiles to canonical JSON, signs it, and sends it to X's agent endpoint.

ACI discovers, AIP negotiates, AJSON writes it all down.

Each layer is independently useful. ACI alone gives you agent-discoverable org identity. AJSON alone gives you better manifest authoring. AIP alone gives you agent negotiation. But together, they're the stack.

What We Need From You

These specs are draft — and we want them to become community standards, not Empire Labs standards. Here's how you can help:

Adopt ACI

Fork the template, add your organization's identity and capabilities, and deploy. Takes 5 minutes. Run aci-validate on your site — if it passes, you're part of the growing network.

Build with AJSON

Try writing your next agent manifest in AJSON. pip install ajson-spec. Add comments. Use references. You'll never go back to raw JSON for authoring.

Give feedback on AIP

AIP is early (v0.1 outline). Read the spec outline, open an issue with your use case, or contribute to the Go reference implementation.

Star the repos

AJSON, ACI, and AIP each need visibility. A star helps more than you think.

What's Next

We're building these in public:

  • AJSON v0.2 — Inline schema annotations (type, desc, default)
  • ACI v1.0 — After three independent implementations ship
  • AIP v0.2/v1.0 — From outline to actionable spec
  • WitnessOS — Commercial governance runtime that enforces ACI/AIP contracts
  • Grant funding — We've applied to the Sovereign Tech Fund to support AJSON's continued development

The Empire Stack is open, free, and built for the agent-native web. Fork it, contribute, or just watch — but the agents are coming, and now they have a way in.

Built by Empire Labs Pty Ltd | Maintained by **Sovereign**

diff --git install: pip install ajson-spec | pip install aci-spec | go install github.com/narko4u/aip-spec/cmd/aip@latest

🍻 Buy the Empire a pint

Top comments (0)