Three connected system directions can remove burdens that modern AI, machines, instruments, electronics, and infrastructure have learned to accept: capability-native agency, live reconfigurable physical computation, and minimal-apparatus physical intelligence.
I plan to organize future subsidiaries around these three directions. They do not exist as companies yet; the work already defines the technical and commercial ground they can pursue.
One customer can need all three directions at once. A robotics team may need structurally bounded machine authority, spatial computation that follows the body, and direct physical interfaces that strip away converter stacks. The same cross-layer opportunity reaches instruments, satellites, industrial systems, adaptive edge machines, and fabrication.
These 210 problem statements locate the leverage: build mechanisms that own authority, reorganize locally, and compute closer to physical cause and effect.
1. Capability-native agency: Give machines authority they can possess
The first planned subsidiary will build capability-native systems that give AI agents and autonomous machines structurally bounded authority, with delegation, ownership, revocation, and possible effects visible in the mechanism itself.
Segment 1A: Give enterprise AI agents consequence-shaped authority
- Enterprise agents borrow human accounts, service accounts, API keys, or application identities before they can act.
- A single account accumulates every permission an agent might need across every possible task.
- Those permissions outlive changes in purpose, principal, instructions, state, and environment.
- API verbs stand in for the real-world consequence that actually needs authorization.
- Authorization for one task exposes the same permissions to unrelated purposes.
- Each external system defines its own incompatible version of what an agent may do.
- Teams reconstruct effective authority by joining credentials, roles, tool definitions, application policies, and network access.
- Organizations lack one system that can enumerate everything a particular agent can currently cause.
- Untrusted instructions and documents enter the reasoning path that controls consequential tools.
- Prompt-injection defenses judge information legitimacy instead of structurally limiting the effects of influenced behavior.
- Tool wrappers expose callable operations without owning the state or consequences those operations change.
- Long-running tasks keep authority after the human reason for delegation disappears.
- Changes to the model, prompt, planning method, or toolchain leave existing authority untouched.
- Invisible vendor updates can radically change the behavior of the same authenticated agent.
- Arbitrary approval checkpoints ask humans to approve actions without reconstructing agent state or downstream plans.
- Teams choose between approving every action and exposing enough ambient power to make the agent useful.
- Audit logs document actions that stronger structure could have made impossible.
- Rollback cannot reverse disclosures, payments, commitments, communications, or other irreversible consequences.
- Organizations assign responsibility to humans who neither understood nor controlled the action.
- Every gain in agent usefulness expands the institutional power exposed to uncertain behavior.
Segment 1B: Make machine delegation narrow, causal, and revocable
- Machine delegation passes a credential, token, session, or proxy relationship from one actor to another.
- Delegation chains preserve or broaden power instead of narrowing it at each handoff.
- Recipients learn the operation they can perform while losing the authority’s complete provenance and purpose.
- Agents exchange messages while external systems retain implicit ownership of the state they change.
- Several agents can mutate the same consequential state concurrently without any agent owning that mutation.
- Systems blur agent, process, model, session, and organizational identities into one vague actor.
- An agent lacks a structural way to create a subordinate whose possible effects fit inspectably inside its own authority.
- Revocation teams must discover every credential, session, queue, derived task, and downstream delegation that one handoff created.
- Time limits stand in for completion, withdrawal, state change, and the disappearance of purpose.
- Coordinators accumulate broader power than every activity they coordinate.
- Global policy and monitoring must see the complete organization before they can govern cross-agent behavior.
- An agent can complete its local assignment correctly and still violate the intent of the larger undertaking.
- Priorities, retries, locks, and human intervention settle conflicts that explicit ownership relationships should resolve.
- Service endpoints substitute for organizational boundaries inside the computation itself.
- One agent failure can scatter partially exercised authority across other agents and external systems.
- Economically useful delegation makes the causal history of authorization hardest to reconstruct.
Segment 1C: Give autonomous machines local ownership of physical consequences
- Control systems treat controller or operator authentication as permission for every physical command that follows.
- Planners inherit whole-machine control because actuators expose no narrower purpose-specific authority.
- Speed, force, zone, and mode limits constrain motion without assigning ownership of each physical consequence.
- A legitimate high-level objective lends presumed legitimacy to every intermediate action in its plan.
- Local machine components lack mechanisms to own and delegate authority over their state and physical territory.
- Central controllers accumulate the powers of every subsystem they coordinate.
- Maintenance sessions grant broad control because systems cannot express precise temporary authority easily.
- Remote support opens general machine access to people who cannot observe the complete physical context.
- A disconnected machine must either stop or continue under authority that its current state may have outgrown.
- Physical state outruns centrally administered permission changes.
- Cages, interlocks, emergency stops, monitoring, and shutdown react after acting computation already holds physical power.
- Local machine logic cannot verify that a requested action fits the exact authority for its present state.
- Machine reconfiguration invalidates assumptions inside separate access-control and safety systems.
- Law assigns human operators responsibility for autonomous choices whose selection mechanism they cannot inspect.
- Designers answer greater physical autonomy with more centralized surveillance and override power.
Segment 1D: Build computing infrastructure around capability and ownership
- Systems attach authority to identities and roles instead of making it a first-class structural possession.
- Applications inherit ambient access to processes, filesystems, networks, environments, and services at startup.
- Machines, containers, accounts, and processes define isolation while semantic state ownership remains invisible.
- Platforms wrap tenant boundaries around applications that still carry ambient power internally.
- External policy engines judge behavior outside the mechanism they constrain.
- A passed authorization check releases ambient authority inside the approved component.
- Services trust upstream callers to use available operations for legitimate purposes.
- Two individually permitted services can combine into an authority nobody anticipated.
- Periodic access reviews stand in for continuous knowledge of live delegation relationships.
- Undocumented dependencies let permissions accumulate and resist removal.
- Revocation stays coarse because the system never modeled authority as a specific relationship.
- Central policy engines must comprehend systems that grow more distributed and dynamic every day.
- Administrative boundaries shape compromise containment instead of the causal structure of the affected operation.
- Configurations, logs, scans, and policy reports stand in for inspectable limits on possible effects.
- Information and process owners cannot directly own the computational territory that exercises their authority.
2. Live reconfigurable physical computation: Let structure change while the machine runs
The second planned subsidiary will build spatial, locally owned computation that can reorganize live across instruments, robots, satellites, industrial systems, adaptive edge machines, and eventually programmable matter.
Segment 2A: Let scientific instruments reshape their live causal structure
- Instrument designers freeze computational structure when they design the electronics.
- New measurement behaviors squeeze through signal paths that embody earlier assumptions.
- Physically local events travel to designated processors before they can join the computation.
- Separate subsystems split acquisition, processing, control, storage, visualization, and physical response.
- Teams add interpretation above an existing data pipeline instead of changing its causal structure.
- Firmware, host software, configuration files, calibration databases, and operator procedures divide instrument state.
- The display presents a different object from the state that governs physical behavior.
- Teams synchronize multiple instruments with clocks, triggers, cables, timestamps, and post-processing.
- Each new experiment forces humans to reconstruct causality across instruments that share no computational region.
- Separate calibration procedures interrupt rather than evolve with live computation.
- Instruments expose data while hiding the mechanism that transformed observation into result.
- Field updates replace complete firmware images instead of reshaping bounded live regions.
- One component change can trigger requalification across the entire measurement chain.
- Engineers diagnose transients by correlating logs and captures from different clocks.
- Host computers and operators absorb the integration cost of instrument flexibility.
Segment 2B: Make industrial machines compute where physical work happens
- Central controllers reduce sensors and actuators to endpoints instead of computational participants in local physical territory.
- Production machinery stops whenever engineers change its computational structure.
- Specialists reconfigure the machine through representations that live outside it.
- Physical rearrangements cascade into addressing, routing, configuration, safety, calibration, and software changes.
- Machines fail to discover changed structure and reorganize causal ownership locally.
- Nearby components route coordination through a central controller or network.
- Designers treat locality as a latency optimization instead of part of machine semantics.
- Controllers, drives, robots, databases, supervisory software, and undocumented operator knowledge scatter machine state.
- One added machine or station triggers a system-integration project.
- Equipment-sized failure boundaries let local faults disable large functional regions.
- Failure planning duplicates entire components because smaller computational territories lack independent survival and reorganization.
- Priorities, schedules, overprovisioning, and strict limits on change preserve real-time behavior.
- Conventional architecture pits adaptability against deterministic operation.
- Safety certification freezes the architecture while operating conditions continue to change.
- Operators watch alarms, traces, dashboards, and schematics instead of the machine’s live causal organization.
- A robot’s computational topology ignores the body and environment it controls.
- Machines outlive the computational assumptions and components embedded in them.
Segment 2C: Let remote systems reorganize after deployment
- Teams finalize computational architecture years before the system meets its operating environment.
- Prelaunch imagination limits every behavior the deployed system can adopt later.
- Remote systems switch among predesigned modes or accept externally prepared images when they need reconfiguration.
- Fixed processing, routing, memory, and redundancy force every possible future need to compete for resources chosen in advance.
- Reliability plans duplicate complete subsystems instead of letting surviving regions reorganize.
- Damaged regions cannot hand state, function, and authority to neighboring resources naturally.
- Communication delay demands local autonomy while remote operators retain authority and planning.
- Communication loss forces a choice between inactivity and continued operation under outdated assumptions.
- Teams avoid repurposing healthy hardware because opaque structural change makes the risk hard to inspect.
- Static verification loses certainty after meaningful reconfiguration.
- Separate representations track state transitions, resource ownership, physical location, and communication topology.
- Remote operators infer causality from sparse telemetry instead of inspecting the computation itself.
- Fixed resources spend scarce energy moving data because computation cannot migrate into the relevant physical locality.
- Inaccessible computational components age out before the surrounding physical system does.
- Surviving hardware gains no fundamentally new organization unless designers predicted that exact possibility before deployment.
Segment 2D: Give edge machines live, local computational structure
- Edge deployments move a conventional fixed computer closer to the phenomenon.
- Geographic distribution leaves each device architecturally centralized.
- Sensors send local physical behavior through buses, memory, schedulers, and processing cores before computation can use it.
- Designers lock accelerated functions before future workloads reveal what the device will need.
- Updates replace instructions while leaving the causal machinery unchanged.
- External toolchains compile every reconfigurable-resource change instead of granting live local ownership.
- A local computational change exposes hidden global timing, routing, and resource effects.
- Physical adjacency still leaves storage, communication, and computation as separate systems.
- Schedulers arbitrate workloads without understanding the physical meaning of their work.
- Software conventions assign local state ownership instead of physical computational boundaries.
- Optimization starts after the architecture accepts data movement and abstraction.
- Each adaptability layer enlarges the operating stack, opacity, and failure surface.
- Determinism strips away the flexible layers that made the device adaptable.
- Devices cannot grow new bounded computational structures from physical experience.
- Runtime inspection reveals processors and tasks instead of the spatial causal organization of behavior.
Segment 2E: Make computation belong to programmable matter
- Fixed identifiers ignore the physical relationships that modules form in the moment.
- Global software reconstructs topology before the material can produce useful collective behavior.
- Manufactured regularity breaks when people cut, damage, fold, extend, or assemble the material irregularly.
- Systems split physical adjacency, communication adjacency, computational ownership, and mechanical attachment into different relationships.
- Designers commit power and data distribution before they know the final spatial behavior.
- Every added module multiplies the burden of central coordination.
- Local interaction rules can produce visible behavior, yet conventional designs reserve useful machinery for a global plan.
- Separate subsystems divide shape change from computation.
- One damaged module can sever addressing, routing, synchronization, or power for healthy regions.
- Repair restores a previous configuration instead of reorganizing live function around changed matter.
- Regions lack a native way to establish boundaries, own state, expose ports, and authorize local mutation.
- Cutting or combining material invalidates the computational model maintained elsewhere.
- Connectors, wiring, addressing, and configuration set the minimum practical module scale.
- Science-fiction expectations hide commercially valuable programmable matter short of arbitrary shape transformation.
- Industry confines large spatial electronics to passive surfaces or centrally managed collections of conventional devices.
- External control separates the physical object from the computation that governs it.
3. Minimal-apparatus physical intelligence: Move intelligence into the mechanism
The third planned subsidiary will build near-sensor computation, direct physical interfaces, tiny local learning, and unusual active devices that remove converter stacks, centralized machinery, and inaccessible fabrication where those layers create the real burden.
Segment 3A: Let sensors decide where phenomena occur
- Standardized signals or numbers mark the end of a sensor’s assigned job.
- A physical phenomenon crosses conditioning, digitization, buffering, timestamps, transport, storage, and remote interpretation before it can matter.
- Designers preserve every available detail even when the local decision needs very little information.
- Institutional separation between sensing and meaning sends raw observations elsewhere.
- Transmission and storage can cost more than the local consequence that gives sensed data value.
- Every sensing point carries power regulation, conversion, clocks, firmware, addressing, protocols, and maintenance.
- Conventional near-sensor intelligence waits for a standard digital representation before it begins.
- Interface apparatus can outweigh the sensor between phenomenon and decision.
- Repeated calibration normalizes sensors whose physical behavior differs slightly.
- Preprocessing removes noise, hysteresis, nonlinear response, and material history before computation can use them.
- A local threshold or control decision inherits a general-purpose computational stack.
- Central collection shapes sensing networks even when most collected data triggers no action.
- Systems expand bandwidth and storage instead of asking why an observation must leave its source.
- A communication failure strips intelligence from an otherwise functioning physical sensor.
- Distributed sensing imposes permanent battery, maintenance, identity, synchronization, and software-management burdens.
Segment 3B: Replace converter stacks with direct computational relationships
- Every distinct physical domain accumulates a chain of specialized conversion and interface components.
- Standard representations mediate nearby physical causes and effects that could share a direct computational relationship.
- One-bit physical decisions recruit analog conditioning, conversion, processing, protocol handling, and output conversion.
- Designers choose general interface architectures whose reach greatly exceeds the required function.
- Converter accuracy preserves distinctions that never affect the intended physical consequence.
- Clocks, sampling, buffering, and reconstruction replace timing that the physical mechanism creates naturally.
- Multiple abstraction layers pull feedback loops out of the physical locality they regulate before returning them.
- Interface layers confirm signal delivery without confirming the intended physical result.
- Every layer adds debugging instruments, models, expertise, and failure analysis.
- Interoperability imports the complete standardized stack that every other participant uses.
- Teams dismiss direct coupling as fragile or application-specific while accepting universal abstraction costs as unavoidable.
- Component-level optimization hides the opportunity to reconceive the causal system by removing an interface layer.
- Drivers, firmware, and protocol support can expire before the physical device wears out.
- Separate owners control the physical effect and the machinery that produces it.
Segment 3C: Give tiny machines local learning they can own
- Central infrastructure learns while deployed devices only execute inference.
- Machines export local experience before they can improve from it.
- Lifecycle plans separate training from operation.
- Adaptation arrives as a replacement model from elsewhere.
- Designers shrink architectures built for vastly larger machinery to create small learning systems.
- Model size dominates the search for capability.
- Fleet economics make device-specific learning look too expensive to maintain independently.
- Fleet-wide averages erase important local physical differences.
- Local examples wait for human labels before learning systems can use them.
- Separate stores split learning state, operational state, sensor history, and control state.
- Change mechanisms that expose neither their operation nor their bounds block continual learning.
- Network loss freezes an offline device’s ability to improve.
- A number represents local uncertainty while behavior ignores what the machine can safely do.
- Even the smallest adaptive system pays separate costs for memory, arithmetic, communication, and sensing.
- Learning design precedes energy, latency, and physical realization.
- Abstract benchmark accuracy outranks improvement in physical behavior.
- Teams find tiny-system change as opaque as a remote statistical model.
- Vendor update infrastructure controls local adaptation instead of an owner-observable mechanism.
Segment 3D: Make active computation locally fabricable
- Inaccessible infrastructure for manufacturing semiconductor junctions controls access to useful active computation.
- Manufacturing separates active function from interconnect as fundamentally different activities.
- Circuit boards route intelligence without embodying the active mechanism themselves.
- Small organizations can assemble purchased intelligence but cannot manufacture consequential active behavior.
- Conventional design confines magnetic materials to transformers, inductors, storage, and sensing instead of general switching and gain.
- Designers characterize away material hysteresis and nonlinear response instead of using them as computational mechanisms.
- Evaluation demands general superiority over conventional transistors before an alternative device can serve a neglected niche.
- Current economics rule out small-run custom active devices.
- Electronic design workflows stop before device geometry becomes an ordinarily machinable file like a mechanical part or circuit board.
- Specialized institutions hoard fabrication knowledge away from the people who design systems.
- Conventional fabrication limits makers and ordinary laboratories to passive arrangements around sealed active components.
- Industry labels locally fabricated active function as education instead of serious production.
- Repair replaces a proprietary active component instead of reproducing its mechanism.
- One discontinued proprietary component can permanently strand a machine that remains repairable everywhere else.
- Electronics treats supply-chain concentration as an intrinsic property.
- Harsh environments demand expensive specialized versions of the same inaccessible technology.
- Conventional design treats material and process variation as an obstacle instead of usable state.
- Fabrication capital decides who gets to invent new computational matter.
- Transistor economics, semiconductor geopolitics, and centralized manufacturing permanently bind computation to inaccessible infrastructure.