Struct Synthesizer 

pub struct Synthesizer { /* private fields */ }

The Synthesizer agent — emergent collective intelligence.

Implementations

impl Synthesizer

pub fn new(position: Position) -> Synthesizer

pub fn with_seed(position: Position, seed: u64) -> Synthesizer

Create a synthesizer with a deterministic ID (for testing).

pub fn insights_produced(&self) -> u64

Total insights produced in lifetime.

Trait Implementations

impl Agent for Synthesizer

fn id(&self) -> AgentId

The agent’s unique identity.

fn position(&self) -> Position

The agent’s current position in the substrate.

fn set_position(&mut self, position: Position)

Set the agent’s position.

fn agent_type(&self) -> &str

The agent’s type name (for display and logging).

fn tick(&mut self, substrate: &dyn Substrate) -> AgentAction

Execute one tick of the agent’s lifecycle.

fn age(&self) -> u64

How many ticks this agent has been alive.

fn profile(&self) -> AgentProfile

Build a profile describing this agent’s capabilities.

fn export_vocabulary(&self) -> Option<Vec<u8>>

Export this agent’s vocabulary as serialized bytes. Returns None if the agent has no vocabulary to export.

fn integrate_vocabulary(&mut self, _data: &[u8]) -> bool

Integrate foreign vocabulary from serialized bytes. Returns true if integration succeeded.

fn evaluate_symbiosis(&self, _other: &AgentProfile) -> Option<SymbiosisEval>

Evaluate whether to absorb another agent as a symbiont.

fn absorb_symbiont(&mut self, _profile: AgentProfile, _data: Vec<u8>) -> bool

Absorb another agent’s profile and vocabulary data as a symbiont. Returns true if absorption succeeded.

fn permeability(&self) -> f64

Current boundary permeability (0.0 = rigid, 1.0 = fully dissolved).

fn modulate_boundary(&mut self, _context: &BoundaryContext)

Adjust boundary permeability based on environmental context.

fn externalize_vocabulary(&self) -> Vec<String>

Return vocabulary terms to externalize (reinforce in the substrate).

fn internalize_vocabulary(&mut self, _terms: &[String])

Absorb nearby concept terms from the substrate.

fn vocabulary_size(&self) -> usize

Return the size of this agent’s vocabulary (for metrics).

impl Apoptose for Synthesizer

fn self_assess(&self) -> CellHealth

Evaluate own health and usefulness.

fn prepare_death_signal(&self) -> DeathSignal

Package final state into a death signal before destruction.

fn should_die(&self) -> bool

Whether the agent should initiate death.

fn trigger_apoptosis(self) -> DeathSignal

where Self: Sized,

Initiate orderly self-destruction (for concrete types).

impl Digest for Synthesizer

type Input = String

The raw input to consume. Ownership is transferred — the input is destroyed.

type Fragment = String

Structural fragments extracted during digestion.

type Presentation = Vec<String>

What is presented to other agents after digestion.

fn engulf(&mut self, input: String) -> DigestionResult

Engulf: take ownership of input.

fn lyse(&mut self) -> Vec<String>

Lyse: break the engulfed material into fragments.

fn present(&self) -> Vec<String>

Present: expose fragments on the agent’s surface.

fn digest(&mut self, input: Self::Input) -> Self::Presentation

Run the full digestion cycle: engulf → lyse → present.

impl Emerge for Synthesizer

type EmergentBehavior = Vec<InsightData>

The collective behavior that emerges at quorum.

fn signal_density(&self, substrate: &dyn Substrate) -> f64

Measure signal density in the local region.

fn quorum_threshold(&self) -> f64

The threshold for phase transition.

fn emergent_behavior(&self) -> Option<Vec<InsightData>>

The emergent behavior that activates at quorum.

fn contribute(&self) -> Contribution

Contribute to a collective computation.

fn quorum_reached(&self, substrate: &dyn Substrate) -> bool

Whether quorum has been reached.

impl Sense for Synthesizer

fn sense_radius(&self) -> f64

The radius within which this agent can sense signals.

fn sense_position(&self) -> Position

The position from which this agent senses.

fn gradient(&self, substrate: &dyn Substrate) -> Vec<Gradient>

Compute the gradient — direction of increasing signal strength.

fn orient(&self, _gradients: &[Gradient]) -> Orientation

Determine next orientation based on sensed gradients.

fn sense(&self, substrate: &dyn Substrate) -> Vec<Signal>

Read signals from the local environment.

fn emit(&self, signal: Signal, substrate: &mut dyn Substrate)

Emit a signal into the substrate.

impl SerializableAgent for Synthesizer

fn export_state(&self) -> SerializedAgent

Export the agent’s state for serialization.

fn from_state(state: &SerializedAgent) -> Option<Synthesizer>

Create an agent from serialized state.