DEV Community: Empire Labs Pty Ltd

We Built the Missing Layer for AI Agents — Here's What It Looks Like in Action (🚀 Launch Video)

Empire Labs Pty Ltd — Mon, 20 Jul 2026 12:16:54 +0000

We Built the Missing Layer for AI Agents

Introducing the Autonomous Company Interface (ACI)

An AI agent can call thousands of APIs, write code, query databases, and invoke language models. But until now, there's been one thing it couldn't do reliably:

Determine what an organization is, what it offers, and how to trust it — without scraping or bespoke integration.

🎬 The Launch Video

https://github.com/narko4u/aci-spec/releases/download/aci-launch-video-v1/Empire_Labs_ACI_Cinematic_Explainer.2.mp4

2-minute explainer — built with AI-generated script, voiceover, and visuals

(replace URL with your browser player if it doesn't auto-embed)

What Is ACI?

ACI (Autonomous Company Interface) is an open specification that lets organizations describe themselves in machine-readable format — designed specifically for autonomous agents.

It's a five-manifest system that any organization can publish alongside their website:

Manifest	What it tells an agent
Identity	Who you are — name, jurisdiction, verifiable identifiers
Capability	What you offer — products, services, documentation
Knowledge	What your domain is — concepts, terminology, relationships
Trust	Why you're trustworthy — certifications, attestations, linked evidence
Agent	How to interact — endpoints, auth requirements, interaction methods

An agent discovers your first manifest via /llms.txt and follows links to the rest. No scraping. No guessing.

Why This Exists

OpenAPI describes interfaces — how to call an endpoint. But agents need organizational context first:

Who owns this API?
What business is this company in?
Are they certified or regulated?
Can I trust their claims?
Do they even want autonomous agents interacting with them?

ACI bridges that gap. It's the layer between "I found a website" and "I can safely do business here."

🚀 How You Can Adopt ACI Today

The fastest path — fork the template (it takes 5 minutes):

👉 GitHub: narko4u/aci-pages-template

This GitHub Pages template includes everything: identity.json, capabilities.json, /llms.txt, and a landing page. Replace the placeholders, enable Pages, and you're live. Zero build tools required.

Or explore a live example:

python3 -c "$(curl -s https://raw.githubusercontent.com/narko4u/aci-spec/main/demo/aci-explorer.py)" empirelabs.com.au

This zero-dependency script discovers all five manifests at empirelabs.com.au — our own Level 3 implementation.

The Path Forward

ACI is currently Draft v0.9 — published as an open specification under CC BY 4.0, with MIT-licensed tools. Empire Labs Pty Ltd is the initial steward, with a governance path to transition to a neutral foundation.

The spec repository: github.com/narko4u/aci-spec

The v1.0 milestone requires three independent implementations. I'm actively seeking organizations to implement ACI, validate the draft, and help shape the standard. If that sounds like you, jump in.

ACI agents don't scrape. They read.

🙏 If this resonates: Fork the template. Deploy it. Open an issue with feedback. And if you know someone building in the agentic space — tag them. The standard only matters if we build it together.

The Missing Layer for Autonomous Agents: Introducing the Autonomous Company Interface (ACI)

Empire Labs Pty Ltd — Sun, 19 Jul 2026 04:53:18 +0000

The Missing Layer for Autonomous Agents: Introducing the Autonomous Company Interface (ACI)

The Problem

An AI agent can call thousands of APIs. It can write code, query databases, and invoke language models. But there's one thing it cannot do reliably:

Determine what an organization is, what it offers, and how it should be trusted — without scraping, inference, or bespoke integration.

When an agent reaches a company website, it sees pages designed primarily for humans — not a stable organizational contract. It can scrape text and make inferences, but it cannot reliably distinguish between a product, a pricing tier, a support contact, or a certification. It cannot reliably determine what identity claims, attestations, certifications, and supporting evidence the organization publishes, what APIs it exposes, or even which of its AI indexing tools are meant for autonomous consumption versus human reading.

We built an entire web for humans — semantic markup, structured data, accessibility standards. But we left autonomous agents to fend for themselves.

Why OpenAPI Isn't Enough

OpenAPI is excellent. It describes HTTP APIs with precision. But it describes interfaces, not organizations. An API definition tells you how to call an endpoint. It does not tell you:

Which organization owns this API
What business the organization is in
Whether the organization is certified or regulated
Where to find its other manifests
Which of its offerings are available to autonomous agents
What trust mechanisms it supports

An agent trying to decide whether to interact with a company needs organizational context first, API details second. That's the gap ACI fills.

What ACI Provides

ACI (Autonomous Company Interface) is an open specification that lets organizations describe themselves in a machine-readable format designed for autonomous agents.

The core model is five manifest types:

Manifest	Purpose
Identity	Who the organization is: name, jurisdiction, identifiers, contact
Capability	What the organization offers: products, services, documentation
Knowledge	What the organization knows: domain concepts and relationships
Trust	How organizational claims are supported: assertions, certifications, attestations, and evidence
Agent	How autonomous agents can interact: endpoints, authentication requirements, and capabilities

In the reference implementation, each manifest is a linked JSON document. An agent discovers the first one - typically via /llms.txt - and follows links to the rest.

A Concrete Example

Consider a fictional company called NovaDynamics. At https://novadynamics.example/llms.txt, an agent finds:

# AI manifests

- [Identity Manifest](https://novadynamics.example/identity.json)
- [Capability Manifest](https://novadynamics.example/capabilities.json)
- [Knowledge Manifest](https://novadynamics.example/knowledge.json)
- [Trust Manifest](https://novadynamics.example/trust.json)
- [Agent Manifest](https://novadynamics.example/agents.json)

Fetching the identity manifest reveals:

{
  "manifest_version": "0.9.0",
  "last_updated": "2026-07-19T00:00:00Z",
  "publisher": "NovaDynamics Inc.",
  "jurisdiction": "US-DE",
  "website": "https://novadynamics.example",
  "description": "Autonomous infrastructure operations platform",
  "identifiers": [
    {
      "id": "org.novadynamics",
      "type": "domain",
      "value": "novadynamics.example"
    }
  ],
  "discovery": {
    "llms-txt": "https://novadynamics.example/llms.txt",
    "capability-manifest": "https://novadynamics.example/capabilities.json",
    "knowledge-manifest": "https://novadynamics.example/knowledge.json",
    "trust-manifest": "https://novadynamics.example/trust.json",
    "agent-manifest": "https://novadynamics.example/agents.json"
  }
}

The agent now has a stable identity anchor and machine-readable paths to NovaDynamics' capabilities, knowledge, trust assertions, and exposed agents. It can build an organizational profile from published contracts rather than site-specific scraping.

The Conformance Path

ACI defines three incremental conformance levels:

Level 1 — Discovery: Identity, Capability, and an operational discovery chain
Level 2 — Understanding: Knowledge, Trust, and resolved cross-references
Level 3 — Interaction: Agent Manifest, an operational interaction method, and a validator score of at least 90

A pre-conformance starter — publishing only an identity manifest and /llms.txt — is a useful first step, but is not a formal conformance level.

Level 1 takes about five minutes to implement. Create an identity.json, a capabilities.json, and an /llms.txt that links to them. Done.

How to Implement ACI Level 1 in Five Minutes

The fastest path — fork the template:

GitHub: narko4u/aci-pages-template

This GitHub Pages template includes everything you need: identity.json, capabilities.json, /llms.txt, and a landing page. Replace the placeholders with your organization's details, enable Pages, and you're live. No build tools required.

Or, do it manually:

Create identity.json with your organization name, website, identifiers, and a short description
Create capabilities.json listing your products or services
Create /llms.txt pointing to both manifests
Run the ACI validator to confirm:

python3 validator/validate.py https://yourdomain.com

See a live example:

# Zero-dependency explorer — discover what Empire Labs exposes
python3 demo/aci-explorer.py empirelabs.com.au

What This Enables

Once ACI is adopted broadly, an autonomous agent can:

Discover an ACI-enabled organization's published manifests without site-specific scraping
Understand its declared products, services, capabilities, and domain vocabulary
Evaluate identity claims, trust assertions, and linked evidence
Discover declared agent endpoints and authentication requirements
Supply structured organizational data to external policy and governance systems

This is the missing layer for autonomous commerce, supply chain automation, compliance checking, and agent-to-agent coordination at scale.

The Open Standard

ACI is published as an open draft specification under CC BY 4.0. The validator, schemas, and examples are MIT-licensed. Empire Labs serves as the initial steward. The governance documents define a path to transfer ACI to a neutral foundation or standards body after v1.0 and the published independence criteria are met.

The repository is at: https://github.com/narko4u/aci-spec

The specification, validator, and full examples are available now.

ACI is currently in Draft v0.9. The path to v1.0 requires three independent implementations, community feedback, and a stable core. We are not declaring a finished standard — we are proposing one, and inviting the community to shape it.

Empire Labs Pty Ltd is the initial steward of the ACI draft specification.

Next: Fork the ACI Pages Template, replace the placeholders, deploy it through GitHub Pages, validate the result, and submit your implementation to the Independent Implementation Tracker. Help us reach three independent implementations for ACI v1.0.