智能体软件工厂需求层次：从单个 Agent 到自动化与持续学习
智能体软件工厂的需求层次探讨了如何构建在用户离开时仍可持续工作的软件 Agent。文章由 Hugo Bowne-Anderson 和 Eleanor Berger 撰写，分析了从单个 Agent 演进到全面自动化与持续学习的架构路径。
- Explore Skills
View all * Data Engineering * Data Warehouse * SQL * Apache Spark * Microsoft SQL Server * MySQL * Kafka * Data Lake * Streaming & Messaging * NoSQL Databases * Relational Databases
View all * Data Science * Pandas * R * MATLAB * SAS * D3 * Power BI * Tableau * Statistics * Exploratory Data Analysis * Data Visualization
View all * AI & ML * Generative AI * Machine Learning * Artificial Intelligence (AI) * Deep Learning * Reinforcement Learning * Natural Language Processing * TensorFlow * Scikit-Learn * Hyperparameter Tuning * MLOps
View all * Programming Languages * Java * JavaScript * Spring * Python * Go * C# * C++ * C * Swift * Rust * Functional Programming
View all * Software Architecture * Object-Oriented * Distributed Systems * Domain-Driven Design * Architectural Patterns
View all * IT/Ops * Kubernetes * Docker * GitHub * Terraform * Continuous Delivery * Continuous Integration * Database Administration * Computer Networking * Operating Systems * IT Certifications
View all * Security * Network Security * Application Security * Incident Response * Zero Trust Model * Disaster Recovery * Penetration Testing / Ethical Hacking * Governance * Malware * Security Architecture * Security Engineering * Security Certifications
View all * Design * Web Design * Graphic Design * Interaction Design * Film & Video * User Experience (UX) * Design Process * Design Tools
View all * Business * Agile * Project Management * Product Management * Marketing * Human Resources * Finance * Team Management * Business Strategy * Digital Transformation * Organizational Leadership
View all * Soft Skills * Professional Communication * Emotional Intelligence * Presentation Skills * Innovation * Critical Thinking * Public Speaking * Collaboration * Personal Productivity * Confidence / Motivation
Platform
Search for books, courses, events, and more
- Explore Skills
Explore Skills
* Cloud Computing
Cloud Computing
* [Microsoft Azure](https://oreilly.com/search/skills/microsoft-azure/)
* [Amazon Web Services (AWS)](https://oreilly.com/search/skills/amazon-web-services-aws/)
* [Google Cloud](https://oreilly.com/search/skills/google-cloud/)
* [Cloud Migration](https://oreilly.com/search/skills/cloud-migration/)
* [Cloud Deployment](https://oreilly.com/search/skills/cloud-deployment/)
* [Cloud Platforms](https://oreilly.com/search/skills/cloud-platforms/)
Back
* Data Engineering
Data Engineering
* [Data Warehouse](https://oreilly.com/search/skills/data-warehouse/)
* [SQL](https://oreilly.com/search/skills/sql/)
* [Apache Spark](https://oreilly.com/search/skills/apache-spark/)
* [Microsoft SQL Server](https://oreilly.com/search/skills/microsoft-sql-server/)
* [MySQL](https://oreilly.com/search/skills/mysql/)
* [Kafka](https://oreilly.com/search/skills/kafka/)
* [Data Lake](https://oreilly.com/search/skills/data-lake/)
* [Streaming & Messaging](https://oreilly.com/search/skills/streaming-messaging/)
* [NoSQL Databases](https://oreilly.com/search/skills/nosql-databases/)
* [Relational Databases](https://oreilly.com/search/skills/relational-databases/)
Back
* Data Science
Data Science
* [Pandas](https://oreilly.com/search/topics/pandas/)
* [R](https://oreilly.com/search/topics/r/)
* [MATLAB](https://oreilly.com/search/topics/matlab/)
* [SAS](https://oreilly.com/search/topics/sas/)
* [D3](https://oreilly.com/search/topics/d3/)
* [Power BI](https://oreilly.com/search/topics/power-bi/)
* [Tableau](https://oreilly.com/search/topics/tableau/)
* [Statistics](https://oreilly.com/search/topics/statistics/)
* [Exploratory Data Analysis](https://oreilly.com/search/topics/exploratory-data-analysis/)
* [Data Visualization](https://oreilly.com/search/topics/data-visualization/)
Back
* AI & ML
AI & ML
* [Generative AI](https://oreilly.com/search/skills/generative-ai/)
* [Machine Learning](https://oreilly.com/search/skills/machine-learning/)
* [Artificial Intelligence (AI)](https://oreilly.com/search/skills/artificial-intelligence-ai/)
* [Deep Learning](https://oreilly.com/search/skills/deep-learning/)
* [Reinforcement Learning](https://oreilly.com/search/skills/reinforcement-learning/)
* [Natural Language Processing](https://oreilly.com/search/skills/natural-language-processing/)
* [TensorFlow](https://oreilly.com/search/skills/tensorflow/)
* [Scikit-Learn](https://oreilly.com/search/skills/scikit-learn/)
* [Hyperparameter Tuning](https://oreilly.com/search/skills/hyperparameter-tuning/)
* [MLOps](https://oreilly.com/search/skills/mlops/)
Back
* Programming Languages
Programming Languages
* [Java](https://oreilly.com/search/skills/java/)
* [JavaScript](https://oreilly.com/search/skills/javascript/)
* [Spring](https://oreilly.com/search/skills/spring/)
* [Python](https://oreilly.com/search/skills/python/)
* [Go](https://oreilly.com/search/skills/go/)
* [C#](https://oreilly.com/search/skills/c-sharp/)
* [C++](https://oreilly.com/search/skills/c-plus-plus/)
* [C](https://oreilly.com/search/skills/c/)
* [Swift](https://oreilly.com/search/skills/swift/)
* [Rust](https://oreilly.com/search/skills/rust/)
* [Functional Programming](https://oreilly.com/search/skills/functional-programming/)
Back
* Software Architecture
Software Architecture
* [Object-Oriented](https://oreilly.com/search/skills/object-oriented-architecture/)
* [Distributed Systems](https://oreilly.com/search/skills/distributed-systems/)
* [Domain-Driven Design](https://oreilly.com/search/skills/domain-driven-design/)
* [Architectural Patterns](https://oreilly.com/search/skills/architectural-patterns/)
Back
* IT/Ops
IT/Ops
* [Kubernetes](https://oreilly.com/search/topics/kubernetes/)
* [Docker](https://oreilly.com/search/topics/docker/)
* [GitHub](https://oreilly.com/search/topics/github/)
* [Terraform](https://oreilly.com/search/topics/terraform/)
* [Continuous Delivery](https://oreilly.com/search/topics/continuous-delivery/)
* [Continuous Integration](https://oreilly.com/search/topics/continuous-integration/)
* [Database Administration](https://oreilly.com/search/topics/database-administration/)
* [Computer Networking](https://oreilly.com/search/topics/computer-networking/)
* [Operating Systems](https://oreilly.com/search/topics/operating-systems/)
* [IT Certifications](https://oreilly.com/search/topics/it-certifications/)
Back
* Security
Security
* [Network Security](https://oreilly.com/search/skills/network-security/)
* [Application Security](https://oreilly.com/search/skills/application-security/)
* [Incident Response](https://oreilly.com/search/skills/incident-response/)
* [Zero Trust Model](https://oreilly.com/search/skills/zero-trust-model/)
* [Disaster Recovery](https://oreilly.com/search/skills/disaster-recovery/)
* [Penetration Testing / Ethical Hacking](https://oreilly.com/search/skills/penetration-testing-ethical-hacking/)
* [Governance](https://oreilly.com/search/skills/governance/)
* [Malware](https://oreilly.com/search/skills/malware/)
* [Security Architecture](https://oreilly.com/search/skills/security-architecture/)
* [Security Engineering](https://oreilly.com/search/skills/security-engineering/)
* [Security Certifications](https://oreilly.com/search/skills/security-certifications/)
Back
* Design
Design
* [Web Design](https://oreilly.com/search/skills/web-design/)
* [Graphic Design](https://oreilly.com/search/skills/graphic-design/)
* [Interaction Design](https://oreilly.com/search/skills/interaction-design/)
* [Film & Video](https://oreilly.com/search/skills/film-video/)
* [User Experience (UX)](https://oreilly.com/search/skills/user-experience-ux/)
* [Design Process](https://oreilly.com/search/skills/design-process/)
* [Design Tools](https://oreilly.com/search/skills/design-tools/)
Back
* Business
Business
* [Agile](https://oreilly.com/search/skills/agile/)
* [Project Management](https://oreilly.com/search/skills/project-management/)
* [Product Management](https://oreilly.com/search/skills/product-management/)
* [Marketing](https://oreilly.com/search/skills/marketing/)
* [Human Resources](https://oreilly.com/search/skills/human-resources/)
* [Finance](https://oreilly.com/search/skills/finance/)
* [Team Management](https://oreilly.com/search/skills/team-management/)
* [Business Strategy](https://oreilly.com/search/skills/business-strategy/)
* [Digital Transformation](https://oreilly.com/search/skills/digital-transformation/)
* [Organizational Leadership](https://oreilly.com/search/skills/organizational-leadership/)
Back
* Soft Skills
Soft Skills
* [Professional Communication](https://oreilly.com/search/skills/professional-communication/)
* [Emotional Intelligence](https://oreilly.com/search/skills/emotional-intelligence/)
* [Presentation Skills](https://oreilly.com/search/skills/presentation-skills/)
* [Innovation](https://oreilly.com/search/skills/innovation/)
* [Critical Thinking](https://oreilly.com/search/skills/critical-thinking/)
* [Public Speaking](https://oreilly.com/search/skills/public-speaking/)
* [Collaboration](https://oreilly.com/search/skills/collaboration/)
* [Personal Productivity](https://oreilly.com/search/skills/personal-productivity/)
* [Confidence / Motivation](https://oreilly.com/search/skills/confidence-motivation/)
Back
Back
- Platform
Platform
* [All features](https://oreilly.com/online-learning/features.html)
* [Verifiable skills](https://oreilly.com/online-learning/verifiable-skills.html)
* [Academies](https://oreilly.com/online-learning/academies.html)
* [Courses](https://oreilly.com/online-learning/courses.html)
* [Certifications](https://oreilly.com/online-learning/feature-certification.html)
* [Interactive learning](https://oreilly.com/online-learning/intro-interactive-learning.html)
* [Live events](https://oreilly.com/online-learning/live-events.html)
* [Virtual conferences](https://oreilly.com/products/superstreams.html)
* [Answers](https://oreilly.com/online-learning/feature-answers.html)
* [Insights reporting](https://oreilly.com/online-learning/insights-dashboard.html)
Back
Search for books, courses, events, and more
Toggle dark mode
AI & MLBusinessDataInnovationResearchSecurity
Try the O’Reilly learning platform
With the O’Reilly learning platform, you get the resources and guidance to keep your skills sharp and stay ahead. Try it free for up to 14 days.
Try a course for free
Join a live online event on the O’Reilly platform to learn from the experts shaping tech.
Get the Radar Trends newsletter
Your email
Country
Subscribe
Please read our privacy policy.
Thank you for subscribing to the O’Reilly Radar Trends to Watch newsletter.
The Agentic Software Factory Hierarchy of Needs
How to build software with agents that keep working while you’re away
By Hugo Bowne-Anderson and Eleanor BergerOctober 23, 2026 • 14 minute read
Share
CloseLinkedInXFacebookThreadsBlueskyReddit
The following article originally appeared on the Vanishing Gradients Substack and is being republished here with the authors’ permission.
Stripe’s Minions turn engineering requests into candidate pull requests. Ramp’s Inspect puts coding agents to work in the background, with tools to check their changes. Warp Factories takes work from tickets and chat through agents, checks, and human review.Agentic software factories are here.
Are you sick and tired of babysitting Codex, Claude Code, or OpenClaw?
Do you have agents that can build features, but still leave you responsible for remembering where they stopped, explaining how each feature fits the project and deciding what happens next? You make progress in each conversation, then development waits for you to return.
It doesn’t have to be this way. A software factory lets you delegate more of that process!
You agree on an outcome, give the system the context and authority it needs, and let it work while you do something else. When you return, there should be a result you can inspect, with evidence of what was checked, or a specific reason the work could not continue. Your next conversation can then focus on the result and the decisions that remain.
As we’ll show you, your first software factory doesn’t need to be that complex at all: It can begin with a single agent and an automation.
What makes it a factory
The defining combination is autonomous and asynchronous execution.
- Autonomous: The agent chooses and carries out steps towards an agreed goal. It can inspect what happened, adjust its approach and continue within its authority.
- Asynchronous: That work can proceed without your ongoing attention. You can leave and return to its result.
A scheduled job can run without you. A coding agent can choose and revise an approach during an interactive session. A factory combines those capabilities, with enough context, tools and feedback to carry out the delegated work.
Software factories have been hypothesized for decades. Now that we have agents, we’re actually able to operate them. The principles apply to software work traditionally carried out by teams of humans, from bespoke tools for teams and individuals to large and complex software systems.
To illustrate these principles, we’ll use an invoice tracker throughout this article, an application we’ve needed for our own businesses. The same approach applies to research tools, publishing systems, and software for teams. Suppose you run a small business and want an invoice tracker that fits how you work.
Build an app that creates invoices from my template and tracks which are unpaid, paid, or overdue. Keep it local for now. Preserve the records when it restarts, and show me checks that the totals and payment statuses are correct.
You can agree on this brief with the agent, leave it to work while you do something else, and return to the app and evidence of what was checked. If a check fails, it can investigate and adjust within its agreed scope. If it encounters a product decision it cannot make, it should bring that question back to you.
You might imagine a clean separation: The factory builds the invoice tracker, then the finished app does its job. That’s one way to run it. But agents can also help operate the software they build, and that combination is useful.
The tracker can store invoices and calculate outstanding balances. An agent can use those records alongside customer correspondence to prepare follow-ups: One customer has promised to pay on Friday; another is disputing a charge. You don’t need to turn every situation into a new software feature before the agent can help. You give it the relevant context, authority, and a way to check its work.
This changes what you need to build! Some behavior belongs in code, such as calculating balances consistently. Other work can be delegated to an agent that responds to the circumstances. If a recurring need emerges, you can ask the factory to build it into the software. The factory builds tools that agents can use, and experience using those tools helps you decide what to build next.
You still decide what is worth building, who it should serve and which trade-offs matter. Agents can help you make those decisions too. The practical change is that implementation can proceed between your conversations, including running checks and responding to failures.
This makes factories relevant to people with product, business or creative expertise as well as engineers. You might know exactly how you invoice clients, record payments, and chase overdue bills while having little interest in writing software. That knowledge lets you direct the factory toward software that fits your business, including the exceptions and connections that general-purpose tools handle poorly.
At every layer: specify what you want and how success will be checked, then verify the result.
Monica Rogati’s original AI hierarchy of needs described the foundations beneath successful AI work. We find that dependency framing helpful for factories too, with four different layers.
- Harness is the environment that exists around the model: tools, a workspace for project files, execution, and feedback. It lets an agent read files, change software and run it. If a check fails, the harness must give the agent enough information to investigate what happened.
- Personalization is the context and capabilities for your work: project direction, rules, reference material, skills and connections to other systems. The agent needs to know what you are trying to accomplish and which existing decisions it should preserve. Permissions limit access to tools and systems; sandboxing restricts the environment where actions can run.
- Automation is a way to start and continue work without a fresh instruction from you each time. A schedule or event can trigger a task or the pickup of ready work. It also needs direction about what qualifies as ready and where to leave the result.
- Continual learning is a process for learning from completed and failed runs, improving the factory and carrying those changes into later work. That might change an instruction, a checking procedure, or a tool the agent uses.
Automation needs a harness able to do the work, plus direction about what to do. Continual learning needs runs to inspect and a way to put improvements into use. These capabilities can develop together: A familiar harness, a short brief, and a basic automation are enough to start. You can personalize further as work reveals what is missing.
Two practices run through every layer: specification and verification.
- Specification makes the intended outcome, constraints, and criteria for success explicit. In our invoice brief, that includes preserving records after a restart and calculating payment statuses correctly.
- Verification checks the software, and the work agents perform against those requirements.
Agents can help you refine the specification and perform the checks. Your role is to decide whether the requirements capture what you need and whether the evidence supports accepting the result. As the factory takes on more work, these practices give you a way to direct it and assess what comes back.
Let’s now see what’s up in each layer.
1. Agent harness
First, you’ll need an agent harness. If you’re using Codex, Claude Code, Hermes, or OpenClaw, you already have one. It gives the model tools to read and edit files, run your software, and see what happened.
For our invoice tracker, the agent can build the app, create an invoice, record a payment, and restart it to check that the invoice and payment records survived. If a paid invoice still shows as overdue, it can investigate, fix the problem, and try again. You shouldn’t have to narrate every step. But if it needs a decision about how your business handles partial payments, that’s a question for you. If it lacks access or authority, the agent should stop and name the blocker.
You’ll also need somewhere for the harness to run. A cloud machine lets the agent keep working while your laptop is closed or disconnected. You can also run it on your own computer, but the machine needs to stay awake and connected for the work to continue.
2. Personalization
Next, give the agent the context it needs to work your way. For our invoice tracker, that means your template, payment terms, and conventions for recording payments. You don’t want to explain all of that again every time you start a new task.
Keep it somewhere future workers can find it:
- Rules: Preserve existing invoice records; ask before changing payment-status calculations
- References: Your template, payment terms, and example invoices
- Skills: Repeatable procedures for testing invoice creation, payment updates, and persistence
An instruction file such as AGENTS.md can point to this material. OpenAI’s harness-engineering account describes using a short guide that points into maintained project documentation. Give a new or scheduled worker a small task and check that it actually follows the guidance.
Be specific about when instructions apply. Eleanor once told an agent to write tests, and it wrote tests for a README. Enthusiasm wasn’t the problem
You’ll also need to set permissions and sandboxing to control what the agent can access and execute. Written instructions alone don’t enforce those boundaries.
3. Automation
One agent works in the background; you assess what comes back.
Now let’s give the factory a way to get started without waiting for you. A schedule or event can launch an agent with its brief, project guidance, and tools. You come back to a result, evidence of what was checked, or a specific blocker that needs your attention.
One agent working in the background
For our invoice tracker, a morning automation could check a saved task list and pick up the next agreed task, such as adding partial payments. You’ve decided what you want and how success will be checked. The agent gets on with it while you do something else.
There are a few practical details to get right. Don’t start the same task twice, leave an empty queue alone, and set limits on time and spending. Save progress so a later session can continue without you having to reconstruct the whole conversation.
One worker may be plenty. But perhaps you have independent tasks that could run in parallel, or you’d like another agent to review a change. That’s where coordination comes in.
Coordinate ready work, then check the combined result.
Coordinated work
With several agents, everyone needs somewhere to see what’s ready, what’s underway, and what’s waiting on something else. A shared task list or issue tracker can hold that information. You agree which tasks are ready; a coordinating agent or automation assigns them, supplies the relevant context, and records what happens.
Suppose one task adds partial payments, another overdue follow-up emails, and a third PDF exports. Follow-ups need the correct outstanding balance, so they wait for the payment behavior to be checked. PDF exports might proceed independently if the changes don’t overlap.
You can also split the roles. One agent builds the feature while another prepares payment scenarios to test it. A third might review the completed change.
Assign responsibility for combining the changes and verifying the whole application. Different questions call for different checks. Deterministic tests can establish whether balances are calculated correctly and payments survive a restart. Agent verification can help identify missed requirements or inconsistencies across the changes. Human judgment can assess whether the workflow fits how you actually work. You’ll often want a combination, with more than one kind of check on the same result. Anthropic’s evaluation guide describes these complementary approaches: code-based checks, model-based checks, and human evaluation.
Combine deterministic checks, agent verification, and human judgment according to what you need to establish.
Once you’ve checked that the combined features work together, you might task your factory with building a phone-friendly interface so you can check invoices and record payments on the move.
The factory can also help run the invoicing workflow as well as improve its software. A scheduled agent could review overdue invoices, consult customer correspondence, and prepare follow-ups for your approval. If that work repeatedly requires information the tracker doesn’t record, you can give the factory a task to add it. Building and operating feed into one another: Agents use the software, and what happens in use informs its next improvement. This brings us to continual learning.
4. Continual learning
Use run evidence to test and adopt improvements to future work.
Your factory can also get better at how it works. Suppose payments disappear after restarting the invoice tracker, even though the agent reported that its checks passed. You’ll want it to fix the bug, of course. But why did its checks miss the problem?
Keep a record of assignments, checks and difficulties so a review agent can identify recurring problems and propose improvements. Did the worker lack a way to restart the app, or did it simply skip that check?
If it skipped the check, the agent could propose a skill that saves a payment, restarts the app, and verifies the remaining balance whenever a change affects stored records. Test it against the original failure, then on further tasks. Does it catch problems with stored customer details too? Does it avoid unnecessary checks when a task only changes a heading?
The results help you decide whether to adopt, revise, or reject the method. Apply changes within the authority you’ve agreed and keep them reversible. Warp’s self-improving factories illustrate this approach: Failed checks can lead to proposed changes to prompts, skills, or configuration, submitted for human review with evidence from the runs behind them.
Reassess methods as the project and model change. Anthropic’s work on long-running application development describes removing procedures as model capabilities improved and checking the effect.
A saved lesson needs to reach later workers and improve their results. This learning happens through changes to the instructions, tools, and methods around the model, without requiring the model itself to be retrained.
What would you build?
Your factory could build a research tool that collects sources and lets you assemble briefings, a family intranet for shared plans and documents, or a private community space. Start with something useful to you, then give the factory further work as you discover what’s missing. Agents can also help operate what you build, from preparing a research briefing to organizing incoming material.
Hugo uses this combination to run Vanishing Gradients, his media and education business. After a guest prep call, an automation retrieves the transcript and prepares interview topics, questions, titles, and thumbnail options for review. After a live stream, agents can propose clips, cut video, add captions, and prepare upload drafts. Saved editorial guidance and skills shape the work; Hugo chooses what to publish.
He also maintains the system, improving checks when agents miss instructions, and updating skills based on results. More autonomous continual learning remains something he’s exploring. He describes the setup in How I Built a Media Empire With an Agentic Software Factory.
What’s one simple task you do repeatedly for your community, audience, or business that you could start automating?
Decide what your factory needs next
Look at what keeps bringing you back to the work. If the agent cannot run the app or inspect a failure, improve the harness. If you keep repeating project context and decisions, personalize it. If development waits for you to start each task or manage every handover, add automation. If the same failures recur across runs, build a learning loop that changes how later work is done.
Start with work you care about and inspect what comes back. One agent can use all four layers. Add capabilities where they help you delegate more useful work while keeping specification and verification part of the process throughout.
Post topics: AI & ML
Explore related articles
article AI & ML ## Software Factories, Light and Dark By undefined | undefined
article AI & ML ## Inside a Software Factory By undefined | undefined
Follow us
About O'Reilly
- Teach/Write/Train
- Careers
- O'Reilly News
- Media Coverage
- Community Partners
- Affiliate Program
- Diversity
- Content Sponsorship
Support
International
Download the O'Reilly App
Take O'Reilly with you and learn anywhere, anytime on your phone and tablet.
Do not sell or share my personal information.
© 2026, O'Reilly Media, Inc. All trademarks and registered trademarks appearing on oreilly.com are the property of their respective owners.
Close Previous
Next
Privacy Preference Center
When you visit any website, it may store or retrieve information on your browser, mostly in the form of cookies. This information might be about you, your preferences or your device and is mostly used to make the site work as you expect it to. The information does not usually directly identify you, but it can give you a more personalized web experience. Because we respect your right to privacy, you can choose not to allow some types of cookies. Click on the different category headings to find out more and change our default settings. However, blocking some types of cookies may impact your experience of the site and the services we are able to offer.
More information
Enable All
Manage Consent Preferences
Strictly Necessary Cookies
Always Active
These cookies are necessary for the website to function and cannot be switched off in our systems. They are usually only set in response to actions made by you which amount to a request for services, such as setting your privacy preferences, logging in or filling in forms. You can set your browser to block or alert you about these cookies, but some parts of the site will not then work. These cookies do not store any personally identifiable information.
View Vendor Details
Performance Cookies
Always Active
These cookies allow us to count visits and traffic sources so we can measure and improve the performance of our site. They help us to know which pages are the most and least popular and see how visitors move around the site. All information these cookies collect is aggregated and therefore anonymous. If you do not allow these cookies we will not know when you have visited our site, and will not be able to monitor its performance.
View Vendor Details
Functional Cookies
Always Active
These cookies enable the website to provide enhanced functionality and personalisation. They may be set by us or by third party providers whose services we have added to our pages. If you do not allow these cookies then some or all of these services may not function properly.
View Vendor Details
Targeting Cookies
Always Active
These cookies may be set through our site by our advertising partners. They may be used by those companies to build a profile of your interests and show you relevant adverts on other sites. They do not store directly personal information, but are based on uniquely identifying your browser and internet device. If you do not allow these cookies, you will experience less targeted advertising.
View Vendor Details
Vendors List
Clear
- checkbox label label
Apply Cancel
Consent Leg.Interest
checkbox label label
checkbox label label
checkbox label label
Reject All Confirm
来源：O'Reilly Radar · oreilly.com