Turning any stream/array/matrix/cloud into new forms.
MorphArray is an open source exploratory project about transforming structured things into useful new forms.
At the broadest level, MorphArray is concerned with streams, arrays, matrices, clouds, relations, signals, documents, tasks, messages, participants, ideas, and other structured collections. The project asks how these structures can be interpreted, recomposed, reduced, mapped, coordinated, or otherwise transformed into new forms.
Some of that work is mathematical. Some is linguistic. Some is analogical. Some is declarative. Some is cognitive. Some is organizational. Some is performed by software, some by humans, some by AI systems, and some by networks containing all three.
The central question is:
How can structured multiplicity be turned into useful new structure?
The primary practical work currently being developed under MorphArray is an architecture for agent orchestration.
This work is expressed through the Orchestration Series, a book-length architectural framework for coordinating heterogeneous participants through human-language scripts, roles, messages, tasks, feedback loops, and delegation.
In the Orchestration Series, the structure being transformed is authored intent.
Instructions, scripts, roles, messages, tasks, and plans are interpreted into performed work. A script becomes a role someone can hold. A role becomes responsibilities. Responsibilities become tasks. Tasks become plans of action. Plans become acts. Acts update state. Updated state informs the next responsible act.
The series develops a vocabulary and pattern language for the recurring structures that appear wherever coordinated work happens: teams, organizations, classrooms, field operations, software systems, and agent networks.
The goal is not to invent coordination from scratch. The goal is to name the primitive patterns that already appear wherever coordinated work is performed, so they can be made explicit, composed deliberately, and eventually implemented in open source tooling.
The Orchestration Series examines concepts such as:
- input scripts
- roles and role assignment
- mutual understanding
- durable messages
- message handling
- messengers
- unique identifiers
- responsive loops
- composer / orchestrator pairs
- delegation
- task management
- plans of action
- role-governed evaluation
- systematic execution
The series treats human language as the shared protocol through which heterogeneous participants can receive authored intent and act on it. A participant may be a human, a software process, an AI agent, or a system composed of many smaller participants. What matters architecturally is that the participant can receive a script, inhabit a role, maintain state, interpret conditions, and perform work within the bounds of the role it was given.
The original writing thread that led to MorphArray was the Analogy Series.
The Analogy Series was more abstract, exploratory, and philosophical, and it includes some early, imperfect understandings of inference that reflect the project’s discovery process. It traced a path from SwiftUI's “views are values” model into broader questions about analogy, latent structure, cognitive primitives, LLM reasoning, declarative transformation, and modular reasoning topologies.
That work explored questions such as:
- How do disposable immutable snapshots become efficient reconciliation engines?
- What is analogy as a proportional, structure-preserving mapping?
- Can analogy be understood as a primitive of thought?
- What does the latent domain of analogy emergence look like in frontier LLMs?
- Can modular reasoning topologies outperform monolithic approaches?
- What happens when natural language is treated as an already-declarative grammar?
- Can kernel reduction expose hidden structure in written thought?
The Analogy Series remains an important origin point for MorphArray. It explored transformation through structural correspondence: one form becoming another through preserved relations.
The Orchestration Series continues the broader project in a more operational direction: authored intent becoming performed work through interpretation, role-taking, task management, state awareness, and coordinated action.
MorphArray is moving toward a practical architecture for transforming structured systems through inference, cognition, coordination, and composition.
The long-term direction includes:
- a pattern language for agent orchestration
- human-language input scripts as portable coordination artifacts
- role-based execution models
- durable message passing between participants
- task-state and responsibility-field tracking
- recursive composer / orchestrator structures
- responsive loops for adaptive execution
- lightweight tools for assembling and carrying structured context
- prototypes for coordinating AI agents, software tools, and human operators
- continued exploration of analogy, reduction, declarative transformation, and structure-preserving mappings
The project treats AI agents not as isolated chatbots, but as participants inside larger coordinated systems. The architectural question is how to give those participants roles, context, boundaries, responsibilities, messages, feedback, and the ability to adapt without losing alignment with the larger work.
MorphArray also includes early tooling around the Mental Stack workflow.
The companion VS Code extension in stack/ helps assemble structured context and copy a clean concatenated prefill to the clipboard. This supports a practical workflow for starting fresh LLM sessions with purposeful context instead of relying on drifting conversational memory.
The Mental Stack tooling is an early utility layer for the larger project: a way to package working context so it can travel cleanly across sessions, tools, and participants.
-
MorphArray site:
https://morpharray.github.io/morpharray/index.html -
MorphArray library / project homepage:
https://morpharray.github.io/morpharray/morpharray_library.html -
Orchestration Series:
https://morpharray.github.io/morpharray/orchestration/dist/index.html
MorphArray is currently in active conceptual and architectural development.
The Orchestration Series is the main active writing project. Tooling and prototypes are expected to evolve around the framework as the architecture becomes more explicit.
Current project status:
- Orchestration Series in active development
- Analogy Series preserved as earlier conceptual foundation
- Mental Stack VS Code extension available as early workflow tooling
- Future work aimed at agent orchestration prototypes and coordination patterns
- Broader MorphArray theme maintained around turning structured multiplicity into useful new forms
Contributions, issues, discussion, and pull requests are welcome.
Useful areas of collaboration include:
- feedback on the Orchestration Series
- examples of coordination patterns from real working systems
- agent orchestration design patterns
- durable message and task-state schemas
- role and delegation models
- Mental Stack workflow improvements
- lightweight prototypes for multi-agent coordination
- examples of human / AI / software orchestration in practice
- examples of analogy, reduction, transformation, or structure-preserving mappings
- X / Twitter: @BenUm432
MorphArray is about turning structured things into new forms.
The current active path is orchestration: how authored intent becomes performed work through interpretation, roles, messages, task state, feedback loops, and responsible action.