Skip to content
Yitsy Mosqueda.
My Own Engineering Framework

Autonomous Engineering

Developed from my hands-on experience building software, this framework coordinates specialized AI agents across planning, implementation, code review and QA.

Agents reason. The harness enforces. The orchestrator coordinates. Artifacts preserve state.

Explore the ArchitectureView Projects

AI coding needs more than prompts.

Individual coding agents can generate useful code, but a larger engineering task introduces additional challenges:

  • Requirements must be translated into actionable implementation work.
  • Dependencies must be identified before parallel execution.
  • Backend and frontend implementations must agree on contracts.
  • Changes need independent review and testing.
  • Long-running workflows need persistent state and recovery mechanisms.
  • Generated code must remain consistent with the intended specifications.

Autonomous Engineering addresses these challenges by introducing a structured execution layer around specialized AI agents.

Architecture

Architecture diagram: specifications feed the Product agent, then a Tech Lead coordinates parallel Backend and Frontend agents, followed by Code Review and QA validation stages. A persistent artifact layer spans the entire workflow.

From specification to implementation.

  1. Define

    Create or update the specifications describing the required behavior, technical boundaries and acceptance criteria.

  2. Decompose

    The Product Agent transforms requirements into actionable engineering work.

  3. Plan

    The Tech Lead identifies dependencies, prioritizes work and assigns tasks to specialized agents.

  4. Implement

    Backend and frontend agents execute compatible tasks, potentially in parallel, using the agreed specifications and contracts.

  5. Review

    The Code Review Agent inspects implementation changes and identifies potential issues.

  6. Validate

    The QA Agent checks the implementation against the defined requirements and applicable tests.

  7. Preserve and Recover

    Execution artifacts maintain the state of the workflow — session information, backlog, changes, contracts and recovery data. This step is cross-cutting: state preservation happens throughout execution, not only at the end.

The engineering behind the harness.

OrchestrationCoordinates specialized engineering agents and workflow stages.
Agent rolesProduct, Tech Lead, Backend, Frontend, Code Review and QA.
Specification layerVersioned requirements and contracts under spec/.
State managementPersistent session, backlog, changelog, agent state, runs and recovery artifacts.
Execution environmentLocal, repository-scoped engineering sandbox.
ValidationCode review, QA and applicable automated checks.

Specific agent providers, models, frameworks, languages and execution mechanisms will be documented as they are verified against the current implementation.

Applied to real software engineering.

The harness is a reusable engineering methodology. IAnversicERP is one application of it.

IAnversicERP — Sistema de Gestión Empresarial

A modular business management system whose backend and frontend development are guided by specifications.

  • Requirements and module behavior are defined through specifications.
  • Backend and frontend implementation follow explicit boundaries and API contracts.
  • Specialized agents divide engineering responsibilities.
  • Review and QA provide separate validation stages.
  • Persistent artifacts support continuity across development sessions.
Explore IAnversicERP

Built around practical engineering constraints.

Local execution

The initial workflow operates locally within a repository-scoped environment. This supports bounded execution but does not, by itself, establish complete isolation or security.

Parallel agents

Parallel execution can reduce sequential work, but introduces coordination, integration and resource-management challenges.

Persistent artifacts

Persisting workflow state improves continuity and traceability, but the artifacts must remain consistent with actual repository changes and execution results.

Specification-first implementation

Detailed specifications and contracts improve clarity but require maintenance when requirements change.

Bounded autonomy

The harness coordinates work within defined execution boundaries. It is not a fully autonomous software organization, nor a guarantee of production-ready code.

An evolving engineering system.

Implemented capabilities are separated from planned improvements. A capability is marked as implemented only once it has been verified.

Stage 1 scope

  • Specialized agent workflow
  • Specification-driven task execution
  • Product planning and technical coordination
  • Backend and frontend implementation
  • Code review and QA stages
  • Persistent workflow artifacts
  • Session continuity and recovery support
  • Repository-scoped execution

Potential future improvements

  • Richer execution observability
  • More comprehensive automated acceptance testing
  • Stronger recovery and retry policies
  • Improved execution metrics and cost tracking
  • Additional safeguards and permission boundaries
  • Integration with external development workflows

Let's build something meaningful.

Open to international opportunities, consulting projects and collaborations.

Explore My Projects Contact Me
Autonomous Engineering | AI Agent Orchestration & SDD