GitHubJoin the waitlist
AtMem brain

AI Architect · ready to run locally

Build your software system with AI Architect.

Turn requirements into architecture, application code and cloud infrastructure—with testing and deployment guidance along the way.

Run locally today Join the platform waitlistWatch the real workflow

Hosted platform coming soon. Local AI Architect is available now. See current capabilities

Recorded in the real application

See it run locally.

Knowledge assistant · AWS designInstall AI Architect
A saved example, a real model conversation, local emulation, generated Terraform and a downloaded handoff. Recorded locally; no cloud deployment. Edited walkthrough with audio and on-screen explanations. Captions describe each step.
Read the walkthrough transcript
  1. See the design

    Explore the saved knowledge-assistant design, its request path and access boundaries.

  2. Explain the flow

    Read the architect’s explanation of the request flow, access scope and local-test boundaries.

  3. Review requirements

    Review requirements and keep design decisions visible alongside the system.

  4. Run local emulation

    Run the local emulation. Three checks pass against synthetic service state; cloud validation remains.

  5. Review the next test

    Use the results to identify remaining gaps, including real authentication and permission enforcement.

  6. Inspect Terraform

    Inspect the generated infrastructure files before implementation and deployment.

  7. Download handoff

    Download the implementation package. This local demonstration does not deploy cloud resources.

Local emulation uses synthetic service state and model responses. It does not verify real cloud permissions, live connector tenants or model answer quality. The model conversation shown uses the signed-in Codex connection.

  1. 01 Define requirements
  2. 02 Design architecture
  3. 03 Plan implementation
  4. 04 Retain project context

A connected design journey

From first question
to implementation handoff.

Work through the design in stages. Every stage produces something concrete to review, revise and carry into the next conversation.

  1. 01

    Discover

    Start with the outcome you want. Clarify goals, boundaries, stakeholders and constraints, and develop a shared diagram with comments.

  2. 02

    Specify

    Derive numbered requirements from the discussion and review the assumptions behind them.

  3. 03

    Architect

    Compare AWS, Azure, Google Cloud and IBM. Discuss country and residency, then map the design to named services and explicit integration assumptions.

  4. 04

    Prepare to build

    Inspect the specification, cost assumptions, diagram exports, Terraform draft and Spec Kit tasks before downloading the project package.

Coverage depends on the services in your design. Local emulation tests supported application paths; it does not prove a successful cloud deployment.

Walk through a first project →

Requirements with traceability

Less lost context.
More explicit decisions.

An architecture is only useful when its assumptions are clear. Review requirements alongside the decisions and the design elements they affect.

  • Numbered requirements
    Keep functional and non-functional needs visible.
  • Cloud choices explained
    Compare services, residency constraints and integration assumptions.
  • Implementation handoff
    Prepare specifications and tasks for coding agents.
☷ Requirements specificationIllustrative project

Functional & non-functional requirements

  • REQ-001

    Users can authenticate securely before accessing personal records.

  • REQ-002

    The system records service events for operational review.

  • REQ-003

    System components support independent scaling where needed.

  • REQ-004

    Customer records stay within the selected residency region.

↗ Connected decision ADR-002
Managed cloud services proposed, subject to requirement and cost review.

Persistent project context

The design remembers
where it started.

AtMem provides governed memory under the architecture workflow. Keep relevant project context available while maintaining scope, evidence and the ability to review or correct retained records.

Explore the memory foundation ↗
  1. DiscoveryRegional data requirement recorded

    A residency constraint is added to the project context.

  2. ArchitectureCloud design revised

    The relevant requirement informs the comparison of potential services.

  3. ImplementationHandoff references the decision

    The design rationale remains available for review as work proceeds.

  4. Future iterationContext can be revisited

    Earlier constraints and decisions can be inspected and corrected.

Built around modern agent memory

Keep useful context.
Make it inspectable.

AtMem checks scope and policy before a memory reaches an agent. Review what is retained, update preferences and keep project context bounded.

Illustrative example · invented records

Admitted into context

Private spaceagent:research · workspace:acme

Customer prefers async updates over calls.

Renewal date moved to March.

EvidenceView the decision
decision
authorized · policy generation 41
scope
agent:research · workspace:acme · private

Private workspace scope

Kept out of context

WithheldSalary discussion from another workspace

Outside the requested workspace scope.

DecisionView the decision
reason code
scope_boundary_denied
effect
not delivered to the model

WithheldAn earlier note the user deleted

Deleted records do not enter candidate content.

DolphinBench · 600 tasks

Memory measured in actions,
not answers.

Remembering a fact is the start. Using it to send the right message, update a record or schedule a meeting is the test.

Self-tested · submitted for review ↗

AtMem · task success

79.83%

AtMem routed-v4 passed 479 of 600 tool-using tasks across three personas in its self-tested DolphinBench run.

Each square represents 10 tasks; the last filled square is partial. 479 passed; 121 did not.

Morgan85.50%171/200 tasks
Alex76.00%152/200 tasks
Riley78.00%156/200 tasks
Published reference resultsHermes · GPT-5.6 Luna high · task success
  1. AtMemOur run79.83%
    479/600
  2. Mem070.67%
    424/600
  3. Hindsight69.50%
    417/600
  4. Honcho68.50%
    411/600
  5. Built-in memory65.67%
    394/600
  6. Supermemory59.17%
    355/600

Published references alongside our separate self-tested run—not a controlled head-to-head or an official AtMem ranking.

View the pinned reference data ↗

Every task. Every outcome. Open to inspect.

Explore the requests, agent responses, tool traces and recorded grades—not just a headline number.

Explore all 600 results ↗
How to read this benchmark

DolphinBench tests whether an agent applies remembered information in tool-using tasks. A task passes only when every required check passes. Each persona contributes 200 tasks.

The run tested installed AtMem 2.3.10b1 plus research routed-v4 / i3 source. Published 2.3.11b1 remains beta and is a different artifact; this score does not measure that exact published package. Reference rows use the same named Hermes/Luna reader, but are separate published runs; transports, ingestion and execution conditions are not established as identical. No matched comparative advantage or statistical significance is claimed.

Our submission is self-tested and awaiting maintainer review. Public-task subsets informed development; this is not an untouched holdout. The evidence card records configuration, ingestion provenance, offline Morgan/020 reconstruction and the owner-authorized Riley/017 retry after a disk-full memory-only attempt. The original 390/600 evidence remains available separately. Reference snapshot checked 2026-11-01.

Read the technical article ↗ · Read the methodology and download the evidence ↗ · Follow the submission review ↗

Product portfolio

Run it on your machine.

AI Architect brings the design journey together. The memory engine, coding memory, observability and task supervision also work on their own.

python -m pip install --upgrade atmem==2.3.14

Current stableAtMem 2.3.14Beta 2.3.15b1

AtMem Code

  • Authorized coding agents can share project memory through the same project and shared profile. Private profiles remain separate.
  • Explore source-backed structure and fetch selected code evidence on demand. Rich multi-language indexing uses an explicitly approved local worker.
  • Search previous coding experience, inspect recorded outcomes, correct or delete memory, and move encrypted project bundles between clones.

Set up AtMem CodeExplore the benchmark results ↗

Agent continuity

  • Installed document-workflow tests left one published document after crashes both before and after receipt storage.
  • In the recorded public retail fault test, AtMem-connected runs stopped for confirmation instead of repeating the exchange request.
  • Follow instrumented retries and reported costs in AtFlows. Group Timeline events by tool, service, model, type or hour, then click through to the records.

Requires explicit integration with registered tools; not automatic for every agent. Specific acceptance and development results, not a general task-success advantage.

Try a resumable workflowRead the release and evidence

AtFlows

Local traces and cost visibility for each run: context, model exchange, tool calls and recorded results.

AtFlows repository ↗

Also: AtBots, a standalone agent platform with private memory and optional supervision · Explore the portfolio and setup guides →

From conversation to construction

Start with the architecture.

Explore the current local AI Architect, or start with the open-source memory engine.

View installation guide ↗Read the docsView on GitHub ↗