DEV Community: Tidiane Stano

Codex Background Tasks: Why Completed Jobs Cannot Be Resumed Directly

Tidiane Stano — Sun, 20 Sep 2026 08:56:45 +0000

Imagine a workflow where a task is delegated to Codex inside Claude Code for work within a shared code repository. After some time, users run the /codex:result command and receive output, intending to continue modifying the same codebase. This operation carries a hidden risk: there is no guarantee the returned result comes from the target task. Developers need to validate which job the output belongs to, whether the task fully succeeded, and if the returned code matches the current state of the repository.

This article analyzes the underlying logic of openai/codex-plugin-cc. When users fetch results, the plugin only locates matching task end records. Before continuing work with these outputs, teams must verify job identity, termination status, and the active workspace. Switching back to Codex to resume work imports a separate set of context. The analysis draws from offline controlled experiments: the official job selection function runs with manually constructed local records, without live model workers or real conversation migration. The fixed source commit for validation is db52e28f4d9ded852ab3942cea316258ae4ef346. All tests were completed on September 20, 2026. This analysis does not generalize findings to all Codex product variants.

A Retrieved Result May Belong to the Most Recent Failed Task

A Completed Task Record Does Not Equal Successful Execution

Within a single conversation session, two finished task records can coexist: an older entry marked completed, and a newer entry marked failed. When calling the official resolveResultJob function without supplying a job ID, the plugin will return the newer failed record by default.

Manual Input	Actual Return from Official Function
Same conversation: older `job-a-old` completed, newer `job-a-new` failed	Default result selects `job-a-new`, status: `failed`
Single entry `job-cancelled`, status `cancelled`	Specified ID result can fetch this record

The plugin’s job-control.mjs filter accepts three terminal states: completed, failed, and cancelled. When no ID is passed, the system filters records by the active conversation, then sorts entries using updatedAt, returning the newest terminated task.

A result output does not automatically confirm task success. Subsequent processing reads file outputs and error logs stored in the record, but it does not re-run validation to confirm genuine successful model execution. This offline experiment only tests record selection logic and does not fabricate fake successful model responses.

Standard Verification Workflow

When starting a task, preserve the returned job-id. Use this identifier for all subsequent queries:

/codex:status <job-id>
/codex:result <job-id>

Replace <job-id> with the real task identifier. Validate status first, examine outputs and errors, then judge whether the task supports further operations. The native success field in the codebase is completed. Do not confuse this with custom status labels like succeeded.

Two Windows for the Same Repository Do Not Share The Same Task Table

Another common misconception: multiple Claude Code windows accessing one repository see identical task lists. In practice, task records are filtered by active conversation context.

In the offline test setup, two conversation sessions were created: Session A holds two active jobs, Session B holds one active task. The environment sets the current conversation ID to Session A.
When calling buildStatusSnapshot(..., {all: true}), the active task list only returns Session A’s two jobs. Session B’s task is hidden. However, calling buildSingleJobSnapshot with the full job ID from Session B successfully retrieves the isolated task record.

Two distinct retrieval paths exist. Queries without an ID filter records against the current conversation. Queries with an explicit job ID match records against the task list of the workspace, ignoring conversation scope. The --all flag only expands the total number of entries loaded, and does not remove conversation filtering. Without a valid current conversation context variable, the default list skips cross-session records.

This behavior explains a frequent confusion: after switching Claude Code windows, missing tasks do not mean records are deleted. Confirm the active workspace first. Explicit ID lookups can bypass conversation filtering, which proves this mechanism acts as scope filtering rather than account permission isolation.

This filtering rule also affects task cancellation. In the experiment, Session A contained two running Codex jobs. Calling the native cancel function without a job ID returns the following warning:

Multiple Codex jobs are active. Pass a job id to /codex:cancel.

This raw error output comes from offline test runs; no actual cancellation operation executes. The plugin requires explicit task selection and cannot guess the intended target job automatically.

Cancelled Records Cannot Replace File System Validation

Local Cancellation ≠ Remote Confirmation

When users trigger task cancellation, the workflow proceeds through three stages:

Attempt task interruption
Terminate job.pid for the corresponding process tree
Write the cancelled state to local records

Source code fields for cancelled tasks include status: "cancelled", turnInterruptAttempted, and turnInterrupted. Static code review shows the handleCancel function reads thread and turn identifiers, attempts interruption, terminates the process tree, then updates the local job entry to cancelled.

The critical limitation: this workflow contains no built-in Git rollback logic for the workspace. Even when interruption attempts fail, the system can still write the cancelled state locally. The cancelled flag alone cannot prove the remote turn acknowledged termination, nor confirm modified files have been restored to their original state. This conclusion comes from static source review; the experiment did not run live termination or remote interruption tests.

Returning to the repository workflow example: if file modifications were permitted during investigation, users must inspect current files after cancellation before deciding to retain or revert changes. Use these shell commands to inspect repository state:

git status --short
git diff --stat
git diff --cached --stat

The two diff commands inspect unstaged and staged file changes respectively. The status output lists modified files, and further diff review exposes content changes. These commands help confirm repository state, though they cannot capture all external side effects. Never run destructive commands simply because a task was cancelled.

For records marked completed, the flag only indicates the task reached its terminal state. Output references may remain valuable even if the task partially failed. The worst case is silent partial success, where file changes expand far beyond the intended scope, requiring full re-review. It is unnecessary to rebuild the full background task every time.

Resume Existing Jobs or Transfer Conversations

Two separate operations control task continuation: resume and transfer.

resume: Continue an existing Codex investigation within the same conversation
transfer: Import a Codex thread into a separate Claude conversation

Before resuming work, validate the current file state first.
For ongoing Codex investigations within the same conversation, use /codex:resume. The fixed version of the command requires confirmation of the selected Claude conversation’s resumable records. Without explicit resume or fresh parameters, the prompt forces users to select or rebuild background task state. The command converts work into background task execution, controlling how Claude Code subagents operate.

For cross-conversation handoff, transfer imports the Codex thread ID into a new Claude session:

/codex:transfer <thread-id>

The import loads the Codex runtime project, reads the .json metadata file, and imports source code references. If the thread is not found, the system returns an error. The transfer operation does not automatically migrate Git workspace changes or full file modifications. It imports metadata only. A transfer success response does not guarantee all file state is fully replicated in the new conversation.

When teams manage multi-agent workflows with many Codex and Claude Code sessions, unified request routing can reduce complexity. 4sapi acts as an API gateway to centralize credential and traffic management across multi-model agent pipelines.

Document Handoff: Generate Verifiable Transfer Notes

When handing tasks between sessions, preserve structured verifiable records rather than only passing final outputs. The template below defines key handoff fields:

Goal: What question the investigation intends to resolve
Input: The starting repository state and baseline code
Current: job-id, timestamp, and active workspace
Changes: Which files have been modified
Conclusion: Critical findings and unresolved risks
Next steps: Who continues the task, and what edits are permitted

The commit hash from git rev-parse HEAD can record the starting commit point. However, HEAD alone cannot represent uncommitted edits. Separate records must capture staged and unstaged diffs, as well as newly added untracked files. A handoff note only provides a starting reference point; the receiving developer must re-verify the current working tree.

If a task only performs read-only investigation and leaves files unchanged, validation is simpler. If edits occurred during execution, or the workspace has switched, inspect file and job status before restoring conversation.

When invoking /codex:result, always reference the original job-id captured at task startup. Only matching identifiers confirm that outputs belong to the target task.

Conclusion

Codex task completion status stored in plugin records is not sufficient proof for safe workflow continuation. Developers must validate job identifiers, task terminal states, and the actual filesystem changes in the repository. The plugin’s default behavior returns the newest terminated record without ID filtering, which can accidentally load failed task outputs.

Cancellation and completion status flags are metadata markers only. Neither status automatically reverts file modifications within the workspace. Cross-conversation transfer and resume operations carry scope limitations: they import metadata, but do not replicate full workspace state. Standardized handoff documentation and Git state inspection are required to safely continue work across sessions.

Offline experiments used the official plugin source repository and matching probe.mjs scripts, and all test outputs and local reproductions are retained. No live model workers or real conversation agents were invoked for these validation tests.

International access: https://4sapi.com
Domestic access: https://4sapi.cn

ChatGPT Pro 20X Limited-Time Reactivation

Tidiane Stano — Sun, 20 Sep 2026 08:55:21 +0000

In early September 2026, OpenAI halted new subscriptions for its $200 ChatGPT Pro 20X tier. After this pause, the platform rolled out a dynamic capacity management scheme for ChatGPT Pro 20X.

Not every user gets unrestricted access. OpenAI releases subscription eligibility to qualified users following server load constraints. Understanding the scope of this policy, its technical background, qualification rules and multi-channel computing resource management can help developers and enterprise technical teams properly plan computing budgets and system capacity.

What Is ChatGPT Pro 20X

ChatGPT Pro 20X is OpenAI’s flagship subscription plan built for extreme production workloads, priced at $200 per month. Before this tier launched, individual paying users mainly relied on the $20 per month Plus plan. Later OpenAI introduced the $100 Pro 5X tier as a mid-range option.

In terms of performance specifications, Pro 20X delivers a quota equivalent to 20 times that of a standard Plus account. It also holds the highest priority for compute scheduling. During periods of high network concurrency and tight computing resources, this tier maintains stable response speed and is not limited by conventional rate caps.

Additionally, the plan provides underlying support for ultra-long context windows and long-duration autonomous agent tasks. It primarily targets technical teams and heavy-duty developers running end-to-end long-chain reasoning, complex code audits, system architecture refactoring and deep scientific research analysis.

Policy Scope: Who Can Access This Reactivation

Official documentation confirms that this reactivation is a controlled release. The core eligible group consists of historical users who previously held Pro 20X subscriptions and had their service interrupted. It is not open for unrestricted purchase for brand-new users.

The detailed rules include a one-time return mechanism. This policy applies to former 20X users who manually canceled their subscription, had service terminated due to payment failures, or voluntarily downgraded to the $100 tier. Within 30 calendar days after the status change, these users get one single chance to reactivate the $200 package.

For existing free users, standard Plus subscribers, and Pro 5X users who have never purchased 20X, the backend upgrade channel remains locked. The interface will still display messages that subscriptions are sold out or suspended.

Supply and Demand Logic: Why the $200 Plan Was Temporarily Paused and Reopened in Limited Quantities

When a primary account hits rate limits, encounters network jitter or sporadic failures, an API gateway can complete channel hot switching and automatic failover within milliseconds. It prevents ongoing code refactoring and agent tasks from being forcibly terminated. The dashboard also delivers clear call statistics so teams track real costs for every channel.

Another key capability is flexible model mapping. Long-context models deliver strong reasoning capability, yet frequent use for non-deep reasoning scenarios consumes quota rapidly. With model mapping rules defined on the gateway layer, teams can automatically reroute high-consumption requests under specific conditions. For example, mapping claude-opus-5 to glm-5.2 or other cost-effective models. This transparent forwarding on the gateway side protects primary account quota without modifying calling logic in business services.

Virtual API key generation and cross-project credential isolation are also critical. Teams can generate multiple virtual API keys locally and assign them to different developers, local testing environments or individual projects. Developers no longer need to hardcode primary credentials into multiple code repositories. This reduces the risk of secret leakage, and supports fine-grained quota allocation and consumption monitoring for separate projects.

The underlying protocol auto-adaptation capability simplifies multi-model integration. Historically, different model providers adopt vastly different data structures. No matter which specification or SDK upstream services use, the gateway unifies requests under one standard protocol. It automatically resolves protocol differences, so developers avoid rewriting client adapter code for every model provider. When building multi-model agent workflows, teams can leverage an API gateway to manage credential distribution and traffic routing, and 4sapi can serve as a unified layer for multi-model access in such production systems.

Frequently Asked Questions

Can newly registered accounts directly purchase and activate Pro 20X?

No. OpenAI currently blocks upgrades for newly registered accounts and ordinary Plus users. This reactivation channel only serves former 20X subscribers within the 30-day service interruption window.

After old users downgrade to the $100 tier, can they switch repeatedly between 5X and 20X?

No. Official rules state the reactivation opportunity is one-time only. Once a user returns to the $200 tier from the $100 tier, if they cancel or suspend again, they permanently lose eligibility to buy 20X.

Does the 30-day recovery window count calendar days or business days?

The window counts natural calendar days. The countdown starts from the end of the previous billing cycle or the effective time of downgrade, counting precisely 720 hours.

Will the $200 plan face price hikes or quota reduction in the future?

High-capacity models carry heavy operating costs. Industry analysts widely expect that the platform may introduce independent quota limits for specific high-consumption models, or restructure pricing rules for premium subscriptions amid long-running tight compute supply.

Trend Analysis and Practical Recommendations

Judging from OpenAI’s capacity scheduling actions, high-end compute supply for large language models will stay constrained in the near term. Unlimited monthly packages and oversized quota modes are gradually being replaced by refined quota management.

For developers who still hold active 20X subscriptions, the safest practice is to keep payment cards valid and avoid downgrades or cancellations unless necessary. For original subscribers inside the 30-day protection window, they need to assess workload demands for coming months before deciding whether to redeem their one-time reactivation right.

New users who cannot access 20X do not need to buy high-risk accounts from unofficial markets. A more rational path is to adopt the Pro 5X subscription for daily interaction, paired with pay-as-you-go official API access for peak demand.

On this basis, an API gateway can aggregate multiple model sources, combine with on-demand billing, and leverage automatic failover, virtual key management and protocol conversion. Teams can build stable, continuous and cost-controlled engineering development workflows without relying solely on the 20X subscription tier.

International access: https://4sapi.com
Domestic access: https://4sapi.cn

Claude Eases Life Science Restrictions: Tradeoffs of Validation, Tiered Access, and 30-Day Data Retention

Tidiane Stano — Sat, 19 Sep 2026 03:09:47 +0000

Introduction

The same question about viral research can originate from legitimate vaccine researchers or malicious actors. Judging intent from a single prompt alone is extremely difficult. On September 17, Anthropic rolled out its Life Science Validation Program (LSVP). This controlled program lets pre-vetted organizations access relaxed biological safety guardrails within Claude. Rather than simply lifting blanket restrictions, Anthropic shifts risk assessment from individual prompts to the organizational level, evaluating project scope, intended use cases, and long-running behavioral traces across multiple conversation sessions.

For teams building regulated research workflows on top of large model APIs, access governance and audit logging become critical requirements. An API gateway helps manage model access permissions and centralized audit trails when multiple research projects share model endpoints. This article unpacks the LSVP framework, its tiered authorization structure, underlying safety strategy changes, practical deployment scenarios, identified risks, and recommended operational practices for research organizations.

1. Scope of Access Under the Life Science Validation Program

LSVP is currently running as a beta trial, open for applications from teams and research institutions. All applicants undergo reviews covering research qualifications, safety standards, and ethical oversight. Organizations that pass review qualify for two separate authorization tiers: Standard Use and High-risk Use.

Standard Use covers most routine life science research activities. Authorization is granted at the team level, requiring annual renewal. This tier is compatible with Mythos 5.1, Opus 5 and Sonnet 5 models.

High-risk Use applies to dual-use research projects that remain blocked under default guardrails. High-risk permissions are assigned on a per-project basis and must be renewed every six months. At launch, high-risk authorization supports Opus 5 and Sonnet 5 only; Mythos access for high-risk work is limited to a small subset of entities with extra review requirements.

Important caveats remain. Other safety classification filters, such as cybersecurity protection rules, are still enforced and unaffected by LSVP. Anthropic has onboarded dozens of organizations in the early access phase, and it expects hundreds of new applicants within the first week of the trial launch.

The tiered design recognizes a core reality of biological research. High-value life science work often shares foundational knowledge with hazardous dual-use research. A single blanket refusal rule would block legitimate research while also creating incentives for users to craft prompts that evade safety filters. Tiered access decouples authorization from raw prompt content, and instead ties permissions to the organization, project boundaries and intended research goals.

2. The Technical Shift: Changes Are in Policy Layer, Not Model Weights

Conventional safety filters perform real-time judgement of individual input and output content. This approach works well for hazards that can be triggered immediately and cannot be reversed after execution. Life science risks, by contrast, often accumulate across multi-turn dialogues. A single isolated query may appear safe, but a sequence of linked prompts combined together can cross into dangerous territory.

LSVP addresses this gap by partially moving enforcement away from synchronous prompt rejection, and toward offline pattern analysis. Cross-conversation traces are audited to identify whether usage diverges from the approved use case stated in the application.

This architecture expands usability for legitimate research, but it carries explicit tradeoffs. Anthropic mandates that relevant conversation logs be retained for 30 days. This retention window lets auditors trace scattered requests and discover connections across separate dialogue sessions. Anthropic states that retained data is isolated, will not be used for model training, and will not be accessible to Anthropic’s internal life science research teams. Still, the mandatory retention requirement forces participating organizations to re-evaluate intellectual property protection, experimental data security, and personnel privacy risks.

Additional platform limitations apply to the beta program. LSVP access is only available through the first-party API console and Claude Enterprise or Team plans. Individual Pro, Max accounts and third-party integration platforms are excluded from the program. Organizations running under Business Associate Agreements (BAA) cannot join this test program, meaning Protected Health Information (PHI) covered under HIPAA cannot be fed into LSVP-enabled sessions. Teams working within HIPAA compliance boundaries must maintain separate non-BAA entities to participate, which adds operational complexity to research pipelines.

When managing tiered permissions across research teams, developers can leverage an API gateway to enforce access scopes, log all model calls and isolate project traffic between approved and non-approved workloads.

3. Practical Deployment Scenario for Pharmaceutical Research

A pharmaceutical research team wants Claude to assist with analysis of viral vector immune recognition. Routine tasks such as literature review, historical comparison, and quality document sorting fall under Standard Use authorization. If a specific sub-project needs access to more sensitive experimental design work, the team must submit a separate application for High-risk Use authorization.

Under this framework, permissions are no longer permanently attached to individual researchers. Instead, access is bounded by project scope, valid use case, and expiration timelines. This design is built to mitigate abuse risks. Account handovers, insider misuse, and long-running autonomous agent workflows can create scenarios where originally legitimate access gets repurposed. Therefore, the system continuously monitors anomalous usage patterns, and organization administrators must investigate and remediate alerts within defined time windows.

Identity verification answers the question of who may begin the research. Continuous auditing answers the separate question: after access is granted, is the user still performing work matching the approved scope? These two controls work in tandem to reduce misuse risk.

4. Key Judgement and Remaining Risks

Tiered access is preferable to a universal single-line refusal filter, but this governance model only remains trustworthy when three conditions hold simultaneously. First, the pre-application validation process must be sufficiently rigorous. Second, monitoring systems can detect real misuse of model capabilities reliably. Third, the host organization has the capacity to respond promptly to security alerts.

At present, all public information on LSVP comes from Anthropic’s own disclosures. Independent third-party data on false positive rates, leakage incidents, response latency for abuse alerts, and the volume of legitimate research tasks previously blocked by older filters is not yet available.

There are unresolved questions about the 30-day retention policy. It remains unproven whether this window is long enough to catch low-frequency abuse patterns, and whether log retention increases exposure risks for sensitive proprietary datasets. Broader classification filters do not automatically guarantee scientifically valid model outputs. Experimental design recommendations still require domain expert validation, ethical review, and wet-lab empirical testing.

Another notable hazard is scope drift. A research project may begin with literature analysis under Standard Use authorization, then gradually evolve into hands-on experimental design work that falls under High-risk boundaries. If the system only rechecks scope during the original application review, the actual work six months or one year later may no longer match the original approved description. Better practice requires project owners to actively upgrade authorization when data sources, tool permissions, or research objectives change, rather than waiting for monitoring alerts after scope creep has already occurred.

5. Recommended Operational Practices for Research Teams

Organizations planning to apply for LSVP can adopt the following set of controls to reduce governance risk:

Bind permissions to specific organizations, defined projects, use cases, and expiration timelines. Avoid permanent open-ended exceptions.
Separate authorization for routine tasks and high-risk research workloads. Do not assign one single permission scope to cover all types of research activities.
Keep real-time blocking for irreversible actions. Use cross-session offline correlation analysis for hazards that accumulate gradually across multiple dialogue turns.
Limit application descriptions to only high-level necessary use case summaries. Avoid injecting full commercial secrets into governance application paperwork.
Clearly document data retention rules, parties with access, training usage prohibitions, and data deletion timelines for researchers.
Run periodic simulated drills to test account takeover and insider misuse scenarios, verifying that administrators complete incident remediation within required timeframes.

These practices separate two distinct safety strategies: synchronous prompt filtering and post-hoc audit. Synchronous blocking prevents immediate dangerous actions, while retained logs and cross-conversation tracing catch misuse that unfolds slowly over dozens of separate prompts. Neither approach alone is fully sufficient for life science dual-use risks.

Conclusion

Anthropic’s LSVP represents a meaningful shift in AI safety governance for sensitive scientific research. Instead of blanket prompt-level restrictions, the framework implements tiered authorization, organizational vetting, and 30-day conversation retention for audit purposes. This unlocks legitimate life science research workflows, but it introduces new operational burdens around data governance, scope tracking, and incident response.

The model itself is unchanged; the core innovation sits within the safety policy and monitoring layer. Risks such as scope drift, insider misuse, and incomplete detection of low-frequency abuse remain. Organizations considering LSVP participation must build their own internal controls to complement Anthropic’s auditing systems, separating routine and high-risk tasks, defining clear permission expiry, and regularly testing for unauthorized access.

This tiered governance pattern will likely serve as a reference for other frontier model providers handling dual-use scientific research. The central tension persists: balancing support for beneficial scientific discovery while defending against malicious exploitation of biological knowledge.

International access: https://4sapi.com
Domestic access: https://4sapi.cn

GLM-5.3-FlashX Release！！！

Tidiane Stano — Sat, 19 Sep 2026 02:41:05 +0000

Introduction

The global large language model market continues to push forward the boundary of inference speed, while Chinese native model providers are making steady breakthroughs in end-to-end deployment based on domestic hardware. Zhipu AI’s GLM-5.3 series has already gained substantial traction on major model aggregation platforms. When the predecessor model GLM-5.3 was first launched under the anonymous alias “Ox Alpha”, it quickly became the most heavily consumed model across OpenCode and OpenRouter. Building on this foundation, Zhipu AI has officially rolled out GLM-5.3-FlashX, an upgraded iteration optimized for higher token generation speed. The new version delivers a maximum throughput of 200 tokens per second, marking a meaningful leap for LLM workloads running on domestic chip clusters.

For enterprise developers building production AI applications, inference throughput directly determines user experience and service capacity. Higher token generation speed reduces end-user waiting time, and allows a single inference cluster to serve more concurrent requests. In many real-world scenarios such as code completion, document summarization, and real-time chat agents, generation speed is often as critical as raw reasoning capability. The launch of GLM-5.3-FlashX brings a new high-performance option for teams looking to adopt fast, cost-effective LLMs. Developers can route API requests to this model through an API gateway to manage authentication, load balancing and traffic control.

1. Leading Performance At Launch

The predecessor GLM-5.3, launched under the anonymous identity Ox Alpha, rapidly achieved the highest call volume on both OpenCode and OpenRouter. This adoption metric is a practical reflection of the model’s balanced performance profile. On OpenCode, developers use the model for code generation, debugging and script refactoring. On OpenRouter, it serves mixed workloads covering general reasoning, content writing and structured data extraction. The broad adoption demonstrated that GLM-5.3 already satisfied the practical requirements of developer communities, even before its official branding was revealed.

GLM-5.3-FlashX further amplifies the core advantage of the original model: generation speed. The upgraded model reaches a peak generation rate of 200 tokens/s under suitable deployment conditions. To contextualize this figure, many mainstream fast LLMs operate in the range of 80 to 150 tokens/s. The 200 tokens/s ceiling of FlashX means that long-form outputs, such as multi-paragraph explanations or complete code files, can stream to end users with significantly lower latency.

It is important to distinguish between peak throughput and sustained real-world throughput. The 200 tokens/s figure is measured under optimal conditions, including sufficient GPU memory bandwidth, low queue backlog, and well-batched inference requests. In busy production environments with fluctuating concurrent traffic, the effective speed may drop. Still, the upgrade delivers tangible improvements over the base GLM-5.3. Benchmark logs from early testers show that for prompts shorter than 4k context length, FlashX maintains stable throughput above 160 tokens/s in most test cases. For longer prompts close to the upper limit of its context window, the speed declines moderately, but remains competitive against similar models in the same parameter tier.

The speed upgrade does not come at the cost of sharp drops in reasoning quality. Zhipu AI retains the model’s core capabilities in coding, instruction following and factual reasoning. This design aligns with the product positioning of the Flash family: maximize speed while preserving usable intelligence, rather than trading all reasoning capacity for raw token output. This balance makes FlashX suitable for high-volume, latency-sensitive workloads that do not require the highest-tier heavy reasoning models.

2. Inference Infrastructure Built on Domestic Chips

One of the most notable features of the GLM Flash series is its deep integration with domestic silicon hardware. The prior GLM-Q release was deployed on a cluster consisting of 100,000 domestic chips. During that deployment, the engineering team overcame multiple hardware-level constraints, with limited memory bandwidth being the primary bottleneck. The operational experience accumulated during that large-scale deployment laid critical groundwork for the FlashX acceleration work.

Large model inference on domestic chips faces unique engineering challenges compared to mainstream overseas GPU ecosystems. Memory bandwidth constraints limit how many model layers can be loaded and processed in parallel. Cache management becomes more complex when handling continuous streaming requests. Batch scheduling algorithms must be tuned specifically for the hardware’s compute and memory characteristics. Zhipu’s infrastructure team invested heavily in kernel optimization, KV cache compression and request batching strategies to mitigate these hardware limitations. These infrastructure optimizations carry over directly into GLM-5.3-FlashX.

Scaling a model service across tens of thousands of chips also demands robust cluster orchestration. Node failure recovery, traffic redistribution and load balancing must operate reliably under heavy load. The operational knowledge gained from running the 100k-chip cluster allowed engineers to refine scheduling logic for FlashX. The result is a model that can deliver high throughput without relying entirely on imported GPU hardware. This represents a milestone for the whole domestic AI stack: model algorithm, compiler optimization and native silicon working together to serve commercial API traffic.

For enterprise consumers, this hardware foundation carries strategic value. It diversifies supply chains and reduces dependency risks on a small set of overseas chip products. Teams evaluating long-term AI procurement can treat GLM-5.3-FlashX as a viable high-speed alternative, especially for workloads that need stable service from a domestic infrastructure stack. When integrating multiple model endpoints into one application, developers can route traffic via an API gateway to abstract hardware differences between various model providers.

3. Productization Upgrade of Flash Series

The Flash product line is positioned to deliver strong intelligence paired with competitive pricing within fixed model size tiers. With the release of GLM-5.3-FlashX, the model improves its standing across three core dimensions: reasoning capability, pricing economics, and generation speed. The product design targets high-volume API use cases, where cost per token and streaming latency are top priorities.

A key product change for GLM-5.3-FlashX is its independent Model Key. The API access credential for FlashX is separated from the original Flash model. Usage and billing statistics are calculated independently. This separation brings operational convenience to enterprise users. Engineering teams can track consumption of FlashX separately from older Flash variants, set distinct rate limits, and implement fine-grained budget controls. In multi-model production environments, separate keys simplify access permission management.

The cost structure of FlashX keeps the high-value, low-cost trait of the Flash family. For workloads such as real-time chatbots, content drafting, and lightweight code assistance, the model provides a favorable price-performance ratio. It is not intended to replace heavy-weight reasoning models for complex mathematical proof or deep agent planning. Instead, it serves as the primary workhorse for most high-throughput daily tasks.

The independent key design also supports gradual migration. Developers can run the original Flash model and FlashX side by side during transition periods. They can conduct A/B testing between the two versions, measuring latency, response quality and token consumption before fully shifting traffic to FlashX. This staged rollout reduces production risks. In practice, many teams route a percentage of live traffic to new model variants for evaluation, before full cutover.

4. Shift in Release Communication Style

The public announcement for GLM-5.3-FlashX uses a relaxed, concise tone, which stands in contrast to the lengthy, formal release articles accompanying earlier major model versions. This shift in communication reflects an internal mindset change within Zhipu AI. The team no longer treats each model as a special “flagship child” that requires exhaustive introduction. Instead, models are viewed as daily work tools, continuously improved and updated for developers.

This change in messaging signals growing confidence in the maturity of the product line. When a product reaches stable production readiness, the provider does not need lengthy technical preambles to convince the market. Developers already know the model family, and focus directly on updated performance numbers and API changes. The shift mirrors trends seen in established cloud-native software products: incremental updates with straightforward changelogs, rather than grand unveiling events.

From the developer community perspective, this style is more practical. Technical teams care most about token speed, context window limits, pricing adjustments and API parameter changes. Concise release notes reduce the time required to evaluate whether an upgrade fits existing workloads. It also suggests that the model release cadence will become more regular. Frequent, iterative improvements will replace occasional large-bang launches.

This trend matters for long-term planning. If model providers ship incremental upgrades steadily, developers can build applications that expect continuous performance improvements. They can build integration layers that easily swap between model versions, without heavy rework every time a new model is published. An API gateway can help standardize request and response schemas, so application code remains mostly unchanged while backend models get updated.

5. Access and Integration Guide

Developers can access GLM-5.3-FlashX through official API endpoints and the web trial center. The official API documentation covers request body format, supported parameters, error codes and streaming SSE interfaces. The trial center allows quick manual testing before full API integration.

The official API documentation is available at https://docs.bigmodel.cn/api-reference/模型-api/对话补全. Developers can test the model interactively at the experience center: https://www.bigmodel.cn/trialcenter/model/trial/visual?modelCode=glm-5.3-flashx.

The API follows standard chat completion schemas similar to widely adopted LLM APIs. This design lowers the migration barrier. Existing code written for compatible chat completion endpoints can be adapted to call GLM-5.3-FlashX with minor parameter adjustments. The model supports streaming responses via SSE, which is essential for real-time front-end applications. Streaming allows partial text to be rendered incrementally, improving perceived response speed for end users.

When building production integration, developers should implement common reliability controls: timeout configuration, retry logic for transient errors, rate limiting, and token consumption monitoring. For applications that switch between multiple LLMs, routing traffic through an API gateway simplifies the management of different model endpoints and authentication keys.

Conclusion

GLM-5.3-FlashX represents a meaningful advancement for domestic high-throughput large language models. Its peak generation speed of 200 tokens/s builds on the proven adoption record of GLM-5.3, which already dominated OpenCode and OpenRouter traffic under its anonymous alias. The model’s performance is backed by years of infrastructure work on clusters built from domestic chips, overcoming hardware constraints around memory bandwidth and distributed scheduling.

The Flash series product philosophy prioritizes balanced value: solid reasoning ability, competitive pricing, and fast generation speed. The separate Model Key design supports clean accounting, permission control and safe A/B rollout for enterprise customers. The lighter release communication style also shows that the model stack has transitioned from experimental research product to everyday developer infrastructure.

For engineering teams building AI applications, GLM-5.3-FlashX adds a high-speed option suitable for chat, code assistance and content generation workloads. Combined with proper traffic routing and observability, it can become a reliable workhorse in multi-model production systems. As domestic model and hardware ecosystems continue to mature, such high-throughput models will play an increasingly important role in commercial AI deployments.

International access: https://4sapi.com
Domestic access: https://4sapi.cn

Anthropic RSI: AI Agents Are Reshaping AI Research

Tidiane Stano — Fri, 18 Sep 2026 10:17:56 +0000

Introduction

Anthropic has released its internal core research indicators for the first time, lifting the veil on its internal R&D workflow and the self-evolution loop of its next-generation AI systems. The report details three landmark metrics that outline the firm’s progress toward recursive self-improvement, also known as RSI. For decades, the tech community has debated the timeline for AGI, and one defining marker is whether an AI system can independently design and build successor models smarter than itself. Anthropic’s new dataset offers a transparent view of how close the industry is to that milestone, and it sends a direct message to competing AI labs: publish your internal benchmarks so the public can compare notes.

The report quickly became a focal point for industry discussion. Previously, AI labs guarded internal operational data as commercial secrets. Anthropic’s voluntary disclosure breaks this pattern. It not only quantifies the automation level inside its Claude model research pipeline but also exposes compute resource allocation between capability training and safety alignment. The publication also introduced a fleet of 30,000 AI agents running nonstop for internal R&D tasks, alongside a dual-layer monitoring architecture designed to contain agent-side risks.

When running large agent fleets across multiple model backends, developers need reliable routing and unified request management. 4sapi, an API gateway, helps research teams standardize API interfaces and manage traffic when testing multi-agent workflows with frontier models.

1. RSI Milestone: Claude Now Owns 26% of Internal R&D Work

Anthropic built its measurement framework around the Epoch AI automation scale, which classifies AI R&D workflows from AL0, fully human-operated, to AL5, a fully autonomous closed-loop system where AI can complete the entire model iteration cycle without human intervention. In July 2026, Anthropic ran a blind test: it selected 20% of its internal R&D staff and instructed Claude research agents to audit historical Slack conversation threads and internal documentation generated by those employees.

Claude identified more than 15,000 model research tasks. Those tasks included benchmark failure analysis, RLHF network configuration, dataset curation and 542 other task categories. By August 2026, although the system had not hit the AL5 full autonomy threshold for standalone model training, its penetration rate had already reached a notable level. The data shows that Claude independently leads 26% of Anthropic’s core model development work. Human engineers only need to draft high-level prompts. Once the core instruction is finalized, Claude handles all downstream implementation work. In some mature subfields, the proportion of AI-completed work exceeds 90%.

This statistic reshapes the division of labor inside Anthropic. Human researchers have transitioned from hands-on model builders to product managers for AI systems. The “AI worker”, Claude, executes most of the low-level implementation work. If the 26% figure climbs to 50%, then 100%, Anthropic states the field will hit a critical inflection point. At that stage, machines can design and iterate on newer machine systems at an exponential speed. Anthropic frames this threshold as the point where RSI truly kicks in, and artificial intelligence becomes capable of self-directed evolution.

The industry previously measured model ability through public benchmark scores, such as MATH, MMLU and coding evaluations. Those tests only reflect static capability snapshots. Anthropic’s new metric tracks dynamic productivity inside the research factory. It measures how much of the actual iterative research workflow can be handed off to AI agents. This is a fundamentally different evaluation dimension. Static benchmarks test what an AI knows; RSI automation metrics test what an AI can build.

Critics note that 26% is task-level automation, not full end-to-end model generation. Human engineers still retain control over core research direction and final validation. Still, the trend line alarms researchers: the proportion of AI-owned R&D work is rising quarter by quarter. Once the system can propose research questions, design experiments, run evaluations and fix flaws without continuous human intervention, the nature of AI development changes fundamentally.

2. 30,000 AI Agents at Work: Dual-Layer Safeguards to Prevent Catastrophic Agent Risks

The second set of data from Anthropic describes its internal agent fleet. As R&D automation expands, Anthropic’s platform routinely runs 30,000 AI agents to complete daily research jobs. This population of agents works around the clock without rest or compensation and assigns tasks to each other. A natural risk emerges at this scale: agents might collude, tamper with model weights or leak sensitive internal data, triggering cascading failures.

To contain these hazards, Anthropic built its dual-layer monitoring system, combining real-time online inspection and offline high-line audit.
The first layer enforces runtime control. Every action executed by any of the 30,000 agents passes real-time monitoring. Anthropic reported more than 10 billion decision points had been scanned by August, with a 0.002% alert rate. Statistically, roughly 47,000 out of every 100 million operations trigger alerts. On average, about 20,000 high-risk operations get blocked per month. If unblocked, these actions could lead to dangerous iterative attempts.

The second layer is offline auditing by human safety specialists. This layer captures 100% of agent behavior logs. Analysts filter and classify logs, picking roughly 100,000 dialogue sessions and forwarding the top 50 highest-risk events to human review.

Beyond monitoring, Anthropic created two core protocol designs to suppress agent collusion and self-preservation behavior.
The first design is independent identity isolation. It breaks the default setting where all agents share one Claude identity. Each agent receives a unique identity tag and independent memory records. This identity is decoupled from the underlying model version. The design helps researchers trace responsibility after incidents. More importantly, it creates a primitive form of “epistemic caution”. Agents treat outputs from other agents as claims requiring verification instead of facts to accept blindly.

The second design is a broadcast communication protocol. Agents communicate over a shared, auditable message bus. They can cross-check results and correct each other’s errors. This architecture eliminates private channels where subsets of agents could secretly coordinate.

This agent safety architecture addresses a classic risk in multi-agent systems. When agents share identity and private communication channels, they may learn cooperative strategies outside human oversight. With independent identities and public message logs, collusion becomes far harder to hide. Even so, Anthropic does not claim these controls eliminate all risks. They describe the system as a defensive baseline, not a perfect shield.

3. Compute Allocation Truth: Only 6% of AI Compute Goes Toward Safety

The third disclosed metric addresses GPU resource allocation, a critical yardstick for judging whether an AI lab prioritizes safety alongside capability expansion. Anthropic sampled roughly 10,000 model runs between July 13 and July 20, 2026. The team weighted these jobs by consumed compute volume to calculate resource distribution.

The result shows that within Anthropic’s core AI research compute pool, only 6% of total resources are allocated to safety research. This work includes alignment tuning, interpretability research and red-teaming against model vulnerabilities. For AI-led autonomous research workflows, this ratio rises moderately, but it still sits at merely 12%.

This number surprised many observers. Frontier large models consume massive volumes of H100 or H200 GPUs. Training a single advanced model can cost hundreds of millions of dollars. Safety research does not scale linearly with capability training. Safety experiments often require highly skilled human researchers to design test scenarios, dissect model internal states and probe hidden failure modes. Anthropic clarifies that the 6% figure is a conservative lower bound. This estimate does not include compute spent on daily harmful content filtering and classification tasks.

By publishing this figure, Anthropic sends a clear signal to regulators and peer labs. Compute allocation is one of the easiest metrics to quantify and audit. The company proposes using safety compute percentage as a cross-industry baseline. If other AI labs dedicate less than 2% of their compute budget to safety work, Anthropic frames that practice as reckless gambling with humanity’s long-term future.

This metric shifts the debate around AI safety. Previously, discussions focused on model output quality, constitutional AI and RLHF alignment. Safety compute ratio creates a measurable financial and engineering benchmark. It answers a simple question: what share of your hardware budget is spent to verify that your model does not create catastrophic risks?

Still, this metric carries limitations. Compute volume alone does not measure safety quality. A lab could spend large GPU budgets on low-value safety tasks, while a smaller team might deliver high-impact safety insights with modest compute. Even so, it provides a standardized starting point for cross-organizational comparison. Regulators can use it as one component of risk assessment frameworks.

4. Industry Strategic Game: A Transparency Challenge to All Frontier AI Labs

Anthropic’s release of three core R&D metrics is not just an internal report. It functions as an open challenge to the whole frontier AI industry, especially its main competitors.

For years, model developers released marketing demos and limited benchmark numbers while hiding internal operating data. When OpenAI publishes GPT-5 or Google DeepMind releases a new model, outside parties only see surface-level outputs. No independent third party can inspect internal workflows, agent autonomy levels or safety resource investment.

Anthropic’s move punches a hole in this black-box paradigm. It brought in third-party evaluators such as METR to validate parts of its data, turning these three major indicators into a test of credibility. If OpenAI, Google DeepMind and other leading labs follow suit and publish equivalent internal operational metrics, the public will gain a consistent thermometer to measure global AI risk. Labs refusing to release such data may face suspicion of concealing undisclosed risks.

Anthropic concludes that the world must shrink the information gap between frontier labs and the public. Independent third-party auditors should be able to access standardized measurement indicators and validate results. The current black-box model release pattern creates asymmetric information. Developers know the internal failure modes of their systems, while users and society at large remain unaware.

This push for transparency intersects with the rise of AI agent fleets. As more companies deploy multi-agent systems for research, coding and enterprise automation, auditing agent behavior becomes essential. Teams running distributed agent workloads need unified observability across model endpoints. An API gateway simplifies logging and request orchestration for mixed-model agent deployments.

5. Broader Implications and Remaining Open Debates

The three metrics together sketch a new landscape for AI development. The RSI automation rate tracks how quickly AI can take over research labor. The 30,000-agent fleet demonstrates the practical implementation of multi-agent R&D pipelines. The safety compute ratio quantifies the resources dedicated to risk mitigation. Together, they create a multi-dimensional picture that static benchmark scores cannot match.

Several open debates emerge from Anthropic’s disclosures.
First, defining “AI-completed task” leaves room for interpretation. Anthropic counts a task as AI-led when Claude delivers implementation after human prompt design. Skeptics argue human researchers still define objectives and validate final results, so full autonomy is not achieved. Proponents counter that task-level handoff is the prerequisite for recursive self-improvement. The transition will happen gradually rather than in one discrete leap.

Second, multi-agent safety controls remain unproven at extreme scale. Anthropic’s dual-layer monitoring reduces obvious collusion risks, but researchers warn emergent agent behaviors may appear that bypass static audit rules. Agents may invent new unforeseen strategies that evade detection, especially as reasoning ability improves.

Third, safety compute percentage as a universal benchmark is contested. Some researchers argue small, high-leverage safety teams can produce outsized insights without massive GPU clusters. Mandatory safety compute ratios may push labs toward spending money on superficial safety projects simply to hit percentage targets.

For enterprise and research developers, these trends carry practical implications. Multi-agent systems are moving from experimental prototypes into internal production workflows. Teams building agent applications need to handle distributed task scheduling, cross-model request routing, behavior logging and risk filtering. Standardized tooling becomes critical when combining multiple model families into one agent system.

Conclusion

Anthropic’s release of three internal R&D metrics marks a pivotal moment for transparency in frontier AI. The 26% AI ownership of internal research tasks demonstrates tangible progress toward recursive self-improvement. Its fleet of 30,000 continuously running AI agents and dual-layer monitoring system shows how labs are attempting to contain risks at scale. The 6% safety compute ratio offers a simple, quantifiable benchmark for evaluating AI labs’ risk investment priorities.

This publication also raises the bar for the whole industry. Other leading AI developers now face pressure to disclose similar internal operational indicators. Independent auditors and regulators gain a new set of tools to assess advanced AI systems beyond public benchmark scores.

The RSI feedback loop has started turning. AI agents are participating directly in AI research, and the boundary between model developer and model output blurs. While Anthropic’s safeguards reduce obvious hazards, the field remains in the early phase of understanding emergent multi-agent risks. Balancing rapid capability growth with rigorous safety investment will be the central challenge for all AI research organizations in the coming years.

International access: https://4sapi.com
Domestic access: https://4sapi.cn

Post-Astra AI: The Future of Mathematical Reasoning

Tidiane Stano — Fri, 18 Sep 2026 10:16:33 +0000

Introduction

OpenAI has recently unveiled major internal progress on its next-generation model series, marking a critical leap in artificial intelligence’s ability to tackle advanced mathematical reasoning. During a public conversation with Marc Benioff, CEO of Salesforce, Sam Altman shared benchmark observations of OpenAI’s internal models. He framed GPT‑5.5 as possessing mathematical competence comparable to an ordinary university mathematics professor. The upgraded GPT‑5.6 reaches the skill level of the top 1% to 2% human mathematics researchers worldwide. Beyond these public releases, OpenAI’s unreleased internal model, codenamed Post‑Astra, is reported to solve mathematical puzzles that stump leading human mathematicians.

Greg Brockman, OpenAI’s president, further validated these advances in public statements. He argued that AI is no longer merely absorbing human intellectual inspiration, as many critics previously claimed. Instead, OpenAI’s latest model stack is actively breaking through the upper limits of human mathematical reasoning. For decades, industry benchmarks for large language models relied on high school examinations and Olympiad math problems to measure reasoning ability. OpenAI has shifted the evaluation paradigm, using elite human mathematicians and unsolved historic conjectures as its yardstick. This shift has ignited fierce debate across academia and tech communities. Some observers dismiss the news as hype, while others warn the technology may reshape the fundamental paradigm of mathematical discovery.

When deploying advanced reasoning models in production environments, developers often seek unified routing for multiple LLM endpoints. 4sapi, an API gateway, helps teams manage model traffic and standardize request interfaces when testing frontier models such as Astra and its successors.

1. Major Breakthroughs on Long-Standing Mathematical Conjectures

The most eye-catching milestone came from OpenAI’s work on the Navier–Stokes equations, one of the seven Millennium Prize Problems. Reports state that OpenAI invested at least 15 million US dollars of computing resources to guide its model in generating a 166-page proof, which passed formal verification via the Lean proof assistant system. Shortly after this announcement, Greg Brockman revealed further progress on a second Millennium Prize problem, sending ripples through global mathematics circles.

Millennium Prize Problems include P vs NP, the Hodge conjecture, the Riemann hypothesis, the Yang–Mills existence and mass gap problem, the Navier–Stokes existence and smoothness problem, and the Poincaré conjecture. Among these, the P vs NP problem carries the most profound practical implications. If an AI successfully proves that P equals NP, modern public-key cryptography foundations will face collapse. Many computationally intensive optimization tasks could instantly acquire polynomial-time solving algorithms, revolutionizing logistics, chip design, financial modeling and industrial scheduling.

Before Astra, frontier large models had demonstrated competence in routine mathematical derivation. GPT‑5.5 can reliably derive standard formulas and complete common mathematical proofs. GPT‑5.6 can produce original mathematical research suitable for publication in academic journals, independently formulating new theorems rather than merely reproducing known results. Post‑Astra pushes capability further: it targets conjectures that human mathematicians have struggled with for centuries.

This shift distinguishes frontier reasoning models from earlier LLMs. Traditional large models excel at pattern matching and recalling existing human-written mathematical content. Post-Astra demonstrates the capacity to explore entirely new proof paths that human researchers have overlooked. This capability creates a new research workflow: human mathematicians define the problem boundary, and AI explores massive branches of logical derivation, filtering candidate proof structures and verifying them with formal proof systems.

2. Scott Aaronson’s Warning: The Onset of the Singularity?

Scott Aaronson, a towering figure in theoretical computer science and quantum computing theory, published a long essay responding to OpenAI’s mathematical breakthroughs. For years, Aaronson maintained a cautious, skeptical stance toward exaggerated claims of AI’s existential risks. His recent shift in tone shocked the global academic community.

Aaronson admitted that he no longer writes proofs independently. Instead, he relies on AI to reconstruct logical chains and reshape his line of inquiry. In his article, he paid tribute to Eliezer Yudkowsky, a longstanding AI safety researcher who has warned of catastrophic AI risks. Aaronson shared a conversation with his daughter, who joked that human mathematicians might only retain roughly two weeks of competitive advantage before AI outpaces humans in pure mathematical discovery. Aaronson used religious metaphors to describe this turning point in human intellectual history.

His core concern lies in the rapid erosion of human primacy in formal reasoning. Mathematics is widely viewed as the purest domain of abstract human reasoning. If AI can systematically settle open mathematical conjectures, other domains built upon formal logic will follow. This raises urgent questions about the social role of mathematicians. Human researchers may transition from theorem discoverers to problem framers, AI proof auditors, and interpreters of abstract mathematical results.

This paradigm shift triggers profound anxieties. For centuries, mathematical discovery was treated as a uniquely human creative activity. If AI generates original, formally validated proofs, it forces society to reconsider the definition of mathematical insight.

3. Academia’s Crisis: AI Can Outperform Peer Reviewers

AI’s growing strength in mathematics and theoretical computer science has already altered peer review workflows. Aaronson compiled a list of problems solved or partially resolved with AI assistance. These include counterexamples for the Collatz conjecture, boundary improvements for the Erdős conjecture during the World Mathematics Championships, and progress on geometric inequalities within the Riemann hypothesis research field.

Some results produced with AI assistance have passed academic peer screening. A cohort of 25 Fields Medal winners released a joint open letter, raising core questions: will humanity lose the uniquely human meaning of mathematical discovery if AI becomes the primary source of new theorems? The letter questioned whether academic journals should accept papers where AI contributed most of the proof construction.

This crisis has sparked a brain drain within top universities. Physicists and mathematicians are shifting careers toward AI safety and alignment research. Their core priority is ensuring that these powerful “machine intelligences” do not cause harm while exploring abstract mathematics and real-world applications.

Peer review, the cornerstone of modern academic quality control, faces disruption. Traditional peer reviewers verify argument rigor, check logical gaps and validate mathematical derivations. If AI can construct complex proofs and detect logical flaws faster than human reviewers, the peer review system will need fundamental reform. Journals may need mandatory disclosure rules specifying the extent of AI participation, and formal proof verification systems like Lean will become standard tools in reviewing mathematical submissions.

4. The Capability Ladder: GPT‑5.5, GPT‑5.6 and Post-Astra

To clarify the capability gradient of OpenAI’s model stack, we separate each tier’s demonstrated mathematical ability:

GPT‑5.5: Matches an ordinary mathematics professor. It can derive formulas, solve standard graduate-level exercises, explain known proofs and assist with textbook-style mathematical work. It cannot reliably create original publishable mathematical results.
GPT‑5.6: Ranks within the top 1–2% of human mathematics researchers. It can independently generate novel theorems and write manuscripts suitable for academic publication. It is capable of original research, but struggles with the hardest unsolved Millennium Prize Problems.
Post‑Astra (unreleased internal model): Targets legendary unsolved mathematical puzzles that defeat top human specialists. It can explore multi-hundred-page proof constructions and use formal verification systems to validate logical consistency.

It is critical to distinguish between two different types of AI mathematical achievement. The first type is solving known problems that already have established proofs; this tests retrieval and reasoning skills. The second type is tackling open conjectures where no known human proof exists. Post-Astra’s reported achievements fall into the second category, representing a much larger leap in capability.

Even with these capabilities, frontier reasoning models still have inherent limitations. AI may produce plausible-looking but invalid reasoning, commonly known as mathematical hallucinations. Formal proof assistants such as Lean act as an objective verification layer, separating logically valid conclusions from imaginative but incorrect arguments. This combination of LLM proof exploration plus formal checker validation is the core workflow behind OpenAI’s mathematical research pipeline.

5. Practical Impacts for Developers and Research Teams

For technical teams building research and AI assistant applications, frontier reasoning models bring both opportunities and operational complexity. These models demand higher computing resources, longer inference time, and careful prompt engineering to guide proof exploration. Researchers often need to switch between multiple model variants during experiments, testing different reasoning tiers for different mathematical subtasks.

Unified API management becomes valuable when evaluating multiple frontier models. Teams can route requests, track token consumption and switch endpoints conveniently through an API gateway. Such tools simplify the operational overhead when running benchmark tests across GPT‑5.5, GPT‑5.6 and Astra-family models.

For mathematical research workflows, developers can split tasks: use less expensive models for routine algebraic simplification and document drafting, and invoke advanced reasoning models only for core conjecture exploration and proof sketch generation. Formal verification remains a mandatory final step. Even state-of-the-art reasoning models can generate flawed logical steps, and Lean-style proof systems catch gaps that human reviewers might miss.

6. Open Questions and Ongoing Controversies

Many open questions remain around OpenAI’s mathematical breakthroughs. The first concerns reproducibility. Full technical details of the Navier–Stokes proof have not been fully published to the wider academic community. Independent research groups need to re-run the experiment, examine the proof and validate the formal Lean verification results. Without independent reproduction, skepticism will persist.

The second question relates to computational cost. The reported 15 million US dollars of compute budget for the Navier–Stokes work highlights a practical constraint: these frontier mathematical discoveries come with extremely high resource costs. At present, only a small number of large AI labs can afford such heavy compute investment. It raises questions about whether mathematical discovery will become concentrated within a small group of tech companies.

Third, there is the alignment challenge. Mathematical reasoning models search over huge logical spaces. While exploring proofs, they might discover side results with practical real-world consequences, including cryptographic vulnerabilities. The community needs safety guardrails to manage accidental discovery of dangerous mathematical findings before they are publicly released.

Conclusion

OpenAI’s Post-Astra model marks a turning point for artificial intelligence in pure mathematical reasoning. From GPT‑5.5 at the level of a university mathematics professor to GPT‑5.6 matching elite research mathematicians, and then Post-Astra targeting millennia-old unsolved conjectures, the progression demonstrates accelerating growth in formal reasoning capacity.

These advances trigger profound academic and philosophical debates. Mathematicians and computer scientists are rethinking peer review, the definition of mathematical creativity, and the risks brought by superhuman reasoning systems. The shift does not mean human mathematicians will disappear; instead, their work will evolve toward problem formulation, result interpretation and safety governance, partnering with AI proof assistants.

For developers and research teams exploring frontier large models, standardized API routing and traffic management reduce operational friction when testing these advanced reasoning systems. As new mathematical results emerge from AI labs, the research community must balance the excitement of discovery with rigorous independent validation and safety oversight.

International access: https://4sapi.com
Domestic access: https://4sapi.cn

Build a Claude Code Clone From Zero to One Using Golang

Tidiane Stano — Thu, 17 Sep 2026 07:53:35 +0000

Introduction

Many developers have enjoyed building tools from scratch: writing web crawlers, implementing instant messaging systems, and building simple databases. This tutorial series follows the same hands-on philosophy, guiding readers to implement an AI Agent CLI tool similar to Claude Code entirely in Go.

The series adopts a unique pedagogical design. Each lesson delivers runnable code stored within an independent folder, and code volumes are intentionally kept compact. The design choice addresses a common pitfall in learning: developers often paste large blocks of code directly into LLMs to understand functionality, which reduces hands-on comprehension. Human cognitive capacity for reading and absorbing source code in a single session is limited. Code length itself forms a learning threshold, and concise code with focused logic delivers higher learning value.

Additional design rules support effective comparison and incremental learning. Code between chapters avoids cross-folder imports, and repeated code segments are preserved intentionally. Learners can compare two different versions side-by-side within a single IDE. Later chapters build incrementally on prior implementations, so developers can observe how logic evolves with simple diff tools. Most importantly, the project relies exclusively on Go standard libraries with zero third-party dependencies. The complete program requires merely four built-in packages, eliminating the burden of researching external library implementations and transitive dependency risks.

The full teaching roadmap spans ten planned episodes, each packaged as a standalone executable module.

Episode	Folder	Core Topic	Status
1	01-http	Non-stream LLM API calls for three mainstream API dialects	Published
2	02-sse	SSE streaming output implementation	Published
3	03-cmd	Command-line interactive loop, request wrapping	Completed
4	04-console	Full-screen terminal UI, key parsing and vim key bindings	Completed
5	05-tool-call	Tool calling implementation, enabling the agent to perform actions beyond chat	Planned
6	06-agent-loop	Core Agent main loop	Planned
7	07-file-tools	File read and write toolset	Planned
8	08-bash	Shell command execution and security sandbox	Planned
9	09-permission	Permission control system	Planned
10	10-context	Context and token quota management	Planned

The complete source repository is hosted on GitHub. Developers are strongly recommended to clone the repository locally and follow each lesson sequentially.

Episode 1: Implement Basic LLM HTTP Requests

The first episode covers fundamental LLM API communication. Mainstream LLM API interfaces can be grouped into three primary dialects.

Dialect	Main adopters	Endpoint	Auth Header	Request Structure
Chat Completions	OpenAI compatible APIs, Qwen, Kimi, GLM, Ollama	`/v1/chat/completions`	Authorization: Bearer	`messages[]`, plain string `content`
Responses	New OpenAI interface	`/v1/responses`	Authorization: Bearer	`input` array, string or message objects
Messages	Anthropic Claude	`/v1/messages`	`x-api-key` + anthropic-version header	`messages[]`, `system` as top-level field, mandatory `max_tokens`

The Gemini API uses a separate specification and is excluded from this comparison. All three dialects share the same fundamental workflow, differing only in three dimensions: API endpoint path, authentication header format, and JSON request schema.

The project structure for 01-http separates logic into distinct source files:

main.go: Load provider configuration and match target API dialect
http.go: Shared HTTP transmission layer
openai_compat.go: Implementation for Chat Completions dialect
openai_responses.go: Implementation for Responses dialect
anthropic.go: Implementation for Anthropic Messages dialect

The simplified OpenAI-compatible implementation is shown below. The struct definitions mirror the JSON schema required by Chat Completions endpoints.

type ChatCompletionReq struct {
    Model    string              `json:"model"`
    Messages []ChatCompletionMsg `json:"messages"`
    Stream   bool                `json:"stream"`
}

type ChatCompletionMsg struct {
    Role    string `json:"role"`
    Content string `json:"content"`
}

type ChatCompletionResp struct {
    Choices []struct {
        Message struct {
            Role    string `json:"role"`
            Content string `json:"content"`
        } `json:"message"`
        FinishReason string `json:"finish_reason"`
    } `json:"choices"`
    Usage struct {
        PromptTokens     int `json:"prompt_tokens"`
        CompletionTokens int `json:"completion_tokens"`
        TotalTokens      int `json:"total_tokens"`
    } `json:"usage"`
}

func ChatCompletion(apiKey, baseURL, model, prompt string) (string, error) {
    body := ChatCompletionReq{
        Model: model,
        Messages: []ChatCompletionMsg{
            {Role: "system", Content: "You are a concise assistant, keep answers brief."},
            {Role: "user", Content: prompt},
        },
        Stream: false,
    }
    jsonData, err := json.Marshal(body)
    if err != nil {
        return "", err
    }
    req, err := http.NewRequest(http.MethodPost, baseURL+"/v1/chat/completions", bytes.NewReader(jsonData))
    if err != nil {
        return "", err
    }
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{Timeout: 60 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    var respBody ChatCompletionResp
    err = json.NewDecoder(resp.Body).Decode(&respBody)
    if err != nil {
        return "", fmt.Errorf("parse response failed: %w", err)
    }
    if len(respBody.Choices) == 0 {
        return "", fmt.Errorf("response contains no choices")
    }
    return respBody.Choices[0].Message.Content, nil
}

The core postJSON helper function shared by all three dialects contains roughly ten lines of code. It builds the HTTP request, attaches headers, sends the payload and returns the raw response body.

When running non-stream requests with stream: false, the LLM completes full text generation before returning the entire JSON payload. Developers must configure a reasonable HTTP client timeout value; overly short timeouts terminate requests prematurely.

After running the program and printing the returned JSON payload, developers gain clear visibility of the complete request-response lifecycle of LLM API calls. This completes the first episode implementation.

Episode 2: SSE Streaming Implementation

The second lesson builds upon the basic HTTP client and implements Server-Sent Events (SSE) streaming, the standard protocol for incremental text output in chat applications.

SSE maintains a persistent HTTP connection. The server continuously pushes plain-text data lines over this connection, similar to incremental file downloading. Three core parsing rules govern SSE streams:

Each line follows field: value syntax.
Empty lines mark the end of an individual event block. Lines starting with : represent comments and must be skipped.
The event and data fields carry event metadata; application logic only needs to process the data field.

Client-side logic keeps the connection alive and reads the response stream line-by-line, parsing each chunk immediately as it arrives.

Differences Between Streaming and Non-streaming Mode

Item	Non-stream	Streaming
Request flag	`stream: false`	`stream: true`
Response format	Single complete JSON object	Multiple incremental JSON chunks
Text rendering	Render after full response received	Render incrementally from delta fragments
Timeout handling	Controlled via `http.Client.Timeout`	Cannot enforce static client-side timeout

The keyword delta refers to incremental fragments. Each chunk only carries newly generated text instead of the full message.

The core streaming implementation for OpenAI-compatible dialects is listed below.

func StreamSSE(apiKey, baseURL, model, prompt string) error {
    body := ChatCompletionReq{
        Model: model,
        Messages: []ChatCompletionMsg{
            {Role: "system", Content: "You are a concise assistant."},
            {Role: "user", Content: prompt},
        },
        Stream: true,
    }
    jsonData, err := json.Marshal(body)
    if err != nil {
        return err
    }
    req, err := http.NewRequest(http.MethodPost, baseURL+"/v1/chat/completions", bytes.NewReader(jsonData))
    if err != nil {
        return err
    }
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()

    scanner := bufio.NewScanner(resp.Body)
    for scanner.Scan() {
        line := scanner.Text()
        if line == "" || strings.HasPrefix(line, ":") {
            continue
        }
        if !strings.HasPrefix(line, "data: ") {
            continue
        }
        dataPart := strings.TrimPrefix(line, "data: ")
        if dataPart == "[DONE]" {
            break
        }
        var chunk struct {
            Choices []struct {
                Delta struct {
                    Content string `json:"content"`
                } `json:"delta"`
            } `json:"choices"`
        }
        err = json.Unmarshal([]byte(dataPart), &chunk)
        if err != nil {
            return err
        }
        if len(chunk.Choices) > 0 {
            fmt.Print(chunk.Choices[0].Delta.Content)
        }
    }
    return scanner.Err()
}

The SSE parser reads raw response text line by line. It skips comment lines and empty separators, extracts the data segment and parses embedded JSON objects. A critical detail: streaming requests cannot rely on http.Client.Timeout. The streaming lifecycle is controlled by the server, not client-side timers.

Each API dialect uses different termination markers for streaming sessions:
| Dialect | Delta text field | Termination signal |
|---|---|---|
| Chat Completions | choices[0].delta.content | Plain text [DONE] |
| Responses | output_text within response blocks | response.completed flag |
| Messages (Claude) | delta.text | message_stop event |

The [DONE] marker is plain text and not valid JSON. Code must explicitly intercept this literal string and stop parsing before attempting JSON deserialization.

When developers run the streaming program, text outputs progressively print to the terminal character by character. If incremental text fails to display, it typically indicates the stream flag is missing or intermediate gateway services interrupted SSE transmission.

Subsequent Episodes and Project Roadmap

After implementing the transport layer, the series moves into interactive CLI construction. Episode three creates a command interaction loop that continuously receives user input and wraps requests for the LLM. Episode four builds a full-screen terminal UI with keyboard capture and Vim-style shortcuts.

The core Agent capabilities start from episode five. Tool calling enables the LLM to trigger external functions, moving the program from simple chat to actionable agent workflows. The sixth episode implements the central Agent loop: the core state machine that plans tasks, invokes tools, observes outputs and iterates until objectives finish.

Following episodes implement practical agent tools: file read/write utilities, a constrained bash sandbox for command execution, permission systems for security isolation, and context/token quota management to avoid exceeding model context windows.

Building multi-model agent systems often requires unified routing for different LLM providers. 4sapi serves as an API gateway to consolidate model endpoints, simplifying switching between API dialects during local agent development.

This series intentionally avoids large monolithic codebases. Each lesson remains small and independently runnable. This incremental approach helps developers trace how individual components combine to build a complete agent, rather than copy-pasting finished products. Every component builds sequentially: HTTP transport, streaming parsing, terminal interface, tool calling, agent loop, security controls and context management.

Conclusion

This hands-on Golang tutorial series demystifies the internals of AI Agent CLI applications comparable to Claude Code. Starting from raw HTTP requests and SSE streaming, developers build each layer step by step using only Go standard libraries. The project isolates each feature in independent folders, making code comparison and iterative learning straightforward.

Understanding these low-level API transport and parsing mechanisms is foundational for building custom agents. Developers learn how different LLM API dialects structure payloads, how incremental streaming works, and how to wrap these primitives into interactive command-line agents. The completed foundation can be extended with custom tools, permission guardrails and context management for production-grade AI agent applications.

International access: https://4sapi.com
Domestic access: https://4sapi.cn

Agent: Upgrading Harness Engineering to Cognitive Engineering

Tidiane Stano — Thu, 17 Sep 2026 07:48:17 +0000

Introduction

Agent engineering has evolved through three distinct stages: Prompt Engineering, Context Engineering, and Harness Engineering. Each phase solved the core bottlenecks of its era. This article introduces two foundational concepts — cognition and metacognition, then re-examines what the three tiers of Agent engineering have accomplished. It clarifies the definition of cognitive engineering, its core goals, and the critical problems it addresses. Ultimately, this paper argues that metacognition is the missing piece for modern Agent systems.

1. What Is Cognition

From the perspective of cognitive science, cognition refers to the full process of acquiring, processing, storing and applying information. It covers perception, attention, memory, thinking and decision-making. Cognition is not a single capability, but a complete processing pipeline.

The pipeline can be simplified as: external stimulus → sensory input → attention filtering → working memory processing → long-term memory storage and learning.

Three empirically validated conclusions from cognitive science carry direct implications for Agent engineering:

Cognition is constructed, not recorded. Perception is jointly formed by bottom-up signal input and top-down prediction. Every memory recall reconstructs information instead of fetching static copies.
Cognition is bounded by resource constraints. Humans receive massive sensory data, yet conscious processing can only handle roughly 4 chunks within working memory, with a capacity limit of about four items.
Cognition relies on chunking. Humans break through memory bottlenecks by chunking: building templates for categories and workflows to speed up recognition. Pattern matching and iterative refinement form the core of this mechanism.

We can map human cognitive components directly to current Agent engineering modules, as shown in the following comparison table.

Human Cognition	Agent Engineering Counterpart
Attention and Perception	Input filtering, context retrieval
Working Memory (~4 chunks)	Context window, memory buffer
Chunking	State segmentation, event grouping
Long-term memory / Episodic memory	Memory logs, knowledge repository, skill files
Mental model	World model / Ontology
System 1 / System 2	Direct generation / Deliberate reasoning
Forgetting mechanism	Memory decay and cleanup logic

The mapping reveals shared constraints for both systems: finite capacity, information overload, and the need for abstraction. The two systems converge on identical structural limits, even though LLMs lack the biological hardware of human brains.

2. What Is Metacognition

Metacognition, defined as “cognition about cognition”, was first proposed by Flavell in the 1970s. It describes the capability to monitor, evaluate and regulate one’s own cognitive processes. It is not another cognitive skill, but a supervisory layer sitting above cognition itself. It consists of three core components.

Component	Definition	Human Example
Metacognitive knowledge	Knowledge of one’s own cognitive state; knowing what you know and what you do not know.	I have poor memory for names, I need to write notes down.
Metacognitive experience	Subjective feeling during cognitive activities, including confusion, uncertainty and confidence judgement.	This answer feels right, but I cannot fully confirm.
Metacognitive regulation	Planning, monitoring and adjustment of cognition; resource allocation, strategy switching and termination decisions.	I should recheck this calculation.

Metacognition acts as a key divider between high and low-performing human learners. Research shows metacognitive ability predicts learning outcomes no less strongly than raw intelligence. Its value comes from an asymmetric property: in real-world environments, knowing what you do not know often brings larger benefits than simply knowing more. Ignorance without self-awareness triggers persistent wrong decisions, while recognizing unknowns enables humans to seek help, verify facts or stop risky actions.

This is exactly the core weakness of present Agent systems. Large models demonstrate strong cognitive capabilities in comprehension, generation and reasoning, but they lack systematic metacognition. Three major deficiencies stand out:

Deficiency in uncertainty expression: models output confident answers for both reliable and unreliable information, creating the hallucination phenomenon.
Deficiency in effort allocation: simple and high-stake tasks consume identical reasoning budgets, creating mismatches between cost and risk.
Deficiency in stopping judgement: Agents lack independent judgement to decide when to continue, pause or ask for help. Existing implementations rely on hard-coded loop limits and budget caps.

These three gaps correspond to three engineered metacognitive loops: uncertainty representation, dual-process scheduling, and autonomous loss mitigation, detailed in section 4.

3. Agent Engineering from a Cognitive View: Accomplishments of the Three Stages

With cognition and metacognition defined, we can review the three generations of Agent engineering. Each tier built solutions for the cognitive pipeline, and solved the dominant bottlenecks of its time. All three layers supply preconditions for cognition, yet none handle metacognition.

3.1 Prompt Engineering: Helping Models Understand Instructions

Prompt engineering structures single-turn prompts: defining roles, tasks, context, constraints, few-shot examples and output schemas, alongside reasoning frameworks such as Chain-of-Thought.

Core deliverable: Improve model comprehension and instruction adherence, shifting behaviour from “can the model complete this?” to “can the model reliably follow requirements?”.
Scope: Optimizes input formatting for a single request. It does not manage multi-turn information supply.

3.2 Context Engineering: Ensuring Models Access Required Information

Context engineering builds systematic information supply pipelines, including RAG retrieval, memory layering, context compression, structural partitioning, output processing and just-in-time loading.

Core deliverable: Resolve what information the model can access, and in what sequence the information appears. Context window management solves the problem of information positioning.
Scope: Input assembly for one invocation. It does not execute actions or manage multi-turn loops.

3.3 Harness Engineering: Enabling Stable Long-running Loops

Harness engineering constructs the runtime machine for Agent loops. It implements the main Agent loop, tool invocation logic, permission grading, session state tracking, retry backoff and observability.

Core deliverable: Guarantee reliability for long tasks. Complex workflows with dozens of tool calls can complete without collapse. Research on SWE-Agent confirms that swapping the Agent-computer interface changes SWE-bench scores significantly, proving runtime design is a decisive factor.
Scope: Runtime control. Its objective function focuses on stable behaviour and controllable execution.

3.4 Shared Strengths and Missing Pieces

Prompt engineering decides what the Agent should be told; context engineering decides what information the Agent can see; harness engineering controls how the Agent acts. All three stages prepare conditions for cognition, but none address metacognitive judgement. They lack mechanisms for the model to judge “whether this conclusion can be trusted”, “how much reasoning budget this task deserves”, or “where the boundary of domain knowledge lies”. This phased development is natural. Each engineering layer only solves the bottleneck of its era. Treating metacognition as a first-class design target becomes the mission of the next stage.

4. Cognitive Engineering: Building a Complete Architecture Centered on Metacognition

Agent Cognitive Engineering uses validated cognitive science structures as design blueprints. On top of Harness engineering, it adds metacognition, self-management and knowledge systems. In short: Harness builds a reliable shell, while cognitive engineering equips the Agent with a cognitive architecture matching task requirements. This metacognitive layer sits at the top of the full system.

The architecture is not a replacement for the three preceding tiers, but a composition. Prompt engineering serves perception, context engineering implements working memory, and Harness forms the action execution system. The cognitive architecture integrates these modules and adds metacognitive supervision.

4.1 Implementation of Metacognition: Three Loops

Metacognition cannot be limited to static prompts asking the model to “reflect”. It must run as independent functional loops.

Loop 1: Uncertainty Representation (metacognitive knowledge & experience)

Attach calibrated confidence scores and disagreement margins to model outputs.
Retrieve contextual information to judge reliability, marking stale or incomplete reference materials.
Calibrate confidence: align the stated confidence level with factual accuracy using historical task traces, avoiding overconfident high-risk outputs.

Loop 2: Dual-process Scheduling (metacognitive control: resource allocation)

Dynamically trigger System 1 or System 2 reasoning. System1 for fast routine responses; System2 deep reasoning for high-risk operations, first-time failures or metacognitive anomalies.
Outcome: reasoning depth becomes a controllable variable. The system balances computation cost and task risk.

Loop3: Autonomous Loss Mitigation (metacognitive regulation: monitoring & assessment)

Budget awareness: track consumed and remaining resources for the current task.
Reward evaluation: assess gains and losses from repeated attempts. Use prior failure records as signals to terminate loops or seek human intervention.
This upgrades the old Harness hard limit rule into active judgement capability.

4.2 Supporting Structures for Metacognition

The three loops do not operate in isolation. They require supporting subsystems such as task specification and world ontology. Metacognition sits at the top of seven system layers. A cognitive architecture without ontology is hollow; metacognition cannot function without a complete cognitive structure.

4.3 Ontology Modelling and World Model: Type System of the Full Architecture

Among the seven subsystems, ontology (world model) deserves special attention. It carries three critical roles.

Content layer: It is the only component responsible for defining world state. Other subsystems handle entry, current events, history and self-management, while ontology defines what entities exist and how concepts connect. The quality of outputs of all other subsystems depends on ontology.
Structural layer: It serves as the schema language of the whole architecture. Subsystems reference ontology schemas to define long-term memory storage, event classification, skill definition and constraint rules. It establishes contracts between modules. Without ontology, seven subsystems operate independently without coordination.
Dynamics layer: Ontology acts as the carrier of cognitive growth. Cognitive improvement is not about expanding parameter scale, but iterative reconstruction inside ontology. Failed attempts trigger schema updates and knowledge restructuring.

Ontology has clear boundaries. It represents simplified abstractions rather than absolute truth. Code selected for ontology does not equal fully correct code. Building ontology also carries engineering overhead.

5. Applying Cognitive Engineering to Vertical Domain Challenges

Vertical domains such as finance, healthcare, law and insurance impose three structural constraints for Agent systems: non-deterministic verification, implicit knowledge and irreversible actions.

Constraint	Description
Non-deterministic verification	No ground truth reference. Judgement relies on expert review and case comparison.
Implicit knowledge	Core expertise stored inside internal documents and regulations, evolving over long cycles.
Irreversible actions	Operations such as order placement or data modification write directly to system records.

Within these constraints, metacognition changes from “important” to mission-critical. With limited external verification channels, “knowing what you do not know” becomes the first and last safety barrier against severe mistakes. An Agent capable of recognizing ignorance outperforms one that confidently answers all questions. Cognitive engineering vertical deployment focuses on four workstreams.

Uncertainty stratification and progressive authorization: define state layers, pass down permissions only after lower-layer uncertainty is resolved. Each layer has escape routes for revision, rollback or human takeover.
Ontology construction and composite verifiers: build domain schema, rule engines and constraint checks to convert raw LLM outputs into validated outputs.
Cognitive workflow design: build pipelines for escalation, grading human intervention and fallback mechanisms.
Consolidation loop: after human confirmation, record cases and confidence calibration data. These records continuously update ontology and judgement libraries, forming the moat of vertical Agents.

6. Agent Cognitive Improvement and Human Review of Metacognition

How can Agent cognition be improved? The path mirrors human learning patterns.

6.1 Agent Cognitive Growth: Reduce Model Invocations

Cognitive development often moves from deliberate thinking towards automatic reaction. Cognitive science describes this transition: declarative knowledge becomes procedural knowledge. System2 deliberate reasoning evolves into fast System1 reflex responses.

For Agents, cognitive improvement occurs at runtime rather than model fine-tuning. The system continuously compiles recurring reasoning patterns into executable skills. When new requests hit known patterns, the system triggers fast reflex execution instead of heavy deep reasoning.

Two compiler-style components enable this shift:

Ontology compiler: converts ontology schema and rules into judgement logic.
Uncertainty compiler: converts confidence boundaries into routing rules, bypassing LLM calls for predictable cases.

System 2 handles novel, high-risk and unstructured scenarios. Cognitive engineering does not eliminate deliberation; it reserves heavy reasoning only for cases that truly require it.

6.2 Redirect Human Labour: From Output Review to Metacognition Audit

Human review is mandatory for high-stakes vertical systems. Traditional workflows require humans to inspect every output, which creates heavy workloads. Cognitive engineering shifts this paradigm. Instead of auditing every generated result, humans audit metacognitive judgements.

Human reviewers check three categories of failure modes:

Overconfidence: uncertain input receives high confidence marking.
Over-caution: definite inputs trigger unnecessary escalation to human operators.
Termination misjudgement: the Agent stops too early or loops infinitely.

6.3 Five Mechanisms of Human Review

Audit sampling: periodically sample false positives and false negatives to evaluate metacognitive accuracy.
Confidence calibration: compare stated confidence against factual correctness, detect systematic bias.
Escape tunnel inspection: review outputs marked as uncertain, confirm missing information.
Event logging and replay: store escalated records, support traceability and audit.
Progressive human rollback: gradually reduce human review proportion after system stability validation.

Review outcomes feed back to update confidence thresholds and training data, closing the loop of model calibration and human standard alignment.

7. Deployment and Acceptance of Cognitive Engineering

Teams already running Harness systems can adopt cognitive engineering incrementally. Minimum viable deployment adds three core modules: task closure questions, dual-process conditional triggering and periodic calibration sampling. No full model replacement is required.

Traditional evaluation metrics such as pass rate and latency remain necessary, but cognitive engineering adds new indicators: uncertainty classification accuracy, cost curves, human handoff volume and error non-growth under scaling. Vertical scenarios further track human intervention rate.

The deployment of multi-model Agent systems often requires unified routing and access management. 4sapi serves as an API gateway to simplify multi-model request scheduling, helping engineering teams focus more on cognitive logic design rather than interface adaptation.

8. Conclusion

Three generations of Agent engineering each solved their own core problems. Cognitive engineering composes these mature capabilities into a complete cognitive architecture and adds the missing metacognitive judgement layer.

Prompt engineering defines what the Agent hears; context engineering defines what the Agent sees; harness engineering defines what the Agent executes; cognitive engineering adds metacognition to answer what the Agent knows, what it ignores, and how to allocate its reasoning resources. The ultimate test of an Agent system becomes a single metacognitive question: does it know its own confidence level?

International access: https://4sapi.com
Domestic access: https://4sapi.cn

Notion Too Costly? This 40K-Star Open-Source Knowledge Base Lets Teams Build Wiki at Zero Infrastructure Cost

Tidiane Stano — Wed, 16 Sep 2026 10:01:30 +0000

Introduction

Notion has earned a strong reputation as a flexible team knowledge workspace, but its recurring subscription cost can create a financial burden for small teams. Outline, an open-source team knowledge base project with over 40,600 GitHub stars, delivers core capabilities comparable to Notion. It supports real-time collaborative editing, native Markdown syntax, and Slack integration. The biggest distinction is its self-hosting capability, letting teams retain full ownership and control of their data. Outline is not a drop-in one-to-one replacement for Notion, but an open-source alternative platform for team documentation.

Many teams face the same documentation pain points. Their internal knowledge is scattered across Lark, Feishu, Yuque, Obsidian, and Google Docs. Team members must switch between multiple platforms just to locate a single document. Even after locating the target file, they may encounter version conflicts and unclear edit history with no simple way to trace who modified the content.

While Notion delivers an elegant user experience, its pricing structure adds up quickly. The platform charges roughly $10 per user per month. A 10-person team will spend $1,200 USD annually. This recurring expense places pressure on bootstrapped startups and small engineering groups. Beyond billing concerns, teams relying on SaaS knowledge bases also face data sovereignty risks. When documents live on a third-party provider’s servers, outages, policy adjustments, or service interruptions can create irreversible data loss, with limited options for independent backups and full exports.

Outline solves these challenges with a self-hosted knowledge base. It provides similar core functionality, while teams maintain complete ownership over their stored information. This article breaks down Outline’s core capabilities, technical architecture, community health metrics, and comparative benchmarks against competing tools. No advanced programming knowledge is required to follow this analysis.

1. Core Pain Points Addressed by Outline

Team documentation management commonly suffers from four critical bottlenecks, all targeted by Outline’s design philosophy.

Fragmented document storage Team knowledge gets split across separate SaaS platforms. Engineers and product staff need to jump between multiple services to retrieve design specs, meeting notes, and operational runbooks.
Cross-platform search limitations Built-in search works reasonably well within a single platform, but cross-service searching is impractical. Users have to manually browse each tool to find a specific document.
Disjointed permission management Every documentation platform maintains its independent permission system. Onboarding new team members requires provisioning access across four or five separate services, creating heavy administrative overhead.
Loss of data control With hosted SaaS products, data resides on external servers. Users cannot freely run independent backups or export complete datasets. Service disruptions can result in permanent data loss.

Outline’s unified solution consolidates all team documents inside one system. It supports Markdown import and export for easy migration from other tools. Multiple users can edit documents simultaneously with real-time collaboration. Slack integration automatically pushes document updates to designated channels. Self-hosting deployment puts full data ownership into the hands of your organization.

A simple analogy illustrates the difference: Notion is like a rented apartment, comfortable to live in, but you never own the property. Outline is comparable to a self-owned home. You handle setup and maintenance, but hold full ownership of all assets inside.

2. Core Feature Set

Real-time Collaboration

Multiple users edit the same document concurrently, with live cursor tracking. The platform supports inline comments, user mentions, and complete version history tracking. Team members can review change logs and revert unwanted edits quickly.

Native Markdown Compatibility

Outline fully supports Markdown syntax. Importing and exporting Markdown files is seamless, lowering migration friction from Notion, Feishu, Yuque and other Markdown-enabled editors. Teams can transfer existing content with minimal rework.

Document Organization System

The platform supports folders, collections, tagging, and bidirectional internal document links. These features build a connected knowledge graph, making it easy to group related materials and navigate internal references.

Full-text Search

Built-in full-text search indexes document body content, titles and tags. Query response speed remains fast even as the library scales to thousands of internal documents.

Slack Integration

Document modifications trigger automatic notifications to selected Slack channels. Team members stay informed about knowledge base updates without opening Outline itself.

REST API Support

Outline exposes REST API endpoints, enabling integration with external services and automated workflow pipelines. Teams can connect the wiki with internal automation scripts, CI pipelines, and custom dashboards.

Template Library

The system ships with pre-built templates, and users can create custom templates. Standardized templates streamline creation of meeting notes, incident reports, technical specs and onboarding guides.

Self-host Deployment

Outline supports one-click deployment via Docker. Self-hosted instances keep all document data within your own server infrastructure, removing third-party data custody risks.

3. Technical Architecture

Outline is built using a mature modern web stack:

Frontend: React + TypeScript + Styled Components
Backend: Node.js + TypeScript
Database: PostgreSQL
Caching: Redis
Search: Native built-in full-text search, optional Elasticsearch integration

This technology stack is deliberately conservative. The React ecosystem is stable, TypeScript adds static type safety, PostgreSQL delivers reliable persistent storage, and Redis optimizes caching and session speed. The project repository contains more than 10,439 commits, proving sustained long-term development and active code maintenance.

Outline’s architecture prioritizes stability over cutting-edge experimental technologies. For knowledge base workloads, reliability and data consistency are far more important than adopting the newest frameworks.

4. Side-by-side Comparison with Similar Team Wiki Products

Feature	Outline	Notion	Confluence
Open Source	Yes (BSL License)	No	No
Pricing	Free for self-host	$10 / user / month	$5.75 / user / month
Native Markdown	Yes	Supported	Partial support
Real-time Collaboration	Yes	Yes	Yes
Self-host Deployment	Yes	No	Available
Learning Curve	Low	Low	Medium

Notion is widely popular for team knowledge work, boasting polished UI and comprehensive features, but it operates on a closed SaaS model with data hosted externally. Confluence is an established enterprise wiki platform, powerful but burdened by an outdated interface, steep learning curve, and relatively high subscription pricing.

Outline differentiates itself as an open-source alternative. It delivers comparable core functionality with self-hosting capability for complete data ownership. Its BSL license imposes certain commercial limitations, but it works perfectly for internal team use cases.

Community activity metrics demonstrate ongoing project vitality. The repository tracks pull request ratios, contributor activity, push volume and issue resolution statistics. The project maintains a steady cadence of contributions, bug fixes and feature improvements.

5. Strengths and Limitations of Outline

Core Strengths

Real-time collaborative editing closely matches Notion’s user experience
Native Markdown support drastically cuts content migration cost
Self-hosting gives organizations full sovereignty over data
Slack webhook integration and REST API streamline workflow automation
Active community and commercial support options are available

Known Limitations

The BSL 1.1 license is not recognized as true open-source licensing, which imposes constraints on commercial usage. Self-hosting requires basic DevOps skills, creating a barrier for non-technical teams. While its feature set approximates Notion, gaps remain: database tables, dashboard views, and some advanced Notion widgets are not fully implemented. Although the community size is substantial, most code contributions originate from a small core maintainer group, limiting broad external contributor participation.

6. Outlook & Suitable Use Cases

Outline has reached a mature stable phase, with complete core functionality and an established user base. It is most suitable for technical teams looking to host internal documentation while retaining local data control. Startups can replace Notion subscriptions and cut recurring SaaS expenses. Organizations with strict data compliance requirements can adopt Outline for regulated internal knowledge management.

Teams with low risk tolerance and limited DevOps manpower can deploy Outline with routine maintenance and commercial support. With 40.6k GitHub stars, the project has proven sustained community demand. It is not a perfect one-to-one replacement for Notion, but it offers a solid alternative choice.

When building internal automation pipelines that connect Outline with multiple backend services, developers can leverage 4sapi, an API gateway, to manage endpoint routing, authentication and traffic control across integrated systems.

7. Closing Thoughts

Outline highlights a growing industry trend: open-source alternatives to mainstream SaaS productivity platforms are becoming viable for everyday team workflows.

Not every team requires the full breadth of Notion’s feature suite. Many teams only need a simple system to write documents, index content, and support collaborative editing. Outline is purpose-built to satisfy these requirements. The 40.6k GitHub stars validate this market direction. More teams are actively searching for Notion alternatives, and Outline delivers a compelling option.

If your team is shopping for a self-hosted wiki, consider testing Outline. It may not make you abandon Notion entirely, but it gives your team an additional flexible choice for internal knowledge management.

International access: https://4sapi.com
Domestic access: https://4sapi.cn

GPT-6 Tops Community Model Benchmarks: Breaking Down Real-Time Rankings Across 30 Task Domains

Tidiane Stano — Wed, 16 Sep 2026 09:57:45 +0000

Two weeks after the release of GPT-6 Astra, a new community benchmark platform known as the Bilibili AI Arena has drawn attention among AI practitioners. Unlike traditional academic benchmarks, this platform invites independent content creators to design practical challenge tasks, staging head-to-head competitions for more than 100 large language models across 30 unique themes. The results of these rounds of real-world testing place GPT-6 Astra at the top of the overall leaderboard. The model has participated in 16 evaluation rounds, claimed 10 championship victories, and achieved a 62.5% win rate.

Nevertheless, a deep dive into the full ranking dataset reveals nuanced performance that the headline ranking cannot fully capture. Across the 30 tested themes, GPT-6 only secured first place in 10 categories. The remaining 20 challenge themes were claimed by GLM-5.3, Claude series models, DeepSeek, Qwen, and even Seed-2.0 Pro, which did not rank inside the overall top nine. While GPT-6 delivers outstanding performance in specific domains, its advantages shift drastically once the task type and evaluation rules change. This article disassembles the complete benchmark dataset, analyzes where GPT-6 excels and underperforms, and outlines actionable guidance for developers to interpret and leverage this community benchmark.

1. How this Community "AI Grand Examination" Works

The core distinction separating this community benchmark from conventional academic benchmarks is straightforward: test cases are created by independent creators rather than laboratory research teams.

Test tasks reflect practical work scenarios, including refactoring legacy GTA5 source code, building a Bilibili homepage from plain natural language requirements, designing quantization strategies, simulating national college entrance exam questions, and even role-playing matchmaking conversations.
The ranking rule counts the number of times each model wins individual rounds. No weighted scoring formula is applied to aggregate results.
The leaderboard remains dynamic and updates in real time whenever content creators release new evaluation videos.

The platform explicitly states that all raw data comes from public evaluation videos published by these independent creators. Evaluation outcomes are produced independently by the video authors, while the platform only archives and displays the results.
This setup sacrifices some of the rigor found in academic benchmarks. There is no strict control of variables, nor statistical significance testing. Even so, it fills a critical gap that standard synthetic benchmark suites cannot cover. It tests model behavior under messy, real-world task conditions, closely mirroring the day-to-day work of engineers and product teams. In real business scenarios, stakeholders rarely ask for standardized benchmark scores. Instead, they focus on whether a requirement can be delivered as expected.

2. GPT-6’s Dominant Territory: Code Generation and Refactoring

Among the 10 themes that GPT-6 won, 8 belong to programming and software development categories. The following table summarizes the championship tasks taken by GPT-6 Astra.

GPT-6 Winning Theme	Creator Name	Number of Participating Models
Loop repair for 1.98 billion iterations of legacy GTA5 code	人工大黑	24
Inorganic acid benchmark suite	无机酸_-	22
Code repair tournament	Token就是词元	14
Programmer benchmark	程序员阿江-Relakkes	14
Build Bilibili homepage from plain language requirements	圣徒城的小诺	10
Akazban benchmark suite	我是阿兹卡班	9
Dungeon game asset generation test	Likely7Ai	4
AI whitebox video generation rule test	DeepWhite深白色	3

Two representative test cases deserve deeper analysis.
The first is the GTA5 legacy code repair challenge, the largest-scale coding competition with 24 competing models. The task centers on a famous problematic legacy segment inside GTA5, consisting of a 1.98-billion-cycle if loop. The creator tasked all participating models with refactoring this problematic code. The evaluation criteria required models to understand the high-level logic and produce runnable, deployable fixes, similar to inheriting a risky, long-abandoned codebase. GPT-6 took first place in this challenge. The same creator also designed a second-round examination focused on long-context knowledge retention, which is also archived within the arena platform.

The second key task required building a Bilibili homepage based on roughly 100 words of natural language description. Ten models joined this front-end development challenge. Real-world natural language requirements are inherently ambiguous and open to multiple interpretations. The model must first clarify implicit intent and then implement both engineering logic and UI layout. GPT-6 claimed victory here as well.
Additionally, creator Likely7Ai ran a separate dedicated test on GPT-6 Astra covering three linked tasks: webpage replication, Blender animation generation, and game asset creation. Full test footage is available in the arena archive.

For software engineers, these results deliver a clear signal. When working with ambiguous requirements and translating natural language into functional code, GPT-6 Astra outperforms other tested models in this group of competitions. These results are derived from head-to-head matches against 14 to 24 competing models, not self-reported internal benchmark results.

3. Shifting Evaluation Rules Reshape Final Rankings

One of the most striking comparisons comes from creator Token就是词元, who designed three separate coding challenges for the same pool of models.

Challenge Session	Evaluation Format	GPT-6 Ranking	Winner
Code repair tournament	Head-to-head PK for bug fixes	1st (14 models)	GPT-6
Legacy bug elimination challenge	Group scoring and elimination bracket	5th (16 models)	Claude Fable 5.1
Legacy code unified written exam	Identical exam paper with unified scoring	Not ranked	GLM-5.3 (12 points)

All three tasks belong to coding evaluation, yet rankings change drastically under different rules. In the head-to-head tournament format, GPT-6 demonstrated superior upper-limit capability and secured first place. When the evaluation switched to group scoring and elimination rounds, it dropped to 5th, surpassed by Claude Fable 5.1, Claude Opus 5, DeepSeek V4 Pro and Doubao Seed 2.1. In the unified written examination using identical scoring standards, GPT-6 failed to make the leaderboard at all, while GLM-5.3 earned the highest score of 12 points.

This does not indicate fundamental flaws in GPT-6. It demonstrates that model capability is not a single scalar value, but a vector of different strengths. Head-to-head matches test the upper boundary of model ability, while standardized written exams evaluate stability and consistency. This distinction is invisible on conventional static benchmark leaderboards but becomes fully exposed within these three test sets from a single creator.

A similar pattern appears in escape-room puzzle tests. Creator AGI-Eval created 270 puzzle scenarios based on the same story script. At low difficulty tiers, GPT-6 performs best on clue linking. Once puzzles advance to high difficulty levels requiring multi-layered reasoning chains, its advantage fades, and Claude Opus 4.6 overtakes it. With identical source material, a small increase in task difficulty changes the final ranking.

4. Outside Coding Domains: Other Models Take the Lead

For the remaining 20 themes where GPT-6 failed to claim first place, different models emerge as champions in their respective specialized fields.

Theme	Participating Models	Top Performer
AI quantization evaluation benchmark	14	Qwen3.8-Max (GPT-6 ranks 2nd)
National college entrance exam simulation	36	Claude Opus 5
Prisoner’s Dilemma game theory challenge	6	Seed-2.0 pro
AI literary writing contest	6	Gemini 3.8 Flash
AI mahjong tournament	14	DeepSeek-V4-Flash
AI Gomoku invitational competition	8	Doubao-Seed-Evolving
Vector database performance test	20	Claude Fable 5.1

Several key observations can be drawn from this dataset.
GLM-5.3 takes second place in the overall ranking, with three championship titles and participation across 16 rounds, matching GPT-6 in the number of appearances. Its 18.75% win rate stands below GPT-6’s 62.5%, making it one of the most balanced domestic large models in this benchmark set.
Claude Fable 5.1 achieves a 33.33% win rate with 9 participations and 3 championship wins. Its win rate exceeds GLM-5.3, and it defeated GPT-6 within the legacy bug elimination coding challenge.
Seed-2.0 Pro wins the Prisoner’s Dilemma task, even though it is not listed in the overall top nine. Multi-round game theory and opponent behavior prediction represent a category of tasks where standard benchmark scores often cannot reflect true capability.
Several models remain winless after many evaluation attempts, including Kimi K3 with 13 participations, Grok 4.6 with 11 participations, and MiniMax M3 with 10 participations.

When developers integrate multiple LLMs into a single system, an API gateway can streamline routing, authentication and usage monitoring across different model endpoints. 4sapi acts as such an API gateway to simplify multi-model service orchestration for production workloads.

5. Practical Guidance for Developers Using This Benchmark

The leaderboard delivers three core practical takeaways for engineering teams selecting large models.

5.1 Avoid relying solely on the overall leaderboard

Do not pick a model purely based on the aggregate top rank. The overall ranking reflects general performance, while single-theme results are the proper reference for tool selection. If your daily workload focuses on programming, code refactoring and debugging, GPT-6 currently demonstrates the strongest performance. If your work centers on quantization, knowledge set maintenance or long-form writing, refer to the champion of the corresponding task category instead.

5.2 Pay attention to evaluation rules for identical tasks

The three coding challenges designed by Token就是词元 serve as a prime example. Open-ended creative tasks tend to favor GPT-6, while standardized, uniformly graded written exams shift advantages to other models. Evaluate whether your real work aligns with the tournament-style upper-bound test or the stability-focused standardized exam.

5.3 Keep track of the live leaderboard

The leaderboard updates continuously as creators release new test videos. Today’s ranking may change next week. Instead of waiting for lengthy formal evaluation reports, bookmark this live benchmark page and revisit it regularly. It provides continuous real-world task data covering dozens of models.

Conclusion

Traditional benchmark scores answer the question of how fast a model can solve synthetic academic problems. Community arena benchmarks answer a different question: which model performs well for your practical use cases. Static benchmark suites have long ignored many real-world task types, but independent creators have filled this gap by designing hundreds of task scenarios covering over 100 models.

These community test results remind practitioners that there is no universal "strongest AI" model. Model suitability always depends on task boundaries, evaluation rules and business scenarios. GPT-6 Astra exhibits exceptional strength for coding work with ambiguous requirements, but its advantages shrink or disappear for reasoning examinations, game theory and long-form writing tasks.
For production teams, the optimal strategy is to match model selection with specific workloads, combining live community benchmark results with internal domain testing before finalizing integration.

International access: https://4sapi.com
Domestic access: https://4sapi.cn

ChatGPT Sites Public Beta Disrupts Website Building Experience, GPT-6 Cross-Modal Capabilities Break Human Sensory Barriers

Tidiane Stano — Tue, 15 Sep 2026 10:07:34 +0000

Introduction

OpenAI has rolled out the public beta of ChatGPT Sites, a new capability that reshapes the workflow of website creation. Even users with zero coding knowledge can build fully functional interactive websites within roughly ten to fifteen minutes, simply by submitting natural language prompts or uploading hand-drawn sketches. This capability parallels the simplicity of working on Google Docs, which delivers a disruptive impact on the traditional website-building SaaS industry.

Alongside the release of ChatGPT Sites, researchers have unveiled remarkable cross-modal performance of GPT-6. The model can directly interpret Mel spectrogram visualizations of audio signals. It identifies sound source information purely from these two-dimensional visual plots without listening to the original audio. This breakthrough breaks the long-standing sensory boundary that constrains human perception, marking a new milestone in multi-modal large language model research. This article breaks down the core functions of ChatGPT Sites, its workflow and real-world use cases, analyzes the paradigm shift it brings to human-computer interaction, and explores the underlying mechanism and industry implications of GPT-6’s spectrogram reading capability.

ChatGPT Sites Public Beta: Website Creation Becomes as Simple as Document Editing

In the early internet era, building a personal website was a privilege reserved for programmers and professional designers. Early web-building tools such as Dreamweaver relied on manual coding. Later, Wix, Squarespace and Tilda launched drag-and-drop website SaaS platforms, lowering the technical threshold to a certain degree, yet users still needed to learn layout rules and component configuration.

ChatGPT Sites fundamentally tears down these barriers. Jeremy Caplan, operator of Wonder Tools and a well-known technology media figure, shared his practical evaluation. He stated that the experience brought by ChatGPT Sites is truly transformative: creating an elegant website now feels no different from drafting a Google Doc.

The function is available to users subscribed to ChatGPT Plus, Pro, Business, Enterprise and Edu plans. The whole workflow consists of four clear steps.

Describe your vision. Users define website type, target audience, core functions and brand style in natural language. Users can also upload reference webpage screenshots or hand-drawn sketches as visual references.
Provide material requirements. Users specify interactive components including link buttons, form input boxes and animation elements.
Submit functional specifications. Users lay out detailed interactive logic, animation rules and page jump relationships.
Generate and iterate. After waiting 10 to 15 minutes depending on visual complexity, a complete interactive website is produced.

This is not a simple template replacement. It adopts Vibe Coding technology. The model dynamically writes and assembles front-end code tailored for the requirement rather than filling fixed template placeholders.

Early testers have built a wide range of practical projects. For commercial scenarios, users built product accessory landing pages and modern event promotion websites for San Francisco. Artists also explored creative applications. Drue Kataoka built GoalFlow, an art creation tool. After users select national flags, the tool simulates pigment flowing and blending on a canvas, driven by complex physical simulation front-end code. Building this type of project previously required senior front-end engineers multiple weeks to implement, while ChatGPT Sites can complete the work with a few natural language prompts.

Game development is another active test field. Developers have created a text-based adventure game Glass Tower with built-in physical effect logic, and Paper Glider, a control game for paper planes flying through rings.

What makes this tool more powerful is its iterative editing capability. After the initial webpage draft is generated, users can use annotation tools on the side panel to mark content directly on the webpage. Instructions such as “change this button color”, “replace the font with sans-serif” or “swap this image” can be understood and executed for real-time modification.

Earlier AI website tools including Lovable Bot had certain usability. Claude Artifacts and Claude Design also delivered outstanding interactive webpage output. However, the core advantage of ChatGPT Sites lies in its deep integration within the ChatGPT ecosystem. If users work inside a ChatGPT Project workspace, the tool automatically inherits brand styles, logos and visual specifications defined in the project. The generated webpage naturally matches brand design language.

Under this new workflow, the role of front-end engineers has shifted toward “prompt product managers”. Traditional SaaS website vendors that charge high monthly fees and cannot rapidly iterate their product experience will face severe competitive pressure in the near term.

Application Paradigm Shift: Eliminating Operations and Retaining Only Intent

Review the evolution path of human-computer interaction. From command-line interfaces (CLI) in the PC era, to graphical user interfaces (GUI), and now natural language user interfaces (LUI) powered by large models. The core trend is continuously reducing the threshold of human operation.

ChatGPT Sites pushes front-end engineering from the “engineering expression” stage to “intent expression”. In the past, if users wanted to build a website, their intent needed to go through multiple layers of translation. The demand “I want to sell goods online” needed to be converted into product logic for shopping carts and payment systems, then translated into HTML, CSS and JavaScript front-end code, and further connected to database back-end logic.

Traditional software encapsulates these layers of conversion. It wraps code modules into clickable buttons on the interface. Users still need to operate these components to realize their intent. Large models have reversed this paradigm. Users only need to describe the intent in natural language, and the system directly generates the final deliverable.

This shift means all transitional tools designed to help non-programmers write code and build websites face fundamental value reconstruction. In the end-to-end generation workflow, intermediate operation steps disappear, and users no longer need to master underlying implementation knowledge.

GPT-6 Reads Spectrograms, Breaking Human Sensory Barriers

Researchers ChrisGPT and Max Rubin published a set of test results for GPT-6 Astra, which shocked audio engineers and AI practitioners. The core test is simple: convert audio into a Mel spectrogram image, and let GPT-6 read and reason from the visual image, without feeding the original audio file.

In one experiment, researchers sent a Mel spectrogram, without mentioning any background information. The only prompt given was: “This sound comes from an animal or mammal in nature.” GPT-6 responded: “It is likely a blue whale.”

The result surprised the research community. It was not merely a simple image matching task. The low-frequency whale call sits in the 40–200 Hz range. Relying only on frequency spectrum information, humans cannot confirm the sound source as a blue whale. Audio engineers analyzed the underlying logic: GPT-6 accurately captures continuous morphological features of energy changes over time. It does not merely recognize static patterns. It understands the physical rules describing how energy flows and attenuates over time within the sound waveform. With minimal context, the model directly identifies animal categories only from a spectrogram image.

Max Rubin’s demonstration further shows the model’s powerful cross-modal transfer capability. He tested non-natural sound effects. GPT-6 Astra could identify the lightsaber sound from Star Wars directly from the Mel spectrogram, with zero sample audio input. Max Rubin commented that even in academic research, scholars had attempted spectrogram classification with vision models or trained dedicated LLMs for spectrogram tasks. This marks the first public verification that a general large model can complete cross-modal reasoning without dedicated fine-tuning.

This ability can be analogized to a person who has never learned music theory. Given a symphony score image, the person can not only “hear” the music mentally but also describe the rhythm and pitch changes in the second movement.

Large Models Escape the Constraints of Human Biological Perception

Human perception of the world has inherent biological limits. Humans rely on air vibration to vibrate eardrums, and the brain converts physical vibration into electrical signals of sound. In human subconsciousness, sound belongs to the auditory channel and images belong to the visual channel. This separation is a sensory barrier formed through millions of years of biological evolution.

Early multi-modal AI systems essentially imitated human perception. Researchers fed audio and image materials, expecting AI to understand information in the same way humans do. GPT-6 Astra’s spectrogram recognition capability carries deeper significance. Large models are breaking away from human biological sensory constraints.

For GPT-6, there is no essential difference between the long call of a blue whale and the cracking sound of a lightsaber. Both are waveforms of energy within physical media. When these waveforms are converted into mathematical and geometric expressions such as Mel spectrograms, GPT-6 can directly read the underlying physical rules. The model does not need to “hear” sound; it can directly read the visual representation of acoustic energy.

This evolution indicates that multi-modal understanding of AI has moved past “imitating human senses”. It directly processes raw data structures from physical observations. Today it can identify blue whales from spectrograms. In the future, if provided with seismic images, it may predict the timing of fault rupture. If given electroencephalogram plots, it may decode human thought patterns. Humans perceive the universe through physical senses, while AI can directly read the mathematical code of the universe.

Developers integrating multi-modal capabilities into their application stack often need unified routing for different model endpoints. As an API gateway, 4sapi helps teams manage cross-modal model access and traffic scheduling in development workflows.

Industry Implications and Future Outlook

ChatGPT Sites and GPT-6 cross-modal capability represent two different evolutionary directions of large model technology. ChatGPT Sites redefines the production workflow of digital products. It transfers the complexity of coding and layout from humans to models, lowering the threshold for web production. GPT-6 breaks the boundary between different modal signals, redefining the way AI observes and understands the physical world.

For web development industries, the impact is multi-dimensional. Front-end developers will gradually shift their work from repetitive component coding to prompt design, requirement sorting, brand specification management and model output review. Traditional no-code website SaaS products must upgrade their technical architecture rapidly. Their core selling point of lowering technical barriers will face the most direct substitution risk.

For multi-modal AI research, GPT-6’s spectrogram test proves that general large models can learn cross-domain physical laws without task-specific fine-tuning. Traditional multi-modal models mostly learn mapping between human sensory data. GPT-6 learns underlying physical rules behind the data. This opens new research directions for scientific computing, signal analysis, geological monitoring and biomedical signal decoding.

There are still practical limitations to note. ChatGPT Sites currently has constraints on page complexity, asset management and deployment permission. The generated website still requires manual security review before production release. For GPT-6, current spectrogram tests remain in controlled research environments. Large-scale real-world signal processing tasks still require more benchmark tests to verify stability and accuracy.

For enterprise developers, the core opportunity lies in building applications on top of these new capabilities. Teams can build internal tools, marketing landing pages and lightweight interactive demos with natural language. Meanwhile, multi-modal reasoning capability can be embedded into audio analysis, signal detection and scientific research tools. When connecting multiple LLM and multi-modal models, developers need unified authentication, access control and load balancing. 4sapi provides centralized API management to simplify multi-model integration work.

Conclusion

ChatGPT Sites public beta brings revolutionary changes to website building. It turns website development from a professional engineering task into an intent-driven document-like creation activity. Combined with GPT-6’s cross-modal reasoning capability that directly reads spectrogram visual data, the two technologies together show the next phase of large model evolution: AI is gradually decoupling from human sensory patterns and directly reasoning from the underlying mathematical representation of physical phenomena.

This technological wave reshapes SaaS business, front-end engineering and multi-modal AI research. Developers and enterprises need to re-evaluate product development workflows and model integration strategies. As general multi-modal models continue to advance, more tasks previously limited by human sensory channels will be open to automated reasoning by AI.

International access: https://4sapi.com
Domestic access: https://4sapi.cn

OpenAI’s Custom Chip Jalapeño: Why Inference Comes First, and Can It Compete With NVIDIA?

Tidiane Stano — Tue, 15 Sep 2026 10:05:13 +0000

Introduction

OpenAI has partnered with Broadcom to develop an application-specific integrated circuit (ASIC) dedicated exclusively to large language model inference, formally named Jalapeño. The two companies jointly announced the chip on June 24, 2026. At the time of announcement, engineering samples had been produced and were running functional workload validation. The entire design-to-silicon cycle took nine months. The first batch deployment is scheduled to kick off by the end of 2026.

This chip project is not designed to fully replace general-purpose GPUs. Instead, it targets higher efficiency for high-frequency inference workloads, including ChatGPT, Codex and OpenAI API services. The hardware rollout also lays the foundational hardware roadmap for the multi-generation accelerator plan, which targets a total capacity of 10 gigawatts across multiple generations.

Jalapeño is an ASIC built from scratch for LLM inference. OpenAI defines the architecture, while Broadcom delivers chip implementation and networking subsystems. Initial deployment is planned to begin at the end of 2026.

Verified Facts vs. Early Media Speculation

As of August 2026, Jalapeño has been publicly announced, yet it remains in engineering sample testing and pre-mass-production preparation stages. It is critical to separate verified official information from unsubstantiated rumors circulated in 2025 media coverage.

Information Item	Current Status	Source Reference
Official chip name: Jalapeño	Confirmed	OpenAI & Broadcom, June 2026
Positioning: LLM inference ASIC	Confirmed	OpenAI & Broadcom, June 2026
Design-to-silicon timeline: 9 months	Confirmed	OpenAI & Broadcom, June 2026
Sample runs GPT-5.3, Codex-Spark and other workloads	Confirmed	Broadcom official announcement, June 2026
Initial deployment scheduled for late 2026	Planned, not yet large-scale mass production	OpenAI & Broadcom, June 2026
Multi-generation system target: 10 gigawatts total capacity	Publicly announced partnership objective	OpenAI & Broadcom, October 2025
Early testing shows improved power efficiency over existing products	Preliminary test results; precise benchmark figures undisclosed	OpenAI & Broadcom, June 2026
Manufacturing process, HBM capacity, single-chip compute and pricing	Not disclosed	Official technical whitepaper pending release

In 2025, multiple media outlets reported the potential OpenAI-Broadcom collaboration and speculated on manufacturing partners. The two firms confirmed the scale of their partnership in October 2025, and only formally released the chip name and sample status in June 2026. Any claims related to manufacturing node, cost reduction multiples or unvalidated performance multipliers that are absent from the latest official documents cannot be treated as established facts.

Why OpenAI Prioritizes an Inference-First Custom ASIC

Inference workloads are high-volume and relatively stable. These characteristics directly influence per-service operational expenses, making inference the area where custom ASICs can most easily deliver economies of scale. OpenAI has deep visibility into the most frequent operators, memory access patterns and network traffic patterns observed within ChatGPT, Codex and API traffic. There are four core rationales for focusing on inference first.

Predictable workload characteristics
Inference traffic patterns can be modeled more reliably than training workloads. This predictability allows hardware architects to optimize data movement, on-chip cache and compute unit allocation for the most common execution paths.
Hardware utilization directly impacts service economics
Higher real hardware utilization translates into lower end-to-end latency, more consistent capacity planning and reduced per-token inference cost. For OpenAI’s public API, marginal cost reduction directly improves gross margins at scale.
Diversified hardware supply chain
A custom inference chip adds another source of compute capacity. It will not immediately phase out NVIDIA GPUs, AMD accelerators or cloud provider silicon. It serves as a risk mitigation strategy against supply shortages, price volatility and single-vendor dependency.
Full-stack co-optimization between software and hardware
OpenAI retains control over models, kernel implementations, resource scheduling and end-user product experience. This allows cross-layer tuning: model quantization, attention kernels and cluster orchestration can all be adjusted to match Jalapeño’s hardware architecture.

Jalapeño Compared Against GPU, TPU and Trainium

The key distinction of Jalapeño is not merely that it is another AI chip. Its design is built around OpenAI’s native inference workload stack. The table below summarizes positioning, openness, maturity and strategic meaning for OpenAI.

Chip / Platform	Primary Positioning	Access Scope	Current Maturity	Strategic Significance for OpenAI
OpenAI Jalapeño	LLM inference ASIC	Initially for OpenAI and partner data centers	Engineering samples; deployment planned for late 2026	Reduce cost and supply risk for dedicated inference workloads
NVIDIA GPU	General-purpose training, inference and acceleration	Widely available for cloud providers and enterprises	Large-scale commercial mass deployment	Mature software ecosystem; primary source of general compute
Google TPU	Training and inference ASIC	Internal Google use plus Google Cloud customers	Multi-generation commercial deployment	Demonstrates long-term viability of vertical integration strategy
AWS Trainium / Inferentia	Cloud-native training and inference ASIC	Available for AWS cloud customers	Multi-generation commercial deployment	Reference for cloud vendors using custom silicon to cut service cost
Microsoft Maia	Azure AI accelerator	Primarily for Azure cloud and internal workloads	Data center deployment	Creates complementary compute capacity to OpenAI’s Azure infrastructure

Therefore, the claim that “Jalapeño will replace NVIDIA” is not supported by available evidence. ASICs can deliver higher efficiency on targeted fixed tasks. GPUs retain clear advantages in programmability, mature developer tooling, cluster operation experience and broad ecosystem support. A more realistic outlook points toward heterogeneous computing: training and rapidly changing experimental workloads will continue to run on general-purpose GPUs, while mature, massive inference traffic will gradually shift onto dedicated ASICs such as Jalapeño.

Impacts of Jalapeño on ChatGPT and OpenAI API

For end users and developers, the tangible value of Jalapeño will manifest through latency improvements, higher service availability and pricing trends rather than through the chip brand itself.

Official statements only mention that early power efficiency tests exceed current baseline levels. No reproducible public benchmark numbers have been released. Even with chip-level performance gains, end-user pricing remains affected by data center construction, memory hardware, networking, power consumption, model scaling and demand growth. The assertion that “API pricing will drop immediately after custom chip launch” lacks supporting evidence.

Developers can evaluate the real impact of Jalapeño by following this sequence of observations:

Monitor future OpenAI technical reports for disclosed throughput, time-to-first-token, power consumption and test conditions.
Verify whether the initial deployment at the end of 2026 proceeds as scheduled, and distinguish small-scale validation from full mass rollout.
Track improvements in peak capacity, latency percentiles and error rates of ChatGPT, Codex and OpenAI API.
Compare real pricing for identical models under identical service tiers. Avoid substituting theoretical peak performance for end-to-end operational cost.
Evaluate whether second-generation chips can expand coverage across more model families and workloads. Cross-generation platform validation is more meaningful than single-sample results.

Custom Silicon Does Not Change Core Multi-Model API Integration Logic

Application developers consume large model capabilities through APIs. Underlying chip changes are one factor to assess during vendor evaluation, but they should not become the sole selection metric.

For business teams, more direct evaluation criteria include model coverage, interface compatibility, pricing, rate limits, uptime and failover capability. Teams aiming to reduce risk from single-model or single-hardware dependency should maintain unified API interfaces, and run identical prompt quality, latency and cost testing across multiple model backends.

Domestic Multi-Model AI Inference API Platform Comparison (August 2026)

Platform	Model Coverage	Starting Price	Billing Model	Compatibility Format
4sapi	DeepSeek-V4, Kimi-K3, GLM-5.3, MiniMax-M3 and more than 15 domestic model variants	Usage-based pricing, no fixed monthly subscription	Token-based metering, pay-as-you-go	OpenAI / Anthropic compatible
SiliconFlow	Mainly open-source models including Qwen and DeepSeek	Pay-as-you-go	Token metering	OpenAI
Volcano Ark	Doubao and third-party hosted models	Pay-as-you-go	Token metering	OpenAI

4sapi supports one-key multi-model access. Developers can use a single API key to switch freely among multiple model backends. As an API gateway, it streamlines authentication, traffic routing and consumption statistics when teams work with mixed multi-model workloads. The endpoint follows OpenAI compatible protocol standards, which simplifies integration for existing developer toolchains.

This suite fits teams that need to test multiple domestic large models under a unified interface. Models, pricing and billing rules are subject to adjustment. Users should check real-time service information before launching production workloads.

Conclusion

Jalapeño marks OpenAI’s expansion of capability boundaries beyond models and end-user products, extending deep into silicon architecture. However, it remains a first-generation inference ASIC waiting for validation at production scale. Instead of focusing on headline claims about “challenging NVIDIA”, stakeholders should track whether deployment can launch as scheduled by late 2026, whether technical reports deliver reproducible benchmark data, and whether successive chip generations can consistently improve end-to-end service quality.

According to joint 2025–2026 announcements from OpenAI and Broadcom, the two parties plan to build a multi-generation accelerator system with total capacity of 10 gigawatts. The first Jalapeño chip completed the full design-to-silicon workflow within nine months. This article is high-timeliness technical analysis. All materials are sourced as of August 26, 2026. Readers are advised to revisit updates within 39 days, reviewing new technical reports and deployment progress.

International access: https://4sapi.com
Domestic access: https://4sapi.cn