Blog Docs Sign in
technical

The IMCO Framework: A Standard for Agentic Systems

Every AIUS component follows the IMCO pattern: Inputs, Memory, Compute, Outputs. This standardization enables agent interoperability and explainability.

A
AIUS Team
architecture imco agents framework

As we build agentic systems, we need a common language for how agents think and work. At AIUS, we've developed the IMCO framework as our foundational pattern.

What is IMCO?

IMCO stands for:

Inputs
Memory
Compute
Outputs

Or, more fully:

Input Sensors
Memory
Compute
Output Tools

This simple pattern creates a universal contract for how agents receive information, maintain context, perform work, and produce results.

The Pattern in Action

Every component in AIUS follows this structure. Here's what each layer represents:

Inputs

What data does the agent receive?

  • Database queries and schema definitions
  • API responses and webhooks
  • File contents and document parsing
  • User prompts and natural language
  • System context and environment variables

Inputs are the raw material — the signals the agent must interpret to understand the task at hand.

Memory

What does the agent remember?

  • Conversation history and dialogue state
  • Previous computations and cached results
  • Learned patterns and heuristics
  • Organizational context and business rules
  • Domain knowledge and best practices

Memory is the agent's working memory — the context that makes every decision informed rather than isolated.

Compute

What does the agent do?

  • Data processing and transformation
  • Pattern recognition and anomaly detection
  • Decision making and reasoning
  • Code generation and refactoring
  • Analysis and statistical modeling

Compute is where intelligence happens — the transformation of inputs and memory into actionable insights.

Outputs

What does the agent produce?

  • SQL queries and data transformations
  • Code changes and pull requests
  • Reports and visualizations
  • Recommendations and action items
  • API calls and webhooks

Outputs are the deliverables — the tangible results that create value.

Why This Matters

Explainability

When every agent follows IMCO, we can trace exactly how a decision was made:

  • What inputs were considered? Full visibility into data sources
  • What memory was accessed? Clear audit trail of context
  • What computation occurred? Transparent decision logic
  • What output was generated? Reproducible results

In a world where AI decisions increasingly impact business outcomes, explainability isn't optional — it's essential.

Interoperability

Standardized interfaces mean agents can work together:

  • Agent A's outputs become Agent B's inputs
  • Shared memory layers enable coordination
  • Common compute patterns allow reuse
  • Modular components compose into complex workflows

The power of agents compounds when they can collaborate seamlessly. IMCO makes that possible.

Modularity

IMCO enables plug-and-play architecture:

  • Swap input sources without changing compute
  • Upgrade memory systems independently
  • Add new output formats easily
  • Mix and match components across use cases

Build once, reuse everywhere. That's the promise of modular agentic systems.

In Practice

Here's how IMCO works in a data engineering agent:

Inputs: Schema definition, business requirements
Memory: Previous transformations, team conventions
Compute: Generate dbt model, add tests, create docs
Outputs: Pull request with generated code

The same pattern applies across every AIUS component — from data cleaning agents to analytics agents to reporting agents. The interface stays consistent; the implementation adapts to the task.

The Long-Term Vision

We're not just using IMCO internally. We want to establish it as an industry standard.

Just as REST became the standard for APIs, IMCO could become the standard for agentic systems.

This would enable:

  • Cross-platform agent compatibility — Build agents that work anywhere
  • Shared tooling and infrastructure — Common debugging, testing, and deployment tools
  • Better debugging and observability — Standardized logging and tracing
  • Faster innovation in the space — A shared language accelerates progress

Standards unlock ecosystems. We believe IMCO can unlock the agentic ecosystem.

Join the Conversation

We're open-sourcing our IMCO implementation. We want your feedback, your use cases, and your contributions.

Together, we can build the foundation for the agentic future.

This is the first in a series of technical deep-dives into AIUS architecture. Subscribe to our blog for more.