M-16-21 rested code reuse on contract rights and an inventory, the two parts Congress put into law in 2024
OMB’s August 8, 2016 source code policy set a 20 percent open source pilot. Its lasting demands were rights to reuse custom code and an inventory listing it. The 2024 SHARE IT Act wrote both into law and dropped the pilot.
Looking Back revisits past weeks one at a time, up to the most recent, and asks what it meant for the banks, health systems and public agencies we serve. The series was written in 2026, with the benefit of hindsight, and each article says which week it looks back on.
Two-minute summaryThe dek and the first sentence of each section, quoted from the article
OMB’s August 8, 2016 source code policy set a 20 percent open source pilot. Its lasting demands were rights to reuse custom code and an inventory listing it. The 2024 SHARE IT Act wrote both into law and dropped the pilot.
- The week The memo opened with a spending figure.
- The rights: what an agency had to buy before it could share The memo was direct about sequence.
- The inventory: listing custom code so others could find it The memo tied the code inventory to an existing duty.
- The pilot: a release target with an end date The memo let agencies choose the measure.
- The exceptions: who could decline to share, and on what record That is a record-keeping requirement.
- How the policy applies to different organizations A large department contracts for custom work across several components.
- Objections, in order The pilot set the memo’s only percentage target.
- Checks a CIO or acquisition officer could run today Pull a sample of current custom development contracts.
- With hindsight The clearest later verdict on the memo came from Congress.
The week
On August 8, 2016, the Office of Management and Budget issued memorandum M-16-21 to the heads of executive departments and agencies. [1] Its title was Federal Source Code Policy: Achieving Efficiency, Transparency, and Innovation through Reusable and Open Source Software. [1] It came from the United States Chief Information Officer and the United States Chief Acquisition Officer. [1]
The memo opened with a spending figure. It said the federal government spends more than $6 billion on software each year through more than 42,000 transactions, citing OMB’s June 2016 software licensing memo, M-16-12. [1]
It described the problem it was addressing. When agencies procure custom-developed source code, the memo said, they do not necessarily make it broadly available for reuse across the government. [1] Even when they could share it, they do not do so consistently. [1]
In some cases, the memo said, agencies may even have difficulty establishing that software was produced under a federal contract. [1] It said these challenges may result in duplicative acquisitions for substantially similar code. [1]
The policy’s stated aim was to ensure that new custom-developed federal source code be made broadly available for reuse across the government, subject to limited exceptions. [1] It said reuse could reduce duplicative costs and federal vendor lock-in, which it defined as dependence on a single supplier that cannot be left without substantial cost or inconvenience. [1]
The memo also set up a pilot. Agencies commissioning new custom software would have to release at least 20 percent of new custom-developed code as open source software for three years. [1] They would also collect data to inform metrics on the pilot’s performance. [1]
The memo gave examples of government code already published openly. It named the White House’s We the People petitions site, 18F and the Consumer Financial Protection Bureau’s source code policies, the eRegulations platform and the Department of Education’s College Scorecard. [1] It said the policy fulfilled a commitment in the Second Open Government National Action Plan. [1]
The policy’s scope was source code custom-developed for the federal government. [1] Code developed for national security systems was exempt. [1] The policy did not apply retroactively, though the memo strongly encouraged agencies to make existing code available where practicable. [1]
The memo defined custom-developed code as code first produced in the performance of a federal contract or otherwise fully funded by the government. [1] It included code for which the government could obtain unlimited rights under Part 27 of the Federal Acquisition Regulation, and code written by agency employees as part of their duties. [1] It excluded truly exploratory or disposable code. [1]
The policy laid out a three-step analysis before any custom development. [1] First, agencies had to analyze alternatives and give preference to an existing federal solution. [1] Second, they had to consider commercially available solutions. [1] Third, only if neither met their needs could they consider custom development. [1]
The memo said agencies must consider open source, mixed source and proprietary software on a level playing field, consistent with OMB’s policy on technology neutrality. [1]
It set deadlines measured from its publication date. [1] Within 90 days, each agency CIO, in consultation with the Chief Acquisition Officer, had to write an agency-wide policy and correct inconsistent ones. [1] That included policies that automatically treated open source software as noncommercial software. [1]
Within 120 days, each agency had to add an enterprise code inventory to its inventory of information resources. [1] Within 90 days, the administration would launch Code.gov, which the memo described as a collection of tools and the primary discovery portal for federal custom code. [1]
The memo said Code.gov would not house the code itself. [1] It would list what existed and where. [1] OMB would assess progress mainly by analyzing agencies’ repositories and code inventories, along with data from its quarterly collections, PortfolioStat sessions and the IT Dashboard. [1]
M-16-21 set a pilot requiring agencies to release at least 20 percent of new custom code as open source, its most visible feature in our view. [1] Read as an architecture document, the memo did something more basic. It made reuse of government code depend on two things an agency controls before any code is written or shared: the rights it buys in the contract, and an inventory that says what code exists. [1]
Our argument is that those two demands were the durable part of the memo. The pilot had an end date written into it. [1] When Congress acted in December 2024, the SHARE IT Act required agencies to acquire and exercise reuse rights and to publish metadata about their custom code. [3] It set no open source release percentage. [3] A Senate committee report said the 2016 policy had lacked accountability mechanisms and uniform procedures for access to code. [2]
We take the memo in four parts:
- The rights: what an agency had to buy in a contract so the code could be reused at all.
- The inventory: how agencies had to list custom code and make the list discoverable.
- The pilot: the open source release target, how it was measured and when it was set to end.
- The exceptions: who could decline to share code, on what grounds, and how that was recorded.
The parts do not overlap. The first concerns acquisition, the second records, the third publication, and the fourth the limits on all three. Together they cover what the memo asked agencies to do with custom code. After them we look at how the policy applies to different organizations, take the objections in order, and end with checks a CIO or acquisition officer could run.
The rights: what an agency had to buy before it could share
The contract comes first
The memo was direct about sequence. Agencies that contract for custom software development shall, at a minimum, acquire and enforce rights sufficient to enable governmentwide reuse of the code. [1] The memo said agencies must use appropriate contract administration to secure the full scope of those rights, including sharing the code with other agencies. [1]
Rights alone were not enough. The memo said agencies must use best practices to ensure delivery of the code, documentation and other associated materials from the developer throughout the development process. [1] A right to code the agency never received is hard to exercise.
Why rights are an architecture question
Contract terms decide what an agency can do with a system later. If the government holds only a limited license to code, it may not be able to hand that code to another agency, to a new contractor or to the public. The memo’s definition of vendor lock-in describes the consequence: a customer that cannot move to another vendor without substantial cost or inconvenience. [1]
So the rights clause shapes the agency’s future options. A system whose code the agency can reuse and modify can be maintained by a different contractor. A system whose code the agency cannot share ties maintenance to the original vendor. The memo said vendors competing for future maintenance can do so with full knowledge of the source code when it is open. [1]
Delivery during development, not at the end
The words “throughout the development process” matter. [1] A contract that requires delivery only at final acceptance leaves the agency without the code if the contract ends early or the relationship breaks down.
In our reading, the memo pointed toward delivery into repositories the agency can reach while work is underway. The memo said accessible, buildable, version-controlled repositories are critical to both reuse and the open source pilot. [1] It told agencies to use existing code repositories and common third-party repository platforms as needed. [1]
Reuse and modification are separate rights
The memo’s objectives named two rights as the minimum: governmentwide reuse and the right to modify the code. [1] The distinction matters. A right to run a copy of a program does not let an agency fix a defect, adapt it to a new rule or hand it to a new maintainer.
A second agency that adopts shared code is likely to need to change it. Its forms, data fields and integrations will differ. Without the right to modify, the shared code is a reference, not a starting point. The memo’s pairing of the two rights reflects that. [1]
What a statement of work would need
Turning the memo into contract terms takes several pieces. The data rights clause sets what the government may do with the code. A deliverables schedule says when code, documentation and build materials arrive. An acceptance step checks that what arrived is complete enough to build and run.
The memo did not supply model clauses in its text. It said Code.gov would include model contract language, along with definitions, metrics, checklists and case studies. [1] So the first year of implementation depended on guidance that was promised rather than attached.
What counts as custom-developed code
The definition sets the boundary. Custom-developed code is code first produced in performance of a federal contract or otherwise fully funded by the government. [1] It includes code or segregable portions of code for which the government could obtain unlimited rights under FAR Part 27 and agency supplements. [1]
The memo listed examples: code for software projects, modules, plugins, scripts, middleware and APIs. [1] It also covered code written by agency employees as part of their official duties. [1] It did not cover truly exploratory or disposable code, such as a developer’s experiments with a new language. [1]
The definition leaves out commercial software. Commercial products remain governed by their licenses. So the rights clause bites on the custom parts of a system: the integration code, the configuration logic written for the agency, the interfaces built to connect commercial products.
Custom code that depends on commercial parts
A system can mix custom and commercial parts. The memo recognized hybrid solutions that mix existing federal, commercial and custom code, and asked agencies to consider them at every step. [1] It defined mixed source software as a solution incorporating both open source and proprietary code. [1]
For reuse, the hybrid case is the hard one. An agency may hold full rights to its custom integration code and still be unable to share a working system, because the commercial component under it is licensed only to that agency. The second agency would need its own license. In our reading, the inventory entry for such code should say which commercial dependencies it carries, so a would-be reuser knows the true cost before starting.
The three-step analysis came before the rights clause
The memo asked agencies to look for an existing federal solution first, then a commercial one, and only then custom development. [1] At each step they had to weigh factors including performance, total life-cycle cost, security and privacy protections, interoperability and the resources required to later switch vendors. [1]
The memo encouraged modular architecture, cloud options and open standards across all three steps. [1] It said modularity can reduce risk and cost while increasing interoperability. [1] It said open standards should be considered whenever practicable in all software procurements and development projects. [1]
In our reading, this ordering made custom code a last resort and then made sure that, when an agency chose it, the result could be reused. The rights clause is what turns a custom build into a shared asset.
The policy correction on commercial software
The memo required each CIO to correct policies inconsistent with it, including policies that automatically treat open source software as noncommercial software. [1] That point sounds technical but affects acquisition. Classification of software as commercial or noncommercial changes which acquisition rules and clauses apply.
The memo’s instruction was to stop treating open source as noncommercial by default. [1] It fit the memo’s instruction to weigh open source, mixed source and proprietary options on a level playing field. [1]
Two officials, one decision
The memo addressed itself to two roles. The CIO had to write the agency policy in consultation with the Chief Acquisition Officer. [1] The memo said CIOs, acquisition officers and other stakeholders should promptly begin working together. [1]
That pairing reflects where the decisions sit. The CIO knows what the system needs and how it will be maintained. The acquisition officer controls the solicitation, the clauses and the contract file. A rights clause that the CIO wants but the contracting officer never inserts does not exist. The memo’s structure put both officials on the hook. [1]
The inventory: listing custom code so others could find it
What the inventory had to hold
The memo tied the code inventory to an existing duty. As part of their broader responsibility to maintain an up-to-date inventory of information resources, agencies had to create and maintain an enterprise code inventory listing all new custom-developed code. [1]
For each entry, the inventory had to indicate one of three states. The code was available for federal reuse, available publicly as open source, or could not be made available because of a specific exception. [1] Agencies were to use a metadata schema OMB would provide on Code.gov. [1]
Discovery, not hosting
Code.gov was designed as a catalog. The memo said it was not intended to house code. [1] It would serve as a tool for discovering code available for reuse or as open source, and for transparency into code developed with federal funds. [1] The memo said Code.gov would be modeled after Data.gov and Project Open Data. [1]
The design choice matters for architecture. A catalog that points to repositories elsewhere depends on those repositories staying accessible and the metadata staying accurate. If an agency moves a repository or lets a link break, the catalog entry no longer leads anywhere.
The inventory as the accountability tool
The memo said OMB would assess progress primarily by analyzing agencies’ internal repositories, public open source repositories and code inventories on Code.gov. [1] It would add data from the quarterly Integrated Data Collection, PortfolioStat sessions and the IT Dashboard. [1]
So the inventory served OMB as well as other agencies. It was how OMB would see whether an agency was complying. An agency without an inventory could not show compliance with the reuse requirement, the pilot or the exceptions process.
What an inventory needs to be useful
An inventory line that says a repository exists is a start. To support reuse, a second agency needs more: what the code does, who maintains it, under what license or rights it can be used and how to build it.
The memo’s documentation requirements for open source repositories point in that direction. [1] At a minimum, agency-maintained repositories had to state the software’s status, its intended purpose, the expected level of agency engagement, the license details, and technical details on how to build, install or use it, including dependencies. [1]
The same fields would help internal reuse. A code inventory that captured status, purpose and maintenance level would let another agency judge whether to adopt the code or build its own.
Keeping the inventory current
The memo asked agencies to keep the inventory up to date after the first 120 days. [1] An inventory built once decays. Repositories are renamed, projects end and contracts change hands.
Keeping it current is an operational task with an owner. The natural trigger points are contract award, first code delivery, release to production and contract closeout. At each point, someone checks that the inventory line exists and reflects the code’s state. The memo did not prescribe those triggers. In our reading, they follow from its demand that the inventory reflect all new custom-developed code. [1]
Private repositories and access for other agencies
Governmentwide reuse does not require public release. Code available for federal reuse but not as open source still needs a place other agencies can reach. [1]
That raises access questions. Which employees of another agency can see the code? How do they request access? Who approves it? The memo did not answer these in its text. The SHARE IT Act later required each agency’s policy to include procedures for federal employees to gain access to public and private repositories holding custom code. [3] The Senate committee report had named the lack of uniform access procedures as a weakness of the 2016 policy. [2]
Connecting code to contracts
The memo noted that agencies may have trouble establishing that software was produced under a federal contract. [1] An inventory that records which contract produced each piece of code solves that problem going forward.
The SHARE IT Act later named this link. Its definition of metadata includes whether the code was produced under a contract, any contract number under which it was produced, whether it was shared in a public or private repository, and any hyperlink to that repository. [3] In our reading, that definition answers the 2016 memo’s concern directly.
The pilot: a release target with an end date
The target
Each agency had to release as open source at least 20 percent of its new custom-developed code each year for the pilot’s term. [1] The memo said agencies should prioritize code they considered potentially useful to the broader community. [1]
The memo said OMB expected all agencies to meet the pilot’s requirements without exception. [1] If a CIO believed the agency could not meet 20 percent, for example because release would create an identifiable risk to national security, the CIO should consult OMB. [1]
How the target was measured
The memo let agencies choose the measure. They could calculate the percentage using lines of code, the number of self-contained modules, or cost, so long as the measure was consistent and met the requirement’s objectives. [1] It said more guidance on measurement would be provided on Code.gov. [1]
That flexibility had a cost. Different measures can give different answers for the same portfolio. One large module and many small scripts weigh differently by lines of code and by module count. Without one measure, comparisons across agencies would be difficult.
Why the exceptions did not apply to the pilot
The memo said the exceptions to governmentwide sharing did not apply to the pilot. [1] Instead, agencies were told not to select code that would fall under those exceptions when choosing what to release. [1]
In our reading, the pilot asked agencies to choose 20 percent from the code that could be released. The other 80 percent could include the sensitive work. The pilot was a floor on what went public, not a test of each piece of code.
The end date
The memo set its own clock. Unless extended or supplanted by OMB through further policy, the pilot would expire three years after the policy’s publication date. [1] The rest of the policy would remain in effect. [1]
The memo said OMB would evaluate pilot results no later than two years after publication and consider whether to let the pilot expire or issue a policy to continue, modify or increase it. [1] It said OMB would develop metrics within 120 days to assess the pilot’s impact. [1]
That is why we call the pilot the less durable part. It was designed as a test with an end date. The rights and inventory requirements carried no such sunset. [1]
Licensing released code
The memo said that when agencies release custom code as open source, they shall append appropriate open source licenses. [1] It said more information on licensing would be on Code.gov. [1]
Licensing is not a formality. A repository without a license leaves outside users unsure of their rights. A license choice also affects what contributors may do and whether others can combine the code with their own. The memo left the choice of license to agencies, with guidance to follow. [1]
What the pilot was for
The memo gave reasons for open release. It said open code enables continual improvement from a broader user community and can make software peer review and security testing easier. [1] It quoted Defense Department guidance on peer review supporting reliability and security. [1]
The memo also asked agencies to engage with open source communities, develop in the open where possible, adopt regular release schedules and consider outside contributions. [1] Those are operating practices. They require staff time, review processes and decisions about who can accept outside changes into government code.
Who does the community work
Open development needs people. Someone has to review outside contributions, answer questions, keep documentation current and decide on release schedules. The memo asked agencies to strengthen internal capacity to deliver open source software securely as part of regular operations. [1]
The memo also said agency officials should work with public affairs, open government staff, web managers, program owners and other leadership to identify and publish projects and collaborate with communities. [1] In our reading, that list shows the pilot was an organizational change, not a repository setting.
The exceptions: who could decline to share, and on what record
Five grounds
The memo listed five exceptions that could exempt an agency from sharing custom code with other agencies. [1]
- Sharing is restricted by law or regulation, including intellectual property law, export regulations, the International Traffic in Arms Regulations and laws governing classified information. [1]
- Sharing would create an identifiable risk to national security, confidentiality of government information or individual privacy. [1]
- Sharing would create an identifiable risk to the stability, security or integrity of the agency’s systems or personnel. [1]
- Sharing would create an identifiable risk to agency mission, programs or operations. [1]
- The CIO believes it is in the national interest to exempt the code. [1]
Approval and documentation
Any exception had to be approved and documented by the agency CIO. [1] For excepted software, agencies had to give OMB a brief narrative justification for each exception, with redactions as appropriate. [1]
That is a record-keeping requirement. It created a list, in principle, of every piece of code withheld and why. In our reading, the documented exception is where the policy’s accountability depended most on agency follow-through.
How broad the grounds were
In our reading, the fourth and fifth grounds were wide. Risk to agency mission, programs or operations could describe a large share of custom code, since custom code is commissioned to run programs. The fifth ground rested on the CIO’s belief about the national interest. [1]
Wide grounds are not wrong in themselves. Agencies hold code that should not be shared. But wide grounds combined with a weak reporting loop can make exceptions the default. The Senate committee’s 2024 description of the policy, that it lacked requirements to report agencies that refused to share, points at this gap. [2]
Security as an exception and as a reason to share
Security appears on both sides of the memo. The third exception allows withholding code where sharing would risk the security or integrity of agency systems. [1] The open source section says open code can make peer review and security testing easier. [1]
Both can be true. Code that encodes how a system is defended, such as detection rules or configuration of security tools, may warrant protection. Code that implements a public service may benefit from outside review. The memo left the line to the CIO’s documented decision. [1]
What OMB would see
The narrative justifications went to OMB. [1] The memo did not say they would be published. A public inventory entry could show that code existed and was excepted, since the inventory had to indicate when code could not be made available because of a specific exception. [1]
So the 2016 design gave the public a count of excepted code, in principle, and OMB the reasons. The SHARE IT Act changed the audience. It requires an annual report to the appropriate congressional committees on all exemptions granted, with the narrative justifications. [3] It also requires a public report listing all discretionary exemptions. [3]
How the policy applies to different organizations
A cabinet department
A large department contracts for custom work across several components. Its CIO had to write the agency-wide policy and coordinate with the Chief Acquisition Officer. [1] The memo cited FITARA as the basis for CIO involvement in IT acquisition and said agency heads must give CIOs and senior officials the authority to implement the policy. [1]
For such a department, the rights clause runs through several contracting offices. A policy at headquarters does not change a contract until each office uses the language. The inventory has the same problem: components may keep their own repositories and records.
A small agency
A small agency may have little custom code and a small IT staff. The memo’s requirements still applied to executive agencies under the Clinger-Cohen Act definition. [1] For a small agency, the inventory may be short, but the contract language and delivery practices still matter. A small agency is more exposed to lock-in if a single contractor holds its code.
A contractor building for the government
For contractors, the policy changed expectations about what they would deliver. The memo said agencies must ensure delivery of code, documentation and associated materials throughout development. [1] A contractor that kept code in its own systems until final delivery would face requests for earlier access.
The memo also said vendors competing for future work could do so with full knowledge of the source code. [1] That cuts both ways for a contractor. The incumbent loses some advantage. A challenger gains a clearer picture of the work.
A national security system
Code for national security systems was outside the memo. [1] Agencies were to follow applicable statutes, executive orders, directives and internal policies for those systems. [1] The SHARE IT Act kept that line. It does not apply to classified code or code developed primarily for use in a national security system. [3]
A digital service team inside an agency
Some agencies had in-house digital teams that wrote code themselves. The memo cited 18F and the CFPB as organizations with policies to publish custom code by default. [1] Code written by agency employees was within the memo’s definition. [1]
For such teams, the contract rights question falls away for their own code. The inventory, licensing, documentation and exception decisions remain. A team already working in public repositories would find the pilot easiest to meet.
State and local governments
The memo did not apply to state or local governments. It noted that city governments had reused code from a federal analytics project to publish their own website statistics. [1] Open federal code can be reused outside the federal government, but no federal policy made that reuse happen.
Regulated industries
The memo’s audience was federal. Its logic travels further.
Banks and health systems were not covered either. But they buy custom software under contracts with the same rights questions. The memo’s distinction between rights to reuse, rights to modify and actual delivery of code applies to any buyer. A firm that pays for custom development without securing delivery and rights faces the same lock-in risk the memo described. [1] For a bank or health system, the inventory idea also carries over. A list of custom code, tied to the contract that produced it and the repository that holds it, is, in our reading, the kind of record an examiner or auditor could ask for when a vendor relationship ends.
Objections, in order
1. The pilot was the policy’s heart, and dropping it was a retreat
The pilot set the memo’s only percentage target. It gave a number agencies could be measured against. [1]
But the memo itself made the pilot temporary and kept the rest of the policy in force. [1] The SHARE IT Act did not require open source release. It required sharing across government, ownership by the agency and public metadata. [3] In our reading, Congress chose to make permanent the parts the memo had made permanent.
2. A memo without enforcement was bound to fail
The Senate committee’s report said the policy lacked accountability mechanisms, uniform access procedures and requirements to report refusals. [2] It said that, according to a GSA compliance page it accessed in February 2024, thirteen agencies still did not share the code they buy with other agencies. [2]
That is a criticism of follow-through, not of the design. The memo’s two foundations, rights and an inventory, are the same foundations the Act uses. [1] [3] The Act added accountability around them: annual reporting, exemption justifications and a GAO review. [3]
3. Missions differ too much for code to move between agencies
Agencies do different work. A benefits system at one agency may not fit another. The memo acknowledged that solutions may combine existing federal, commercial and custom code. [1]
Reuse need not mean taking a whole system. Shared components, such as login modules, forms handling and data connectors, can be reused across different missions. The memo’s definition covered modules, plugins, scripts, middleware and APIs. [1] The smaller the component, the easier the fit.
4. Open code creates security risk
The memo let a CIO withhold code where sharing would create an identifiable risk to system security. [1] It also excluded the excepted code from pilot selection. [1]
The objection is strongest for code that reveals how defenses work. It is weakest for public-facing services whose behavior is already visible. The memo’s design let agencies distinguish those cases, but only with a documented decision. [1]
5. Rights clauses raise contract prices
A contractor that gives up exclusive rights to code may price that into its bid. The memo did not estimate cost effects.
The memo’s reasoning was that duplicate purchases and lock-in cost more. [1] The trade-off is real and specific to each contract. An acquisition officer can weigh it, but the default the memo set was that governmentwide reuse rights are the minimum. [1]
6. An inventory is paperwork that changes nothing
An inventory does not write or share code. Agencies can list code and still not share it.
But the inventory is how anyone outside the project learns the code exists. The memo made it the basis for OMB’s assessment. [1] The Act made metadata publication a legal duty. [3] Without the list, reuse depends on informal knowledge of who built what. With it, a second agency can at least find the starting point.
Checks a CIO or acquisition officer could run today
Contract language
Pull a sample of current custom development contracts. Check that each secures rights for governmentwide access, sharing, use and modification of custom code, the words the SHARE IT Act uses. [3] Check that each requires delivery of code and associated materials during development, as M-16-21 asked. [1]
Repository ownership
Check where contractor code lives. The Act requires custom-developed code and key technical components to be owned by the agency and stored in at least one public or private repository. [3] A contractor-controlled repository with no agency ownership would not meet that text, in our reading.
Key technical components
The Act lists what must be stored with the code: documentation, data models, schemas, metadata, architecture designs, configuration scripts and artifacts required to develop, build, test and deploy the code. [3] Check whether contracts require delivery of each.
Metadata and contract numbers
Check the code inventory against the Act’s metadata definition: contract or not, contract number, repository type and repository link. [3] An entry missing the contract number cannot connect code to the agreement that governs its rights.
Exemption records
List each piece of custom code withheld from sharing. Check that each has a recorded ground matching the Act’s exemptions and a narrative justification for the annual report. [3] Grounds that matched M-16-21’s mission-risk or national-interest exceptions need a fresh look, since the Act’s list does not include them. [1] [3]
The alternatives record
Check that new custom development projects have a written alternatives analysis showing that existing federal and commercial options were considered first, as the memo’s three steps required. [1] Check that the record weighs the resources required to later switch vendors, one of the factors the memo named. [1]
The agency policy itself
Check that the agency-wide source code policy reflects the Act. The Act required each CIO, with the acquisition officer and OMB’s Office of Electronic Government, to develop a policy implementing it and to correct inconsistent policies. [3] A policy written to M-16-21 alone may predate the Act’s access, metadata and exemption rules.
These checks are good practice drawn from the memo and the Act. The specific obligations for a given agency depend on the Act, OMB guidance and the agency’s own policies, and should be confirmed with agency counsel.
With hindsight
The clearest later verdict on the memo came from Congress. On September 9, 2024, the Senate Committee on Homeland Security and Governmental Affairs reported S. 3594, the Senate’s SHARE IT Act bill, with an amendment in the nature of a substitute. [2] Its report said that in 2016, OMB had attempted to address duplicative code purchases with the federal source code policy. [2]
The committee said the policy lacked accountability mechanisms, uniformity in procedures for accessing code, and requirements to report agencies that refused to share their code. [2] It said that thirteen federal agencies still did not share the code they buy with other agencies. [2] For that figure it cited a GSA agency compliance page it accessed on February 13, 2024. [2]
The report said the bill would require agencies to publicly list custom code they make or buy and share that list across government. [2] It said the bill would increase accountability by having CIOs oversee code sharing and report annually to Congress. [2]
The bill that became law was the House version, H.R. 9566. [3] The House passed it on December 4, 2024, and the Senate on December 17, 2024. [3] It was approved on December 23, 2024, as Public Law 118-187. [3]
The Act’s definition of custom-developed code follows the memo closely. It covers code produced under a contract with an agency or otherwise exclusively funded by the government, and code developed by a federal employee as part of official duties. [3] It includes code for which the government could obtain unlimited rights under FAR Part 27. [3] It excludes exploratory or disposable code and commercial software, including configuration scripts for it. [3]
The Act turned the memo’s two foundations into statute. The head of an agency that contracts for custom software development shall acquire and exercise rights sufficient to enable governmentwide access to, sharing of, use of and modification of the code. [3] The memo had said acquire and enforce. [1] The Act says acquire and exercise. [3]
On the inventory, the Act requires agencies to make metadata for custom code publicly accessible within the deadline it sets. [3] The metadata includes whether the code came from a contract, the contract number, whether it is in a public or private repository, and a link to the repository. [3]
The Act also requires the code and key technical components to be stored in at least one public or private repository, accessible to federal employees and owned by the agency. [3] The components it names include documentation, data models, schemas, architecture designs, configuration scripts and build, test and deploy artifacts. [3]
The Act does not require open source release. It contains no percentage target. [3] It applies to code developed or revised by federal employees, or under contracts awarded from solicitations issued, not less than 180 days after enactment. [3]
The exemptions are narrower than the memo’s. Classified code and code developed primarily for a national security system are outside the Act. [3] Code developed by an element of the intelligence community, and code exempt from disclosure under FOIA, are exempt from its sharing requirements. [3] A CIO, consulting the Federal Privacy Council, may exempt code whose sharing is prohibited by another law or regulation, or would create an identifiable risk to an individual’s privacy. [3] The memo’s grounds of risk to agency mission and the CIO’s view of the national interest do not appear. [1] [3]
The Act requires each CIO to report exemptions with a narrative justification by December 31 each year. [3] It requires a public annual report on implementation and a GAO assessment not later than two years after enactment. [3] It requires the FAR to be revised as necessary to implement it. [3] As checked on November 16, 2026, we have not confirmed whether GAO has issued its assessment or whether the FAR has been revised, and we make no claim about either.
GSA has updated its own policy. On January 22, 2026, GSA signed CIO 2107.1A, its revised open source software policy. [4] It said the Office of GSA IT takes an open-first approach to source code, and it named M-16-21 as the OMB memo that prioritized an agency-wide process for releasing open source code. [4]
The GSA policy requires project teams to develop new custom code in the open in publicly readable repositories, with justification required for code that does not. [4] It says it aligns with current federal open source requirements. [4] As checked on November 16, 2026, GSA listed it as active, with an expiration date of January 31, 2029. [4]
Spotted an error? Tell us and we will check it and correct the article where needed.