Introducing Morph: an agent that can change how it thinks

Morph

What if an AI agent didn't have to think with the same mind for every task?

Today, Phylogeny AI introduces Morph, our first open research project.

Phylogeny is a community AI lab exploring what artificial intelligence could become when we stop treating today's architectures as fixed boundaries — experimenting, building, and sharing in the open.

Morph starts with a simple idea:

An agent should be able to change what it is made of while it is working.

Beyond the single-model agent

Most agents are built around a single language model. Tools are attached to it, prompts shape its behavior, and the same model remains responsible for everything from planning to coding to research.

Morph takes a different approach.

Instead of giving an agent one permanent intelligence, we give it access to a population of specialized capabilities.

A coding model can take over when code needs to be written.
A reasoning model can be activated for a difficult decision.
A vision capability can appear when an image needs to be understood.

And when a capability is no longer useful, it doesn't have to remain active.

The agent changes its cognitive configuration to fit the task.

Capabilities have a lifecycle

Morph is not simply a multi-model agent.

Its runtime treats capabilities as things that can appear, disappear, sleep, and reactivate over time.

A capability can move through states such as:

OFF → LOADING → ACTIVE → SLEEPING → UNLOADED

The runtime is responsible for discovering what is available, deciding what should be active, moving context between capabilities, and coordinating their next actions.

This creates a different kind of agent architecture:

the intelligence is no longer static — it becomes a runtime-managed resource.

Designed for constrained machines

This becomes particularly interesting outside the datacenter.

On a local machine or an edge device, RAM and VRAM are finite resources. Keeping several models loaded simultaneously can quickly become impractical.

Morph explores whether models could instead behave more like processes:

• load a specialist when it is needed
• share only the context it requires
• put inactive capabilities to sleep
• unload weights to reclaim memory
• reactivate them when the task changes

This also opens questions around isolation and permissions.

A coding capability might run inside a sandbox with access to files and a shell, while a web research capability receives network access but nothing else.

Different capabilities could therefore have different trust boundaries, not just different prompts.

The real research question

Morph is not built around the assumption that dynamic model orchestration is automatically better.

The interesting question is whether it can create a measurable advantage.

The first prototype will be a small Python runtime built around:

• interchangeable models
• a capability orchestrator
• lifecycle and resource management
• shared context
• permission boundaries
• memory and latency measurements
• model-call and cost tracking

We will compare Morph against simpler architectures:

one model + tools
vs.
fixed multi-model orchestration
vs.
dynamic capability lifecycles

If Morph performs better, we want to understand why.

If it performs worse, that is equally useful.

An experiment in the open

Morph is intentionally starting small.

We are not presenting a finished architecture or claiming that agents should work this way.

We are asking a question:

What happens when an AI agent can change its own computational composition as the problem changes?

The answer will come from prototypes, measurements, failures, and experiments.

Morph is the first research direction from Phylogeny AI.

We're building it in the open because the architecture itself is only half of the experiment.

The other half is seeing what the community discovers with it.