GPT-6 Astra for developers: code, API and computer use

This is the technical page on GPT-6 Astra: the scores on the code and how much they really are worth, how the API is made —identifiers, endpoints, tools —, what changes between the five levels of reasoning, how it behaves on the long context and what it knows how to do when you let it use your computer.

All from official sources: API data sheet, announcement and system card. Verified data on September 4, 2026.

The numbers, in full

The picture is clear if two things separate.

For the terminal tasks — system configuration, data analysis, command-line software engineering A Astra is first with real margins: 2.1 points on Fable 5.1 and 5.3 on Opus 5, as well as a +20.6 on its previous generation.

On programming measured in a broad sense the primacy disappears: on both variants of FrontierCode it is Fable 5 in the lead, and on the coding index of Artificial Analysis.a third-party measure.it is first Opus 5.

The data that counts more than the score

On Terminal-Bench 4.0 OpenAI states that 57.9% comes to about the 9% less estimated cost compared to Sol and about 63% less compared to Fable 5.1.

The second figure is the important one: at the same list with Fable 5.1 — both $10 and $50 per million token — a 63% lower cost per task means that the model consumes much less to get to the same point. On a team that works all day, that difference is worth more than two benchmark points.

It must be said that it is a manufacturer's estimate on a single test, not a general rule. But it is verifiable: just fifty real problems run on both, counting the tokens actually billed.

What Changes in Codex

Along with Astra, OpenAI updated the Codex scaffold by declaring a task completion 1.9 times faster compared to the experience with GPT-5.6 Sol on the Mind2Web benchmark.

There is then an architectural novelty interesting for those who work on long sessions. Historically, when the context window fills up, models use the compaction: summarise the work done. However, each compaction can lose details about why a correction did not work or how a component behaves.

With Astra, Codex can Keep notes through different context windows, preserving the accumulated details without compressing them each time in a single summary. Previous windows remain searchable, so the model can find test requirements or results from past messages even if they had not been captured in the notes.

It is a function experimental, to be enabled in the Codex configuration, which OpenAI declares will become the default for Astra in the following weeks.

What band is needed, for what use

The right column covers a substantial share of a team's daily requests. For real-time suggestions, count the speed more than capacity: a completion that comes after three seconds is of no use to anyone, however good it is.

A mature team uses different models for the three modes of use —completion, discussion, autonomous agent — instead of choosing just one. The criterion is in best AI model for programming, and the correct way to read coding benchmarks in SWE-bench and coding benchmarks.

What Teams That Tried It Say

The announcement reports judgments of companies that have had early access. They are testimonies collected by OpenAI, then selected, but contain concrete observations that are worth reporting.

From Cognition, which integrates Astra into Devin's scaffolding, it is reported that computer usage, writing, and understanding of the codebase have improved testing "immediately", with easier-to-follow videos and clearer, more concise reports.

From Jane Street comes the observation perhaps most useful to a team: used for agent coding, Astra "communicates in an easier way for developers to follow and produces code that requires fewer iterations to achieve production quality".

This last point touches exactly what benchmarks do not measure. A model that produces acceptable code on the first spin saves more than one that gets a higher score but requires three revision steps —both in API cost and, above all, in people's time.

A Methodological Note on FrontierCode

On the two lines of FrontierCode there is a footnote that changes the reading of the result.

OpenAI states that on that Astra benchmark it was run with a system message similar to a section of his message in Codex, which asks in essence: avoid creating unnecessary test files, reuse existing utilities, read repository conventions and inspect nearby code, tests and documentation, with the aim of producing clean and integrable code.

OpenAI specifies that the prompt was not optimized for that test. But the fact remains that the result was obtained with specific instructions on expected behavior, and that those instructions describe good development practices.

It is useful information in two ways. First: Resize direct comparison, because not all models in the table have received the same treatment. Second, and more practical: suggests that instructions of this type improve the result, which is replicable on its own environment regardless of the model chosen.

The cost of a development team

Let's make a realistic count. A five-person team using an agent assistant all day can generate substantial volumes, because the code as context is heavy.

We assume 400 requests per day overall, with 15,000 input tokens (relevant files, session history) and 2,000 outputs.

Two levers radically change this account, and both are more effective than a model change.

The first is the cache: on Astra the input read from the cache costs 1 dollar instead of 10. On a stable project context reread dozens of times a day, it is the difference between 1,320 and a few hundred dollars.

The second is the file selection: a tool that locates the three relevant files costs a fraction of one that sends the entire repository, and also produces better answers because the model doesn't have to look for the needle in the haystack.

The specific risk of the generated code

One last warning that applies to any model, including this one.

A model that generates blatantly broken code does no harm: the test fails, someone notices it, corrects itself. A model that generates code that works on the expected cases but mistakes on untested ones produces a problem that will emerge in production, maybe months later.

The more the model is capable, the more this risk grows, because the product code is plausible and exceeds the surface review. Countermeasure is not technical but process: always ask to explain the change and of declare the assumptions made. A model that writes "I have assumed that this field is always valued" is giving you the information to verify; one that does not state it has made the same assumption in silence.

To go deeper. If you are considering adoption, start from GPT-6 Astra: what it is and what changes. The calculation of real expenditure —the one that includes reasoning, attempts and human review —is in GPT-6 Astra: prices and how to pay, while the stated limits are collected in GPT-6 Astra: all official benchmarks.

Identification and snapshot

The identifier is gpt-6-astra. The tab indicates that available snapshots and aliases all point to the same name.

Snapshots are used to block a specific version of the model, so that behavior and performance remain constant over time. It is a recommended practice for systems in production, because it prevents a silent update from changing the behavior of an already calibrated stream.

Endpoints supported

Two absences deserve attention. The fine-tuning is not available: you can not specialize the model on your data, and you have to get the same result with context and instructions. And the audio is not supported in any form, so a project that involves transcription requires a side-by-side model.

The Endpoint Responses is the one to use if you need the tools: the tab indicates that tool features are available through that interface.

The available tools

The equipment is extensive. Computer use is the one that enables the use cases described in the ad — fill out forms, browse software, update personal data — and is deepened in GPT-6 Astra and the computer use.

MCP It deserves a note: it is the protocol that allows you to connect the model to external sources and tools in a standardized way, and it is the cleanest way to give it access to business systems without building an integration tailored to each one.

Functionality

• Streaming: supported — useful to show the answer as it arrives
• Function Call: supported
• Structured Outputs: supported — essential for data extraction
• Reasoning Tokens: supported, with five levels of effort
• Fine-tuning: not supported

The streaming has a practical value often underestimated: in interactive scenarios the time to the first visible word counts more than that to the complete answer. On a model that reasons before answering is the difference between a tolerable wait and one that looks like a block.

The structured outputs are the function to be used in any data extraction stream, because they eliminate the fragility of having to interpret free text.

The processing methods, in practice

The card indicates four ways to run the same request, with very different prices. Choosing them well is worth more than any code optimization.

Between the economic extreme and the fast one there is a factor four. On a system that mixes urgent and non-urgent loads without distinguishing them, it means paying up to four times what is needed on a part of the traffic.

The verification to do is trivial and hardly anyone does it: list the requests that the system generates and mark which ones really have someone waiting. In most business cases a substantial share can wait —enrichment of archives, periodic reports, retroactive classification.and that share can stay on Batch.

The Cache: How to Use It Well

With cache input to 1 dollar against the 10 of the normal input, the cache is the most powerful economic lever available on this model. But it must be used knowing how it works.

Cache writing costs $12.50 per million tokens, i.e. 1.25 times the input not stored. It means that storing a content is only worthwhile if it comes reread at least twice.

The most profitable case is the system prompt: On tens of thousands of monthly calls with the same instructions, going from 10 to 1 dollar per million tokens on that portion changes the order of bill size.

Manage outages

An architectural requirement specific to this model, which must be predicted and not discovered.

OpenAI states that additional security controls can slow down, pause, or stop legitimate work. In ChatGPT or Codex, a review may be required; in API the task stops.

For an automatic stream this means that a call may never return the expected result, for reasons that do not depend on your code or data. The countermeasure is ordinary but needs to be implemented.

• Record any interruption with the context of the request
• Predict a queue for non-concluded cases
• Establish Who knows?: a mute automation is worse than a stop
• Don't try endlessly: limits attempts and goes beyond
• Monitor the percentage of interruptions in time

The last point is what reveals the problems before they become serious: if the percentage changes suddenly, something has changed.in the data, in the model or in the protections —and needs to be investigated.

Privacy and Data Retention

For a business project there is one last item to verify before writing code.

OpenAI declares that Astra supports the Zero data retention for eligible API customers, and who are experimenting with private security processing designed to strengthen monitoring while preserving customer confidentiality.

It should be borne in mind, however, that for models of this class an active monitoring of mismatch in production: a system of classifiers that analyzes reasoning and actions in search of unauthorized behavior.

It's two pieces of information to put together in the evaluation. The suitability for zero conservation goes confirmed on your contract, not taken for granted — and is the type of verification to be done before designing the architecture, not after putting into production a stream that treats confidential data.

From here, three useful insights. For full official numbers see GPT-6 Astra: what it is and what changes. The price list with the conditions that change the account is in GPT-6 Astra: all official benchmarks. And for the verdict by type of company, Where GPT-6 Astra is not the best.

What happens when you raise the level

The model no longer becomes capable: more space is taken to arrive at the answer. It produces intermediate reasoning, considers more roads, checks more before concluding.

There are three consequences and they must be considered together.

• The Salt Quality on tasks that require multiple linked steps
• The Salt Cost, because intermediate tokens are paid as output
• The salt latency, often sensitively
• On simple tasks the gain is null or negative

The last point always surprises. On a recognition task — classifying a message, extracting a date — raising the level does not improve anything and sometimes gets worse: the model processes a simple answer more than necessary and ends up complicating it.

Results at Reduced Levels

OpenAI, however, also publishes two results at cheaper settings, and they are the most useful of the entire ad for those who have to design a real system.

The first line is the one that should guide choices: a reduced Astra setting exceeds anyway the best result of the previous generation, spending about a third less.

Translated: in most cases you don't need the maximum level to get a better result than you had before. It's the kind of information that changes a quote.

How to choose the level

The practical rule is simple: raises the level when the task concatenates reasoning steps, lowers it when it is recognition or extraction. Choice must be made by type of task, not once and for all.

The Two Specular Errors

Setting the maximum anywhere "for safety". It seems prudent and it is not: it multiplies the cost on all traffic, including the thousands of trivial requests that do not benefit from it, and it worsens latency right where users notice it. On a model with output at $50, it's the most expensive mistake you can make.

Keeping the minimum anywhere to save money. It produces hasty answers on tasks that require reasoning, which then need to be corrected by hand — and correction time costs more than saving.

The bill: how much does it cost to raise the level

Let's take a concrete example to make the economic impact tangible.

We take 20,000 requests per month with 3,000 input tokens and a visible response of 500 tokens. Output consumption changes radically with the level, because reasoning tokens add up to the answer.

Multipliers are indicative and must be measured on their own case — the only thing certain is the direction. But they illustrate the point: the exact same request can cost ten times as much only by changing a parameter, without touching the prompt.

Instead, the input remains constant at $600 per month in all scenarios. That is why on a model with output at five times the input, the level of reasoning is the most powerful economic lever available.

The effect on latency

Reasoning doesn't just cost money: it costs time. And in some scenarios time weighs more than money.

Raising the layer means that the model produces intermediate tokens before to start answering. On an interface where someone looks at a screen, the difference between two seconds and ten is not a detail: it is the difference between a tool you use and one you abandon.

In agentic flows the effect multiplies by the number of steps. An agent who takes twelve steps at the high level pays the delay twelve times, and an execution that on the average level lasts three minutes can reach ten.

The last line is where the maximum level really justifies itself: few cases, high value by chance, no one waiting. Outside of there is almost always excessive.

How it combines with Fast mode

On Astra there is a second parameter that touches the speed: the Fast mode, which according to the documentation offers up to twice the speed at twice the applicable price.

The two add up so that it is worth understanding. Fast mode doubles the tariff; a high level of reasoning multiplies the tokens consumed. Activating them together on all traffic produces a surprising account.

The sensible combination is almost always the opposite of the instinctive one: level of reasoning appropriate to the task, Fast mode only where latency is a real requirement. Raising both "for safety" is the quickest way to multiply spending without a corresponding gain.

Finally, it is worth remembering that Batch and Flex cost half the Standard: on a non-urgent load, the most efficient combination is adequate level and economical mode, as described in GPT-6 Astra: prices and how to pay.

A question that precedes the choice of the level

Before fixing the effort, it is worth asking yourself a more upstream question: Do you need this model?

The level of reasoning is the right lever when the model is the right one. But if the task is to classify messages or extract fields from structured documents, the problem is not what effect to set on Astra: it is that an economy-range model would do the same job at one-fiftieth of the price, with whatever setting.

The correct order is therefore: first the band, then the level, then the mode. Inverting it — finely calibrate the parameters of an oversized model. is an optimization that produces marginal savings on an expense that did not have to exist.

The criterion for the first decision is in when an economic model is enough.

A Detail on Documentation

The model card lists the five levels without specifying the default. This is worth checking directly in your integration, because it determines what happens if you specify nothing — and therefore how much you are spending today without having decided to.

It is the same category of verification that is best done on the model identifier: check what the system really uses, instead of hiring. In projects that have grown over time, the difference between the desired configuration and the actual configuration is more common than is believed.

The rest of the route, in three pages. The comparison with the previous generation is in GPT-6 Astra: what it is and what changes. For benchmarks that the model lags behind, GPT-6 Astra: all official benchmarks. The method to verify everything about your cases is in Where GPT-6 Astra is not the best.

The numbers on long-distance recovery

The benchmark MRCR checks if a model can find specific information hidden in a very long context — in the mentioned variant, eight different information to retrieve.

The interesting fact is the second line: in the most difficult band the previous generation lost more than a quarter of the information, while Astra recovers more than 96%.

It is the most regular improvement of the entire ad, and has a practical consequence: on very long documents the risk of an important detail being overlooked is significantly reduced. It does not disappear —96.3% still mean that something can escape — but it changes order of magnitude.

Why filling the window is almost always wrong

There is a widespread and expensive idea: if the model accepts a million tokens, you might as well use them. There are three reasons why it doesn't fit.

It costs, and on every call. Context is not an included function: you pay every time you send it. A document from 300,000 tokens passed in full to twenty different questions costs twenty times that document — and over threshold, at twice the rate.

It doesn't improve the response. In practice, information at the beginning and end of the context is used more reliably than information buried in half. On very long documents a central detail can be overlooked even if technically the model has read it — and 96.3% of MRCR confirms that something is missing.

It hides the real problem. If a system needs to send everything, it usually means that no one has built a way to find the relevant part. And it's that piece that makes the system useful, not the window size.

The right column covers most real business requests, and in all the big window is a capacity that you pay without using it. The complete reasoning is in context window: how much it really matters.

The Limit You Meet First

Everyone looks at the input; hardly anyone looks at how much the model can produce. And in many document projects that's the constraint you touch first.

One hundred and twenty-eight thousand output tokens are many for one answer, but they become narrow in three recurring scenarios: translate a document in full, rewrite it or reformat it completely, produce a table with one line for each entry in an extended list.

The solution is to break the work and recompose it, but it needs to be planned: finding out in the middle of development costs more than taking it into account from the beginning.

The cache, the stable context ally

On a model with input at $10 per million tokens, there is a leverage that changes the bill: the input read from the cache costs 1 dollar, i.e. a tenth.

Cache writing, however, costs $12.50, more than normal input. So memorizing is only convenient if that content will be reread more than once — but on a system prompt or on stable reference documents it is exactly the case.

How much is a million tokens really

To make the window concrete, some practical reference.

The exact conversion depends on the language and type of text, and Italian tends to consume a little more than English with equal content —a detail that should be kept in mind when comparing estimates found online, almost always calculated on English texts.

The most useful reference is the penultimate line: the threshold of 272,000 tokens corresponds to a few hundred pages. For most business tasks it is abundant, which means that the increase concerns a minority of cases — but that minority must be identified first, not discovered in the invoice.

The official numbers

The generational leap is clear: fifteen points on ScreenSpot-Pro compared to Sol, seven on OSWorld, almost six on Agents' Last Exam.

The comparison with the competition is more nuanced than the communication suggests: on OSWorld 2.0 the advantage on Opus 5 is to 2.4 points, on Agents' Last Exam of 3,8. They are real margins but not overwhelming.

The Time Factor

Alongside the scores, the ad reports two speed measurements —which is rare and particularly relevant for agents.

Up OSWorld 2.0, in latency simulations, Astra obtains 72.6% employing approximately 40 minutes per task, compared to about 65.7% in 75 minutes of the previous generation. More result in about half the time.

On the benchmark Mind2Web, with the updated Codex scaffolding, OpenAI declares a task completion 1.9 times faster compared to the experience with GPT-5.6 Sol.

That matters more than it seems. In the streams that use the computer the latency multiplies by the number of steps: if a task requires forty actions, halving the time of each changes if that stream can turn while someone is watching or only during the night.

What he claims to know how to do

The ad lists concrete tasks, which are worth reporting because they are more informative than a score.

• Compile Online Forms and update customer records in a CRM
• Organizing the calendar
• Do online research and write summaries in emails or documents
• Analyzing scientific data, generate graphs, create a site
• Run Quality Controls on the frontend of a site
• Install and test software, diagnose problems seen on screen

Examples shown include the layout of a printed circuit board in an electronic design software, the compilation of a tax form, the formatting of a legal document, and the use of business intelligence tools.

These are tasks that have one characteristic in common: specialist software without convenient APIs. It is exactly the space where computer use makes sense — where traditional integration does not exist or would cost too much.

When it's really needed

The right column deserves a note: Navigating an interface to a model is more fragile than calling an API. If integration exists, the correct path remains. The use of the computer is the solution for the case where does not exist.

How it behaves when education is ambiguous

An aspect that benchmarks capture little and that in the daily use of an agent weighs a lot.

The ad describes Astra as better than previous models in deciding what to do when the instructions leave room for interpretation: it uses context to fill in routine gaps and Asks targeted questions when the answer would change the outcome. In Codex can ask asynchronously, while continuing the work that does not depend on the answer.

If it receives no response, it proceeds with reasonable assumptions where appropriate, but waits decisions with consequences.

There is then an improvement on maintaining orientation: earlier models sometimes treated a correction message as a new target, losing the original request or initial constraints. Astra is described as capable of incorporating new requirements, changing course when required and answering side questions without abandoning the main task.

Security: the numbers and the price to pay

On the use of the computer OpenAI publishes specific alignment metrics, where a lower value is better.

The comparison was made, OpenAI declares, with a generic scaffolding based on the computer use tools available in the APIs of both suppliers, and without the additional protections normally active in Codex and ChatGPT Work.

The reverse side of the coin is declared with just as much clarity: the extra controls can slow down, pause or stop legitimate work. In ChatGPT or Codex a revision may be requested before continuing; in API the task stops.

For those who design an automation that runs at night without supervision, this is an architectural requirement, not a detail: you need a mechanism that records the interruption and brings it to someone's attention.

The jump that makes projects possible before excluded

It is worth isolating what really changes for an SME, beyond the scores.

So far automating a process that goes through a software without API meant one of three things: paying for a custom integration, resigning to manual work, or building a script that mimics clicks and breaks at the first interface change. All three have a cost that often exceeds the benefit on average volumes.

A model that Look at the screen and see what he's seeing. changes that calculation: tolerates small variations of the interface, does not require mapping each field in advance, and should not be rewritten when the provider updates the management software.

This does not make it suitable for everything — it remains more fragile and slower than an API, and should be used where the alternative does not exist. But it shifts the threshold beyond which automation becomes convenient, and some processes that have so far remained manual enter the sustainable zone.

It is the kind of gain that benchmarks do not capture and that is measured in one way only: how many hours of repetitive work become available.

Three linked references. The general overview is in GPT-6 Astra: what it is and what changes, the real costs in GPT-6 Astra: prices and how to pay, and the assessment by business use case in GPT-6 Astra: all official benchmarks.

The example of the presentation

The ad shows a specific case: Astra creates a presentation on a dummy model using few slides of the OpenAI template as a reference, keeping correct tone and layout throughout the document.

The resulting statement is practical: you can expect presentations formatted according to your company's standards, not according to a generic layout.

For those who produce commercial materials or recurring relationships, this is the point that changes the calculation. The time spent reformatting a generated document is often close to what it would take to write it —and if that time disappears, the gain becomes real.

Creating Sites and Applications

Next to the documents, the ad describes an adjacent capacity: Astra brings a more solid visual judgment in the sites, games, applications and rendering it builds.

With the Sites in ChatGPT feature, OpenAI declares, it can create, host, and share sites, web apps, and games directly from a prompt. Among the examples shown are an architectural scene modeled in Blender and transformed into a navigable environment in Unreal Engine, and games with consistent graphics and movement.

From Higgsfield AI a judgment that touches on the economic point: Astra performs the most complex creative flows ‘using up to 20% fewer tokens than the other models tested’, with the main effect of a higher quality of output for customers.

It is the same pattern that occurs throughout the announcement: the stated advantage is not only qualitative but of efficiency, and on a price range like this the two add up.

The cost of long documents

There is a specific economic aspect to this use case that deserves a calculation.

Producing documents means generating a lot of output, and it's the expensive entry: $50 per million of tokens versus 10 of the input. An articulated document can require several thousand tokens output.

The figures per single document seem negligible, and they are. They become relevant on the volume: a thousand reports per month are two hundred dollars of output only, and the reasoning tokens must be added, which on structured tasks are not few.

The comparison that matters remains that with the alternative: if producing that relationship by hand takes forty minutes, the cost of twenty cents is irrelevant. This is the case where the return calculation is simple and favorable — as long as the document exits usable, otherwise the accommodation time eats the gain.

Beware of the output limit

A technical constraint that in this use case is encountered more than elsewhere: the maximum output is of 128,000 tokens.

They are many for a single answer, but they become tight in three recurring situations when producing documents.

• Translate a long document in full
• Rewrite or reformat fully an extended text
• Producing a table with one line for each entry of a long list
• Generate a very large structured document at once

The solution is to break the work into parts and recompose it, with the carefulness of maintaining consistency of style between the parts. It's not complicated, but it needs to be planned: finding out in the middle of development costs more than taking it into account from the beginning.

The full framework on context and output limits is in GPT-6 Astra and the Long Context.

The advantage of working inside the tools

There is an element that distinguishes this use case from a normal text generator: Astra can operate directly in the software that you use.

The ad cites data analysis with graph generation, the use of business intelligence tools, formatting a legal document, and filling out forms. It does not "produce a file that then matters": it works inside the application.

For a company the difference is substantial. An output that already comes in the right format and place eliminates the manual step that usually cancels the automation gain. And it is also why this ability connects directly to that described in GPT-6 Astra and the computer use: they are the same thing seen from two angles.

The limit remains that of computer use in general: it is more fragile and slower than a true integration. Where there is an API, that remains the correct path.

Three linked references. The general overview is in GPT-6 Astra: what it is and what changes, the real costs in GPT-6 Astra: prices and how to pay, and the assessment by business use case in GPT-6 Astra: all official benchmarks.

Practical examples

Team that automates database migrations. On internal migrations the gap is 6.1 points on Fable 5.1 and 21.2 on Sol. It is the most distinctive area along with the terminal.

Software house evaluating the day-to-day assistant. Here the verdict is open: on FrontierCode and on the Artificial Analysis index we are on par with Claude, and Opus 5 costs half. It is worth the test on ten real problems already solved by the team.

Project with very long debugging sessions. Notes between contexts are designed exactly for this. It is the function to be tried first, bearing in mind that it is experimental.

Mistakes to Avoid

• Reading "Best Model for Software" as "wins everywhere".
• Use it for completion, where you need speed and it costs too much.
• Ignoring the Artificial Analysis Index, which is third party.
• Comparing Scores obtained with different scaffolding.
• Activating notes between contexts in production without trying them: they are experimental.
• Forgetting the 272K token threshold in long sessions.

How to apply it in the company

For a development team the path has three steps, and the first is what almost no one does.

It separates the three modes of use. Completion while writing, conversational assistant, autonomous agent. They have opposite requirements —the former needs speed, the third capacity —and treating them as a single problem makes them spend too much to get little.

Try your code. Ten real problems already solved by the team, including at least three interventions on existing code and not new files. Writing a function from scratch is a task that all modern models perform; editing code with conventions accumulated over the years is real work.

Evaluate two things separately. If the code works and if it is code that you would accept in revision. Only the first one measures it a benchmark.

Finally, it counts the attempts: a model that costs twice as much but closes on the first shot instead of the fourth is convenient, and on this band it is the calculation that decides.

Conclusion

On the development side the difference does not make it the score on a benchmark, but three choices: the right level of reasoning for the task, a well-built cache and a kept context short and stable. Wronging them costs more than any list difference between models.

And a model that uses the computer instead of you opens up projects that are out of reach first, but moves the problem to the perimeter: what it can touch, with what credentials, with what register. prices and real cost; for the general picture, What it is and where it doesn't get.