ACE 1.1 Code Intelligence in Atrium: ask what changed, inspect the supported answer and its governed evidence, and see why it matters.

What ACE does

Most AI products answer the prompt in front of them. The human still has to reconstruct the past, decide which expertise is missing, coordinate people and agents, notice contradictions, and remember what happened afterward.

ACE owns that loop:

understand → reason → decide → coordinate → act with authority → verify → learn

Its first complete experience is the Intelligence Builder:

Choose Intelligence → Connect → Map → Watch → cited Brief → Activate → Learn

1. Choose Intelligence. Start with the decision context you want to improve.
2. Connect. Bind only the sources and permissions you approve.
3. Map. Review an editable, cited concept model of entities, relationships, and exclusions.
4. Watch. Define what matters, what counts as change, and who should know.
5. Brief. Receive source-grounded intelligence with uncertainty, disagreement, and relevance.
6. Activate. Approve the exact plan and effects; ACE keeps watching under that authority.
7. Learn. Return decisions and outcomes as governed proposals without rewriting history.

Builders do not need to hand-author Domain Pack JSON or learn compiler mechanics before receiving first intelligence value. Generated material passes the same fail-closed compatibility, conformance, authority, and activation boundaries as expert-built material.

The current published stable package and public-index install is ace-core==1.0.3. This source tree is the local ace-core==1.1.0 ACE 1.1 Code Intelligence release candidate; it has passed its local candidate gate but has not yet been tagged or published.

Two connected loops

flowchart LR
    subgraph R["Decision reasoning"]
        P["problem"] --> C["classify + compose"] --> D["deliberate"] --> REC["recommendation"]
    end
    subgraph I["Continuous intelligence"]
        S["authorized sources"] --> O["observations + entities"] --> CH["signals + shifts"] --> B["cited Brief"]
    end
    REC --> DEC["governed Decision"]
    B --> DEC
    DEC --> W["people + agents + tools"] --> V["verification"] --> OUT["Outcome"]
    OUT -. "correction + governed feedback" .-> C
    OUT -.-> CH

Decision reasoning begins when a person or product brings a problem. ACE selects and coordinates a problem-fit approach, records what shaped the result, and preserves the Decision for inspection and correction.

Continuous intelligence begins with authorized sources. ACE admits observations, updates entity state, detects material change, routes attention, and assembles a cited Brief. Either loop can invoke the other through the same governed Decision and Outcome model.

What you can build

• Domain intelligence applications for markets, world events, code, products, research, operations, or any other bounded decision context.
• Decision systems whose evidence, reasoning, authority, and outcomes must survive beyond one model response.
• Governed AI backends that need provider-neutral inference, scoped action, append-only state, replay, human disposition, and attributable feedback.

ACE supplies both the Intelligence Builder experience and the governed runtime beneath it. Specialized products remain the hands. ACE keeps them working from the same evidence and Decision.

Explore the Intelligence OS and Builder →

Trustworthy intelligence is the feature

ACE wraps a lean coordinating Core around specialized reasoning and Intelligence capabilities; the octopus is useful inspiration for that shape, not a literal ratio of code or intelligence. The cognitive runtime remains visible inside the product: Human ↔ ACE ↔ LLM, A nine-layer cognitive pipeline, and Dynamic composition describe how ACE assembles and governs reasoning. Core + Intelligence + Domain Packs make that machinery reusable without moving domain nouns, executable behavior, or authority into the kernel.

flowchart TB
    SRC["sources + systems of record"] --> INT["Intelligence<br/>observe · map · detect · brief"]
    INT --> CORE["Core<br/>reason · decide · authorize · remember"]
    PACK["Domain Packs<br/>inert vocabulary + policy"] -.-> INT
    CORE --> TOPIC["bounded decision context"]
    TOPIC --> PART["people + governed agents"]
    PART --> TOOLS["Figma · Codex · CRM · BI · ERP · domain tools"]
    TOOLS --> OUT["artifacts · effects · measures · corrections"]
    OUT --> CORE

• Core owns cognition and control: identity, immutable and temporal state, reasoning, authority, Decisions, Outcomes, and receipts.
• Intelligence owns sensing and orientation: Observation, Entity, Shift, Signal, Case, Brief, monitoring, routing, synthesis, and pack conformance.
• Domain Packs own vocabulary and policy: independently versioned, inert declarative data.
• Adapters own bounded I/O: exact source or destination access under separate authority.
• Atrium is the human control plane: it reads and acts through the same ACE API, never a second state or authority system.

ACE provides graph-grounded, calibrated foresight. It projects conditional consequences of decisions, exposes the mechanisms and uncertainty behind them, observes what actually happens, and uses resolved forecasts to improve later reasoning.

Read the architecture → · Inspect trust boundaries →

One stack, many intelligence systems

ACE is infrastructure for building intelligent systems around consequential work—not a collection of content-generation point solutions.

Solution Bundles combine exact Packs, adapters, monitors, applications, outcome mappings, and conformance fixtures. They specialize ACE without forking its durable intelligence, reasoning, or authority model.

Code Intelligence: ACE’s first recursive proof

Code Intelligence has passed for a local 1.1 release candidate. Issue #194 and publication remain open, and the Release Spine Project stays Now until the public four-record closeout. Software makes the complete ACE loop measurable: Decisions connect to repositories, symbols, dependencies, tests, reviews, releases, incidents, and later Outcomes.

ACE separates three improvement loops:

1. Complete the current change. Detect missed consumers, tests, migrations, documentation, acceptance evidence, or stale concurrent work; perform a bounded linked repair; reverify.
2. Improve the codebase. Present reusable architecture opportunities separately with semantic evidence, ownership, alternatives, blast radius, migration, verification, and rollback.
3. Improve future work. Use repeated verified experience to propose better agent definitions, procedures, context policy, routing, frameworks, Pack policy, or verification; evaluate and activate the exact revision under explicit authority.

ACE Builds ACE applies these loops to ACE's own roadmap and repository under matched coding-agent controls. ACE may inspect, diagnose, coordinate, propose, and verify its own work. Repository access never grants approval, merge, release, deployment, policy, promotion, or expanded authority.

Read the governed Code Intelligence contract →

Useful for one. Compounding for many.

ACE 1.0.3 is stable for the documented single-user, single-node topology. The same semantic kernel is designed to grow from a private workspace into shared and federated intelligence:

one owner
  + invited participants
  + shared Topics and explicit roles
  + organization policy and relationships
  + bounded federation
= the same durable intelligence, with more coordination and boundaries

Governance scales with consequence, not merely seat count. A high-impact action may require review for one person; a low-risk investigation can remain lightweight inside a large organization. Adding the second person or the ten-thousandth must not invalidate existing identity, provenance, Decisions, memory, ownership, or receipts.

Read the product vision → · Read the scale-invariant architecture →

Quickstart

Install the stable package:

python -m pip install ace-core==1.0.3
python -c "import ace; print(ace.__version__)"
ace --help

This repository currently identifies a local ace-core==1.1.0 release candidate. Do not request 1.1.0 from the public index until its tag, publication, clean-install reproduction, issue #194, Project state, release evidence, and ROADMAP have been reconciled.

Or run the complete self-hosted Intelligence OS. You need macOS or Linux, Git, Python 3.12, uv, Docker Engine with Compose v2, and credentials for one supported provider.

git clone https://github.com/augmented-cognition-engine/core ace
cd ace
uv sync
uv run ace setup

Then verify and open Atrium:

uv run ace doctor
uv run ace atrium

Follow the complete installation guide →

What is real today

ACE 1.0 is stable for the documented single-user, single-node topology; 1.0.3 is the recommended patch release.

The stable 1.0 claim is deliberately bounded. ACE does not claim distributed operation, hostile extension isolation, arbitrary web access, autonomous authority, universal connectors, managed hosting, or beneficial impact beyond its frozen evaluation evidence.

See exact capability maturity → · Inspect 1.0 public acceptance →

Choose your path

The documentation index routes product builders, operators, extension authors, contributors, and reviewers without turning this README back into the entire manual.

License and stewardship

ACE Core is Apache-2.0. See LICENSE and NOTICE. Separately distributed extensions and Domain Packs declare their own licenses. The default stack runs SurrealDB separately under its own license.

ACE was created and is initially stewarded by Edwin Amirian. QueryLabs is the founding sponsor.