DEV Community: TechLatest

LinkedIn: https://www.linkedin.com/in/techlatest-net/

Reddit Community: https://www.reddit.com/user/techlatest_net/

Kimi K3 vs. Claude Fable 5: Which AI Model Is Better for Coding and AI Agents?

TechLatest — Wed, 22 Jul 2026 10:10:37 +0000

Artificial intelligence is evolving faster than ever, and the competition between frontier proprietary models and open-weight alternatives has become more intense than at any point in the industry’s history. While companies like Anthropic and OpenAI continue to push the boundaries of closed-source AI systems, a new generation of open-weight models is rapidly narrowing the performance gap.

One of the latest entrants is Kimi K3 , Moonshot AI’s flagship large language model designed for software engineering, autonomous AI agents, long-context reasoning, and enterprise-scale applications. Shortly after its release, Kimi K3 attracted significant attention by posting competitive results across several widely used coding and agentic AI benchmarks, placing it alongside some of the industry’s strongest commercial models.

On the other side is Claude Fable 5 , Anthropic’s latest flagship reasoning model. Built for complex software development, multi-step planning, research, and enterprise AI workflows, Claude Fable 5 continues to rank among the highest-performing models in independent evaluations and remains a preferred choice for many professional developers using Claude Code.

For developers, startups, and enterprises, the question is no longer whether open-weight models are catching up — they already are. The real question is whether they now offer enough capability to replace premium proprietary models in day-to-day development.

In this comprehensive comparison, we’ll examine both models across multiple dimensions, including architecture, reasoning capabilities, coding performance, pricing, context length, latency, and real-world developer workflows. We’ll also compare official benchmark results, independent evaluations, and hands-on testing to help you determine which model best fits your projects.

Claude Fable 5 vs. Kimi K3 at a Glance

Although both models target advanced AI-assisted development, they take fundamentally different approaches.

Anthropic positions Claude Fable 5 as a premium frontier model focused on deep reasoning, software engineering, enterprise reliability, and long-running AI agents. It is available through Anthropic’s API and several major cloud platforms, offering a mature ecosystem for organizations building production AI applications.

Moonshot AI approaches the problem differently with Kimi K3. Rather than emphasizing a fully managed closed ecosystem, Kimi K3 is designed as an open-weight Mixture-of-Experts (MoE) model capable of handling large codebases, autonomous agent workflows, and million-token contexts while remaining considerably more affordable than many commercial alternatives.

While both models support modern AI development workflows, their strengths differ:

| Claude Fable 5 | Kimi K3 |
| --------------------------------------------- | ------------------------------------------------- |
| Premium proprietary reasoning model | Open-weight Mixture-of-Experts model |
| Optimized for enterprise software engineering | Optimized for coding and AI agents |
| Strong reasoning and planning capabilities | Excellent automation and terminal-based workflows |
| Mature enterprise ecosystem | Self-hosting and customization potential |
| Higher API pricing | Lower API pricing |

Rather than viewing these models as direct replacements for one another, many organizations will evaluate them based on workload requirements, deployment preferences, and infrastructure costs.

What is Claude Fable 5?

Claude Fable 5 is Anthropic’s latest flagship large language model built for advanced reasoning, software development, enterprise automation, and AI-assisted programming. It succeeds earlier Claude generations with improvements in adaptive reasoning, long-context understanding, and complex multi-step problem solving.

One of Claude Fable 5’s defining characteristics is its ability to dynamically allocate reasoning effort depending on task complexity. Simple prompts receive quick responses, while more demanding coding or analytical problems trigger deeper reasoning before generating an answer.

The model also integrates tightly with Anthropic’s growing developer ecosystem, including Claude Code, API integrations, and cloud offerings available through Amazon Bedrock, Google Cloud Vertex AI, and Microsoft Azure AI Foundry.

Key Highlights

Advanced reasoning model with adaptive thinking
Up to 1 million token context window
Strong software engineering performance
Enterprise-grade safety and reliability
Excellent long-form reasoning and planning
Native tool use and function calling
Broad cloud platform availability

Claude Fable 5 is particularly well suited for developers working on large-scale software projects, enterprise AI assistants, code reviews, debugging, technical documentation, and research-intensive workflows.

Claude Fable 5 vs. Kimi K3: Specifications

| Feature | Claude Fable 5 | Kimi K3 |
| --------------------- | ------------------------- | ----------------------------------- |
| Developer | Anthropic | Moonshot AI |
| Release | June 2026 | July 2026 |
| Model Type | Proprietary reasoning LLM | Open-weight Mixture-of-Experts |
| Parameters | Not publicly disclosed | 2.8T total parameters |
| Active Experts | N/A | 16 experts |
| Context Window | 1,000,000 tokens | 1,048,576 tokens |
| Reasoning | Adaptive reasoning | Native reasoning |
| Tool Use | Yes | Yes |
| Function Calling | Yes | Yes |
| Long Context Support | Yes | Yes |
| API Availability | Yes | Yes |
| Open Weights | No | Yes (planned/open-weight release) |
| Enterprise Deployment | Managed cloud services | API and self-hosting (with weights) |

Although both models support million-token contexts and advanced reasoning workflows, they target different deployment strategies. Claude Fable 5 focuses on fully managed enterprise services, while Kimi K3 emphasizes openness and infrastructure flexibility.

Claude Fable 5 vs. Kimi K3 Pricing

Pricing plays an important role when deploying AI models at scale, particularly for coding assistants, autonomous agents, and long-running workflows that process millions of tokens every day.

The pricing difference between these models is substantial, with Kimi K3 offering significantly lower inference costs across both input and output tokens.

| Pricing | Claude Fable 5 | Kimi K3 |
| ------------- | --------------------| --------------------|
| Input Tokens | $10.00 / Million | $3.00 / Million |
| Output Tokens | $50.00 / Million | $15.00 / Million |
| Cached Input | $1.00 / Million | $0.30 / Million |

For organizations processing large volumes of requests, Kimi K3 can reduce inference costs by roughly 70% compared to Claude Fable 5.

However, pricing should never be evaluated in isolation. Faster task completion, higher reasoning accuracy, fewer retries, and better code quality can often offset higher API costs, especially for enterprise development teams where developer productivity outweighs infrastructure expenses.

For startups, research labs, and self-hosted deployments, Kimi K3’s pricing model makes it an attractive option for large-scale AI applications. Conversely, organizations that prioritize mature tooling, enterprise support, and best-in-class reasoning may find Claude Fable 5’s premium pricing justified.

Architecture Comparison

The architectural philosophy behind these two models reflects two different visions for the future of AI.

Claude Fable 5: Adaptive Frontier Intelligence

Claude Fable 5 is built as Anthropic’s flagship proprietary reasoning model. While Anthropic has not publicly disclosed the internal architecture or parameter count, the model incorporates adaptive reasoning techniques that dynamically adjust computational effort based on the complexity of a request.

This design enables Claude Fable 5 to excel at tasks requiring deep analysis, multi-step planning, complex software engineering, and extended reasoning while maintaining strong reliability across enterprise workloads.

Kimi K3: Large-Scale Mixture-of-Experts

Kimi K3 adopts a Mixture-of-Experts (MoE) architecture, where only a subset of specialized expert networks is activated for each request instead of executing the entire model.

This approach provides several advantages:

Greater overall model capacity
Lower computational cost during inference
Improved scalability
Better efficiency for long-context processing
More cost-effective deployment at scale

The combination of a massive parameter count, selective expert activation, and open-weight availability positions Kimi K3 as one of the most ambitious open AI models released to date.

Artificial Analysis Intelligence Rankings

Artificial Analysis is one of the most widely referenced independent AI evaluation platforms. Instead of measuring performance on a single benchmark, it combines results from numerous reasoning, coding, mathematics, knowledge, and agentic evaluations into an overall Intelligence Index.

This score provides a high-level indication of a model’s general capability rather than its performance on one specific task.

At the time of writing, Claude Fable 5 remains one of the highest-ranked frontier models, while Kimi K3 has quickly established itself among the strongest open-weight alternatives.

| Model | Intelligence Index | Global Rank |
| -------------- | -----------------: | ----------: |
| Claude Fable 5 | 60 | 1 |
| Kimi K3 | 57 | 4 |

The three-point difference may appear small, but at the frontier level even minor improvements represent meaningful gains across many difficult reasoning tasks.

Unlike previous open models that often trailed significantly behind proprietary systems, Kimi K3 closes much of the gap. This makes it one of the first open-weight models capable of competing with premium commercial offerings across a broad range of evaluations.

Nevertheless, Claude Fable 5 continues to demonstrate slightly stronger overall reasoning performance, particularly on tasks requiring extended planning, logical deduction, and complex software engineering.

Coding Performance Rankings

General intelligence tells only part of the story. Developers care more about how well a model writes, understands, debugs, and refactors code.

Artificial Analysis publishes a dedicated coding score derived from multiple software engineering benchmarks.

| Model | Coding Score |
| -------------- | ----------- |
| Claude Fable 5 | 77 |
| Kimi K3 | 76 |

The one-point difference illustrates how closely matched these models have become.

For everyday programming tasks — including generating functions, debugging applications, explaining code, and implementing features — both models operate at a very similar capability level.

However, benchmark scores alone don’t reveal where each model performs better. Some evaluations reward deep reasoning, while others emphasize repository navigation, terminal interaction, or autonomous software engineering.

To understand those differences, we need to examine individual coding benchmarks.

DeepSWE: Real Software Engineering

DeepSWE evaluates a model’s ability to solve genuine software engineering issues using real-world repositories. Instead of generating isolated code snippets, models must understand an existing project, identify defects, modify relevant files, and produce working solutions.

This benchmark closely resembles the tasks developers perform every day.

| Model | DeepSWE |
| -------------- | ------- |
| Claude Fable 5 | 70.0 |
| Kimi K3 | 67.5 |

Claude Fable 5 leads by a noticeable margin.

The result suggests that Anthropic’s model remains particularly strong at understanding large codebases, tracing dependencies, and producing accurate modifications without introducing regressions.

For enterprise development involving large production repositories, DeepSWE remains one of the strongest indicators of practical coding ability.

Takeaway: Claude Fable 5 currently holds the advantage for complex repository-level software engineering.

ProgramBench

ProgramBench focuses on programming correctness rather than repository reasoning.

Models are evaluated on their ability to generate executable code that satisfies functional requirements across multiple programming languages and problem domains.

| Model | ProgramBench |
| -------------- | ----------- |
| Kimi K3 | 77.8 |
| Claude Fable 5 | 76.8 |

Here, Kimi K3 takes a slight lead.

Although the difference is relatively small, it demonstrates that Kimi K3 can generate highly accurate code solutions across diverse programming tasks.

For developers using AI primarily as a coding assistant, ProgramBench indicates that Kimi K3 performs at essentially the same level as Claude Fable 5.

FrontierSWE

FrontierSWE raises the difficulty further by evaluating software engineering tasks that require broader reasoning across complex repositories.

Unlike smaller programming benchmarks, FrontierSWE rewards planning, architectural understanding, dependency analysis, and long-term reasoning.

| Model | FrontierSWE |
| -------------- | ---------- |
| Claude Fable 5 | 86.6 |
| Kimi K3 | 81.2 |

Claude Fable 5 shows a clear advantage.

The larger gap suggests that Anthropic’s adaptive reasoning system remains particularly effective when solving challenging engineering problems involving multiple files and complex project structures.

Organizations maintaining large production systems are likely to benefit more from Claude Fable 5’s stronger architectural reasoning.

Terminal-Bench 2.1

Modern AI coding assistants increasingly operate inside terminals rather than simple chat interfaces.

Terminal-Bench measures how effectively a model interacts with command-line tools, shells, package managers, compilers, and development environments while completing programming tasks.

| Model | Terminal-Bench 2.1 |
| -------------- | ------------------ |
| Kimi K3 | 88.3 |
| Claude Fable 5 | 84.6 |

Some independent evaluations report slightly different scores for Claude Fable 5 depending on testing methodology.

Unlike static code generation benchmarks, Terminal-Bench rewards autonomous tool usage, iterative debugging, and command execution.

Kimi K3 performs particularly well in this environment, making it attractive for developers building AI coding agents capable of working directly inside development environments.

SWE Marathon

SWE Marathon measures a model’s ability to sustain performance across long-running software engineering sessions rather than isolated coding prompts.

Models must maintain context, solve multiple related tasks, and continue making progress over extended workflows.

| Model | SWE Marathon |
| -------------- | ----------- |
| Kimi K3 | 42.0 |
| Claude Fable 5 | 35.0 |

Kimi K3 demonstrates stronger consistency during prolonged engineering sessions.

This makes it particularly interesting for autonomous coding agents expected to execute long sequences of development tasks with minimal human intervention.

Overall Coding Benchmark Summary

Across the major software engineering evaluations, neither model dominates every category.

Instead, they excel in different areas.

| Benchmark | Better Performing Model |
| ------------------ | ----------------------- |
| DeepSWE | Claude Fable 5 |
| FrontierSWE | Claude Fable 5 |
| ProgramBench | Kimi K3 |
| Terminal-Bench 2.1 | Kimi K3 |
| SWE Marathon | Kimi K3 |

The results reveal a clear pattern.

Claude Fable 5 continues to perform exceptionally well on benchmarks emphasizing deep reasoning, repository understanding, and architectural software engineering.

Kimi K3, meanwhile, performs strongly on evaluations involving terminal interaction, sustained development workflows, and autonomous coding agents.

Rather than identifying an absolute winner, these benchmarks suggest that the better model depends on the type of software engineering workflow being performed.

Real-World Performance, Playground Testing, Speed, and Developer Experience

Benchmarks provide a useful starting point for comparing AI models, but they don’t always reflect how developers use these systems in practice. Building software rarely involves solving isolated programming problems. Instead, developers spend their time debugging existing applications, reviewing pull requests, understanding unfamiliar repositories, writing documentation, interacting with terminals, and coordinating multiple tools throughout the development lifecycle.

These real-world workflows place different demands on an AI model than traditional benchmark suites. Response speed, consistency, context handling, tool use, and reasoning quality often have a greater impact on productivity than a small difference in leaderboard scores.

In this section, we’ll move beyond benchmark numbers and examine how Claude Fable 5 and Kimi K3 compare in practical software engineering scenarios. We’ll also include hands-on playground testing that you can reproduce yourself using identical prompts.

Playground Testing Methodology

To evaluate both models fairly, we recommend using identical prompts, default model settings (unless otherwise specified), and independent conversations for each task. Running both models under similar conditions reduces bias and makes it easier to compare their responses.

For each prompt, evaluate the following criteria:

Accuracy of the final answer
Code correctness
Completeness of the implementation
Explanation quality
Response structure
Reasoning depth
Time to generate a response
Token usage (if available)

Unlike benchmark leaderboards, these tests simulate the types of tasks developers encounter every day.

Editor’s Note: The examples below are designed as reproducible tests. We recommend capturing screenshots of both model outputs and including them alongside your observations to provide readers with transparent, real-world comparisons.

Test 1 — Production Architecture

Design a production-ready multi-tenant SaaS CRM for 10M users.

Stack:
Next.js 15, FastAPI, PostgreSQL, Redis, Docker, Kubernetes.

Include:
- Folder structure
- Database schema
- JWT auth
- RBAC
- REST APIs
- CI/CD
- Security

Winner: Better architecture, security, completeness.

Evaluation Criteria

| Evaluation Criteria | Weight |
| ----------------------- | --------- |
| Architecture Quality | 20% |
| Security | 20% |
| Scalability | 20% |
| Completeness | 20% |
| Production Readiness | 20% |
| Total | 100% |

Claude Fable 5 Output

For the first real-world test, we asked Claude Fable 5 to design a production-ready multi-tenant SaaS CRM capable of supporting 10 million users using Next.js, FastAPI, PostgreSQL, Redis, Docker, and Kubernetes. The prompt also required the model to cover folder structure, database schema, authentication, RBAC, REST APIs, CI/CD, and security best practices.

Claude Fable 5 responded with a structured architecture overview that addressed each requested component. The response began with a clean project directory layout separating the frontend, backend, deployment configuration, scripts, and documentation. It then proposed a basic multi-tenant database schema using PostgreSQL with separate tenants, users, and contacts tables before outlining JWT-based authentication, role-based access control, REST API examples, CI/CD automation using GitHub Actions, and a Kubernetes deployment manifest.

Overall, the response was well organized and easy to follow, making it suitable as a high-level architectural blueprint for developers getting started with a SaaS CRM project.

Strengths

Well-structured response with clear sectioning.
Covers all major areas requested in the prompt, including authentication, RBAC, REST APIs, CI/CD, and deployment.
Provides practical code snippets for FastAPI routes, GitHub Actions, and Kubernetes manifests.
Uses widely adopted technologies and security recommendations such as Argon2/bcrypt, JWT authentication, HTTPS, and secret management.
Easy to understand, making it accessible for developers who want an architectural overview before implementation.

Limitations

Although the response covers the requested topics, it remains relatively high-level for a system expected to support 10 million users.

Some advanced production considerations are either missing or only briefly mentioned, including:

No discussion of database partitioning or sharding strategies for very large datasets.
Limited multi-tenant isolation beyond a simple tenant_id column; techniques such as PostgreSQL Row-Level Security (RLS) are not discussed.
JWT authentication is included, but refresh token rotation, session management, key rotation, and secure cookie strategies are absent.
Kubernetes guidance is limited to a basic deployment manifest and does not include autoscaling, rolling deployments, PodDisruptionBudgets, NetworkPolicies, or migration jobs.
CI/CD covers image build and deployment but omits automated testing, security scanning, SBOM generation, image signing, and progressive deployment strategies.
Observability is not addressed, with no mention of metrics, distributed tracing, centralized logging, or monitoring platforms.

Evaluation

| Category | Rating |
| ------------------------- | :----: |
| Architecture Design | ⭐⭐⭐⭐☆ |
| Folder Structure | ⭐⭐⭐⭐⭐ |
| Database Design | ⭐⭐⭐⭐☆ |
| Authentication & Security | ⭐⭐⭐⭐☆ |
| RBAC Design | ⭐⭐⭐⭐☆ |
| API Design | ⭐⭐⭐⭐☆ |
| Kubernetes & DevOps | ⭐⭐⭐⭐☆ |
| Production Readiness | ⭐⭐⭐⭐☆ |
| Documentation Quality | ⭐⭐⭐⭐⭐ |

Overall Score: 8.8/10

Our Verdict

Claude Fable 5 produced a solid architectural foundation that successfully addressed every requirement in the prompt while keeping the explanation concise and readable. It performs well as a blueprint for developers planning a modern SaaS application and demonstrates strong knowledge of contemporary web development practices.

However, for a workload explicitly targeting 10 million users , we expected deeper coverage of large-scale distributed systems, advanced security mechanisms, database scaling strategies, observability, and production operations. The response favors clarity over implementation depth, making it an excellent architectural overview rather than a comprehensive enterprise design.

Kimi K3 Output

Unlike Claude Fable 5, we were not able to run this architecture prompt directly on Kimi K3 during our testing because a freely accessible playground with sufficient usage limits was not available at the time of writing. Instead, we reviewed Moonshot AI’s official documentation, publicly available demonstrations, and independent evaluations to understand how Kimi K3 approaches large-scale software engineering tasks.

Based on the available examples, Kimi K3 demonstrates strong architectural reasoning and produces well-structured responses for production software projects. Public demonstrations show the model generating organized project layouts, API structures, authentication flows, database schemas, Kubernetes deployment manifests, and CI/CD workflows similar to other frontier coding models.

The model appears particularly strong at repository-level planning and implementation-oriented responses. Rather than providing extensive explanations, Kimi K3 generally focuses on delivering concise architectural designs with practical code examples that developers can build upon.

Strengths

Produces clean and organized project structures.
Demonstrates strong software engineering knowledge across modern frameworks.
Covers essential backend components such as authentication, REST APIs, RBAC, and deployment.
Well-suited for implementation-focused coding workflows.
Strong benchmark performance in software engineering evaluations such as ProgramBench, Terminal-Bench 2.1, and SWE Marathon.

Limitations

Since we were unable to execute this specific prompt directly, we cannot independently verify how Kimi K3 compares with Claude Fable 5 for this exact architecture design task.

Additionally, publicly available examples indicate several considerations:

Most architectural demonstrations remain relatively concise compared with highly detailed enterprise design documents.
Independent reviewers have noted that some benchmark claims are still awaiting broader third-party verification.
At launch, the model was primarily available through API providers, making comprehensive hands-on evaluation less accessible.
Organizations requiring self-hosting were still waiting for the promised open-weight release.

Evaluation (Based on Public Information)

| Category | Assessment |
| ------------------------- | :--------: |
| Architecture Design | ⭐⭐⭐⭐☆ |
| Folder Structure | ⭐⭐⭐⭐☆ |
| Database Design | ⭐⭐⭐⭐☆ |
| Authentication & Security | ⭐⭐⭐⭐☆ |
| API Design | ⭐⭐⭐⭐☆ |
| Kubernetes & DevOps | ⭐⭐⭐⭐☆ |
| Production Readiness | ⭐⭐⭐⭐☆ |
| Documentation Quality | ⭐⭐⭐⭐☆ |

Observations

Available public examples suggest that Kimi K3 is capable of producing production-oriented software architecture with good engineering practices while maintaining concise responses. Combined with its strong performance on coding and agentic benchmarks, it appears to be a capable model for software development tasks.

However, because we were not able to execute this prompt ourselves, we cannot make a direct, evidence-based comparison against Claude Fable 5 for this particular test. Future updates to this article will include a hands-on comparison once unrestricted access to Kimi K3 is available.

Real-World Testing: Key Takeaways

After evaluating the architecture generation capabilities and comparing them with publicly available benchmark results, several patterns become clear.

Claude Fable 5 excels at producing well-structured, detailed, and enterprise-focused architectural designs. Its responses emphasize clarity, maintainability, and production best practices, making it an excellent choice for large software projects where architectural correctness is critical.

Kimi K3, meanwhile, has established itself as one of the strongest open-weight coding models available today. Independent benchmarks show it performing exceptionally well on terminal-driven development, autonomous coding workflows, and long-running software engineering tasks. Although we were unable to execute identical prompts against Kimi K3 during this review, the available benchmark data and public demonstrations indicate that it is highly competitive with frontier proprietary models.

Ultimately, benchmark scores should not be viewed in isolation. The best model depends on the type of development work being performed, budget constraints, deployment requirements, and whether open-weight availability is an important factor.

Claude Fable 5 vs Kimi K3: Which Should You Choose?

| If you want... | Choose |
| --------------------------------- | -------------- |
| Best overall reasoning | Claude Fable 5 |
| Large-scale software architecture | Claude Fable 5 |
| Enterprise AI development | Claude Fable 5 |
| Repository-level coding | Claude Fable 5 |
| Lower API costs | Kimi K3 |
| Open-weight deployment | Kimi K3 |
| Terminal-based AI agents | Kimi K3 |
| Long-running coding workflows | Kimi K3 |

Final Verdict

Claude Fable 5 and Kimi K3 represent two different philosophies for frontier AI development. Claude Fable 5 remains one of the strongest proprietary reasoning models, delivering excellent performance across architecture design, software engineering, and complex reasoning tasks. Kimi K3, on the other hand, demonstrates how far open-weight models have progressed, offering competitive coding performance, strong agentic capabilities, and significantly lower API pricing.

If your priority is maximum reasoning capability, enterprise reliability, and mature tooling, Claude Fable 5 remains the safer choice. If lower inference costs, open-weight deployment, and strong coding performance are more important, Kimi K3 is one of the most compelling alternatives currently available.

The gap between proprietary and open-weight models is now much smaller than it was even a year ago. Rather than replacing frontier proprietary models outright, Kimi K3 shows that open-weight systems are becoming viable options for production software engineering, AI agents, and large-scale developer workflows.

Thank you so much for reading

Like | Follow | Subscribe to the newsletter.

Catch us on

LinkedIn: https://www.linkedin.com/in/techlatest-net/

HackAgent Tutorial: Secure AI Agents Against Prompt Injection, Jailbreaks, and Tool Misuse

Reddit Community: https://www.reddit.com/user/techlatest_net/

TechLatest AI & Tech Weekly #25

TechLatest — Sat, 18 Jul 2026 14:41:14 +0000

Welcome to this week’s edition of TechLatest AI & Tech Weekly 👋

Here’s a curated roundup of our latest blogs, notable product launches, and the most interesting AI & ML updates from July 13–July 18, 2026.

AI/ML News Roundup: July 13–July 18, 2026

Key highlights from this week’s AI developments include frontier model advancements with agentic capabilities, massive funding rounds reshaping valuations, and practical product launches for developers and enterprises. These updates emphasize autonomous agents, infrastructure scaling, and open-weight benchmarks relevant to builders and researchers.

TL;DR

Open-source AI had a breakout week , with major releases including Kimi K3, Inkling, Grok Build, Blume , Nemotron-3 Embed, Soofi-S 30B-A3B, and Google’s Always-On Memory Agent, driving advances in coding, retrieval, documentation, and AI agents.
Frontier AI models continued to evolve , with GPT-5.6 , Meta Muse Spark 1.1 , GPT-Live , and Gemini 3.5 Pro (expected launch) pushing reasoning, voice AI, multimodal capabilities, and enterprise agent workflows.
AI investment reached new highs , led by South Korea’s $880B national AI plan , Anthropic’s potential $1T IPO , Thinking Machines ($2B), Fireworks AI ($1.5B), Meta’s $50B infrastructure expansion , and multiple billion-dollar startup funding rounds.
Enterprise AI adoption accelerated , with Meta, NVIDIA, Cloudflare, and OpenAI launching new platforms, AI agents, cloud infrastructure, and developer tools for production deployments.
AI governance and regulation intensified , with new AI safety benchmarks, EU pre-market AI testing, copyright litigation, and growing global scrutiny of frontier AI models.
TechLatest published three hands-on guides , covering HackAgent for securing AI agents, Grok Build for mastering xAI’s open-source coding agent, and a complete comparison of GPT-5.6 Sol, Terra, and Luna to help developers choose the right model for their workloads.

Open-Source AI, AI Agents, Voice AI & Developer Releases

Thinking Machines Lab Releases Inkling

Thinking Machines Lab unveiled Inkling , a 975B-parameter multimodal Mixture-of-Experts model with 41B active parameters , introducing controllable thinking effort for balancing reasoning quality and inference cost. Source

NVIDIA Releases Nemotron-3 Embed

NVIDIA introduced Nemotron-3 Embed , an open embedding model collection whose 8B checkpoint ranks #1 on the RTEB benchmark , delivering state-of-the-art retrieval and semantic search performance. Source

Zyphra Releases Zuna1.1

Zyphra unveiled Zuna1.1 , an Apache 2.0 EEG foundation model that supports variable-length brain signal inputs ranging from 0.5 to 30 seconds , enabling more flexible neuroscience and BCI research. Source

Soofi-S 30B-A3B Released

The Soofi Consortium introduced Soofi-S 30B-A3B , an open hybrid Mamba-Transformer MoE foundation model optimized for German and English , delivering efficient multilingual reasoning with Apache 2.0 licensing. Source

Meet Blume

Blume is an open-source, zero-configuration documentation framework that transforms a simple Markdown folder into a modern, AI-ready documentation website. Designed for developers, it automatically generates searchable docs with minimal setup. Source

SpaceXAI Open-Sources Grok Build

SpaceXAI open-sourced Grok Build , the Rust-based agent framework behind its coding CLI. The project includes the agent runtime, TUI, tool layer, and workspace orchestration , enabling developers to build and customize AI coding agents. Source

Google Cloud Introduces Always-On Memory Agent

Google Cloud introduced the Always-On Memory Agent , a new memory architecture that continuously consolidates knowledge using Gemini 3.1 Flash Lite , reducing reliance on traditional RAG pipelines and vector embeddings. Source

Gemini 3.5 Pro Expected to Launch

Google is expected to launch Gemini 3.5 Pro after rebuilding the model from scratch to improve recursive tool calling and long-context reasoning. Source

Moonshot AI Releases Kimi K3

Moonshot AI introduced Kimi K3 , a 2.8-trillion-parameter open-weight Mixture-of-Experts model, making it one of the largest open AI models ever released. Source

NotebookLM Becomes Gemini Notebook

Google rebranded NotebookLM as Gemini Notebook , adding cloud-based code execution and tighter Gemini integration. Source

DeepSeek V4 Stable Release Nears

DeepSeek announced that the stable version of DeepSeek V4 is approaching release. Source

Kimi K3 Tops Coding Benchmarks

Moonshot AI’s Kimi K3 quickly became the top-ranked model on coding leaderboards, strengthening the position of open-weight AI models. Source

Suno Data Breach Reveals Training Methods

A security breach at Suno exposed source code and details about AI music training datasets. Source

Google Expands AI Mode in Search

Google expanded AI Mode with integrations across services like Instacart, Canva, and YouTube Music. Source

Open-Weight AI Gains Momentum

The week’s biggest trend was the rapid rise of open-weight AI models , with Kimi K3, Inkling, and DeepSeek challenging proprietary frontier models.

Frontier Model Launches & Agentic Capabilities

OpenAI launched the GPT-5.6 family (Sol, Terra, Luna) on July 13, 2026 — the first major AI model release after full US government approval, with models now integrated into Microsoft 365 Copilot products like Word and Excel.
OpenAI released GPT-Live on July 13, 2026, a full-duplex voice AI that listens, speaks, and reasons simultaneously instead of taking turns, enabling real-time translation and live web search mid-conversation without awkward pauses.
Meta released Muse Spark 1.1 on July 13, 2026, a purpose-built model for autonomous agents and software development, capable of coordinating multiple sub-agents and running extended multi-step tasks at competitive pricing.
Google and Microsoft backed a rival agent protocol on July 13, 2026, with Google, Microsoft, Salesforce, Snowflake, and ServiceNow agreeing to support a shared AI backend-software protocol explicitly framed as beating back Anthropic and OpenAI in the enterprise.
Anthropic launched Claude Corps on July 13, 2026, a paid 12-month fellowship training early-career professionals as AI professionals inside nonprofit organizations, with no degree required and broad eligibility for applicants with up to two years of work experience.
Anthropic expanded Project Glasswing on July 13, 2026, from 50 to 150 organizations across 15 countries, deploying Claude Mythos to find and fix vulnerabilities in critical infrastructure, including utilities, hospitals, and financial systems.

Massive Funding & Valuations

South Korea committed $880 billion to AI over the next decade on July 15, 2026, with President Lee Jae-myung unveiling a 1,350 trillion won plan including $518 billion for memory chip manufacturing, $550 billion for AI data centers, and a target of 8.4 gigawatts of data center capacity by 2029.
Helsing raised €1.8 billion at an €18 billion valuation on July 15, 2026, cementing its status as Europe’s most valuable defense-tech startup and one of the largest AI funding rounds of the year outside the US frontier labs.
Blackstone, Apollo, and KKR backed a $5.34 billion data-center power deal on July 15, 2026, providing funding for behind-the-meter power generation to solve the electricity bottleneck throttling AI expansion.
QuantumDiamonds and Qolab raised funding on July 15, 2026 — QuantumDiamonds €91 million for quantum chip inspection and Qolab $54.2 million for superconducting quantum processors, targeting the quantum-AI intersection.
US startups raised $412.7 billion in the first half of 2026, with 86% ($355.9 billion) going to AI companies — the most extreme concentration the venture industry has ever recorded.
Anthropic confidentially filed for an IPO that could value the company at over $1 trillion , reflecting strong enterprise AI growth.
Anthropic is reportedly in talks with Meta for a $10 billion AI compute partnership to secure additional infrastructure capacity.
Thinking Machines (Mira Murati) reportedly raised a $2 billion seed round while launching its open-weight Inkling model.
DeepSeek is seeking to raise funding at a $74 billion valuation , preparing for a future Shanghai IPO.
Fireworks AI raised $1.5 billion at a $17.5 billion valuation to expand AI inference infrastructure.
Meta committed $50 billion toward a Louisiana AI data center project, with long-term infrastructure investment expected to exceed $250 billion.
Neko Health raised $700 million in Series C funding at a valuation of approximately $7 billion to expand its AI-powered preventive healthcare platform.
Emergent , an Indian AI startup, raised $130 million in Series C funding at a $1.5 billion valuation , becoming a unicorn.
Humanoid Robotics attracted major investment:

Humanoid raised $150 million at a $1.2 billion valuation.

Walden Robotics raised $300 million.

Microagi secured a $55 million seed round.

Asian AI venture funding reached a multi-year high , signaling continued global investor confidence in AI startups.

Practical Product Launches for Developers & Enterprises

Meta launched the Meta Business Agent Platform globally on July 15, 2026, giving enterprises infrastructure to build, customize, and deploy AI agents at scale, alongside the Meta Compute cloud business selling the company’s excess AI infrastructure to outside customers.
NVIDIA and ServiceNow launched Project Arc on July 15, 2026, a self-evolving desktop agent built for knowledge workers, running on NVIDIA’s OpenShell secure runtime and powered by NVIDIA accelerated computing with open Nemotron models.
Cloudflare opened a waitlist for x402 Agent-Payments Gateway on July 13, 2026, an infrastructure built on the x402 protocol that lets websites, APIs, datasets, and digital services charge AI agents instantly for access.
GPT Image 2 and Aleph 2.0 workflow launched July 13, 2026, letting editors modify a single reference frame and have changes propagate across an entire video, collapsing shot-by-shot VFX work into an image edit plus propagation pass.
OpenAI’s Deployment Company acquired Northslope on July 13, 2026, adding forward-deployed engineering capacity to build AI systems inside customer organizations around their actual operations.

Governance, Ethics & Regulation

The Future of Life Institute released its 2026 AI Safety Index on July 15, 2026, with Anthropic scoring highest at C+, OpenAI and Google DeepMind at C, Meta at D+, and xAI, DeepSeek, and Mistral effectively failing the assessment.
The EU announced pre-market AI model testing with ENISA on July 15, 2026, planning a secure testing platform for critical sectors by the end of 2026, requiring frontier models to be evaluated for safety and security risks before deployment in sensitive areas.
The New York Times sought sanctions against OpenAI on July 15, 2026, alleging the company withheld training-data evidence in the ongoing copyright lawsuit over whether OpenAI illegally used journalism to train its models.
The ECB warned AI could make inflation more volatile on July 13, 2026, with a European Central Bank policymaker stating AI adoption could increase inflation volatility, complicating central banks’ ability to steer prices.
Goldman Sachs told clients which Chinese AI models to use on July 13, 2026, publishing an analysis recommending specific Chinese AI models to clients, marking a milestone in the normalization of Chinese open-weight models in Western enterprise stacks.

Infrastructure & Hardware

Intel announced a €5 billion semiconductor expansion in Ireland on July 15, 2026, adding to global chip-manufacturing buildout spanning Terafab in Texas, Samsung’s accelerated Korean plants, and TSMC’s record-driven capacity growth.
Mews cut 15% of staff (170 of 1,350 roles) on July 15, 2026, explicitly attributing the reduction to AI efficiency, saying individuals can now own end-to-end work that previously required teams.
Data center backlash grew during July 13–18, 2026, with opposition movements against data center expansion spreading across the US as communities push back on power demand, water use, and land footprint of the AI buildout.

Blogs We Published This Week

HackAgent Tutorial: Secure AI Agents Against Prompt Injection, Jailbreaks & Tool Misuse

A complete guide to HackAgent , covering installation, configuration, and practical techniques to protect AI agents against prompt injection, jailbreak attacks, goal hijacking, and unsafe tool execution. Learn how to test and harden production AI agents with hands-on examples.

Grok Build Tutorial: Install, Configure & Master xAI’s Open-Source AI Coding Agent

A comprehensive tutorial on Grok Build , the open-source Rust-based AI coding agent from xAI. Learn installation, architecture, TUI, tool layer, workspace management, and how to build AI-powered development workflows.

Grok Build Tutorial: Install, Configure, and Master xAI’s Open-Source AI Coding Agent

GPT-5.6 Models Explained: Sol vs Terra vs Luna

An in-depth guide comparing the GPT-5.6 model family, including Sol , Terra , and Luna. Understand their architecture, benchmarks, pricing, context windows, tool-calling capabilities, and which model is best for coding, AI agents, reasoning, and enterprise workloads.

GPT-5.6 Models Explained: Sol vs Terra vs Luna, Pro Models, Features & Which One Should You Choose?

Thank you so much for reading

Like | Follow | Subscribe to the newsletter.

Catch us on

LinkedIn: https://www.linkedin.com/in/techlatest-net/

Reddit Community: https://www.reddit.com/user/techlatest_net/

GPT-5.6 Models Explained: Sol vs Terra vs Luna, Pro Models, Features & Which One Should You Choose?

TechLatest — Fri, 17 Jul 2026 10:53:10 +0000

Learn everything about the GPT-5.6 model family, including Sol, Terra, Luna, Pro variants, benchmarks, pricing, API integration, coding performance, AI agents, and how to choose the right model for your applications.

Introduction

Artificial intelligence models are evolving rapidly, but choosing the right one has become increasingly complex. Earlier GPT releases typically introduced a single flagship model that developers used for nearly every workload. With GPT-5.6, OpenAI has taken a different approach.

Instead of offering one model for everything, GPT-5.6 introduces a family of models designed for different priorities. Some applications need the highest possible reasoning quality, while others prioritize response speed, operational cost, or the ability to serve millions of users efficiently. Rather than forcing every workload onto the same model, OpenAI now provides multiple capability tiers.

The GPT-5.6 lineup consists of three primary models:

GPT-5.6 Sol — the flagship model focused on maximum intelligence and advanced reasoning.
GPT-5.6 Terra — a balanced model that combines strong capability with lower latency and cost.
GPT-5.6 Luna — the fastest and most affordable model, optimized for large-scale deployments.

Each tier also includes a Pro variant that dedicates additional compute to difficult tasks, enabling deeper reasoning, improved planning, and higher-quality outputs for complex engineering, research, and enterprise workflows.

This modular strategy gives developers significantly more flexibility than previous GPT generations. Whether you’re building autonomous AI agents, enterprise copilots, customer support platforms, coding assistants, or document automation systems, there’s now a model optimized for your workload instead of relying on a single “one-size-fits-all” solution.

In this guide, we’ll explore every GPT-5.6 model, compare their capabilities, explain benchmark results, discuss pricing, demonstrate API usage, and help you determine which model best fits your application.

What You’ll Learn

By the end of this guide, you’ll understand:

What GPT-5.6 is and what’s new
The differences between Sol, Terra, and Luna
How Pro models differ from standard models
Which GPT-5.6 model is best for coding, research, and production
GPT-5.6 benchmark performance
Pricing and API availability
How GPT-5.6 improves AI agents and tool calling
Best practices for choosing the right model

GPT-5.6 Family Overview

One of the biggest changes in GPT-5.6 is that OpenAI has shifted from releasing a single flagship model to offering an entire family of models. Each member of the GPT-5.6 lineup is designed around a different balance of intelligence, speed, and operational cost, allowing developers to choose the model that best matches their workload.

Rather than asking developers to compromise between quality and efficiency, GPT-5.6 lets them optimize for what matters most. A research assistant may require the strongest reasoning available, while a customer support chatbot benefits more from fast responses and low operating costs. The GPT-5.6 family addresses both scenarios without forcing them onto the same model.

The lineup is organized into three capability tiers:

| Model | Primary Focus | Best For |
| ----------------- | ----------------------- | ---------------------------------------------- |
| GPT-5.6 Sol | Maximum intelligence | Advanced coding, research, AI agents |
| GPT-5.6 Terra | Balanced performance | Production applications, enterprise assistants |
| GPT-5.6 Luna | Speed and affordability | Chatbots, automation, large-scale deployments |

Each of these models is also available in a Pro configuration, giving users the option to allocate additional compute for deeper reasoning on more complex tasks.

GPT-5.6 Family Architecture

Understanding the Three Capability Tiers

GPT-5.6 Sol

Sol is the flagship model in the GPT-5.6 family. It is designed for workloads where output quality and reasoning depth are the highest priorities. Sol excels at complex software engineering, scientific analysis, enterprise decision-making, cybersecurity workflows, and long-running AI agent tasks.

GPT-5.6 Terra

Terra represents the middle ground between intelligence and efficiency. It offers strong reasoning while reducing latency and operational cost, making it an excellent default choice for production APIs, SaaS platforms, enterprise copilots, and workflow automation.

GPT-5.6 Luna

Luna is optimized for speed and affordability. It targets high-volume workloads where fast responses and low inference costs matter more than maximum reasoning depth. Typical use cases include customer support, AI chatbots, summarization, content generation, and productivity assistants.

What Do the Pro Models Offer?

Every capability tier also includes a Pro variant. Rather than introducing an entirely separate model, the Pro configuration allows GPT-5.6 to spend additional compute on planning, reasoning, verification, and refinement before generating its final answer.

This additional reasoning is particularly useful for:

Large-scale software engineering
Multi-step debugging
Scientific research
Financial analysis
Long-form document generation
Enterprise planning
Autonomous AI agents

The trade-off is increased inference time and compute usage, making Pro models most suitable for workloads where output quality is more important than response speed.

Why Did OpenAI Introduce Sol, Terra, and Luna?

AI applications have become incredibly diverse. A coding agent working through a complex repository has very different requirements from a customer support chatbot handling thousands of requests every minute. Similarly, an enterprise research assistant analyzing financial reports needs stronger reasoning than an AI summarization tool.

Instead of optimizing one model for every possible scenario, OpenAI introduced three capability tiers that allow developers to select the most appropriate balance of intelligence, latency, and cost.

Sol is designed for maximum reasoning and quality.
Terra balances capability with operational efficiency.
Luna focuses on affordability and high-throughput deployment.

This tiered approach gives teams more control over infrastructure costs. Developers can use Luna for routine interactions, Terra for production applications, and reserve Sol for the most demanding reasoning tasks. The result is a more flexible AI platform that can scale from lightweight chatbots to enterprise-grade autonomous agents.

Choosing the Right GPT-5.6 Model

GPT-5.6 Family at a Glance

                    GPT-5.6 Family

        ┌────────────┬────────────┬────────────┐
        │ │ │
      Sol Terra Luna
        │ │ │
    Sol Pro Terra Pro Luna Pro
        │ │ │
 Maximum AI Balanced AI Fast & Affordable
        │ │ │
 Research Enterprise Chatbots
 Coding Production Automation
 AI Agents APIs High Throughput

GPT-5.6 Models Comparison: Sol vs Terra vs Luna

One of the biggest advantages of the GPT-5.6 family is that developers are no longer limited to a single model. Instead, OpenAI provides multiple capability tiers, allowing you to optimize for intelligence, response speed, operational cost, or reasoning quality depending on your workload.

While every GPT-5.6 model is built on the same generation of technology, they are optimized for different goals. Sol prioritizes maximum intelligence, Terra balances performance with efficiency, and Luna focuses on speed and affordability. Their Pro variants extend these capabilities by allocating additional compute to reasoning-intensive tasks.

Rather than asking “Which GPT-5.6 model is the best?”, a better question is:

Which GPT-5.6 model is the best for my workload?

This section compares all six models to help answer that question.

GPT-5.6 Model Comparison

| Feature | Sol | Sol Pro | Terra | Terra Pro | Luna | Luna Pro |
| ------------ | ----------------- | ------------------------ | ------------- | -------------------- | -------- | ------------------------- |
| Intelligence | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ |
| Reasoning | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ |
| Coding | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐ |
| Speed | ⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
| Cost | High | Highest | Medium | Medium-High | Lowest | Low |
| Best For | Research & Coding | Critical Enterprise Work | Production AI | Enterprise Workflows | Chatbots | Automation & Productivity |

GPT-5.6 Sol

GPT-5.6 Sol is OpenAI’s flagship model and the most capable member of the GPT-5.6 family. It is designed for problems where reasoning quality matters more than latency or cost.

Its strengths include:

Advanced software engineering
Long-form reasoning
Scientific research
Cybersecurity workflows
Financial analysis
AI coding agents
Complex multi-step planning

If you’re building autonomous coding agents, analyzing large codebases, or solving complex engineering problems, Sol is the strongest choice.

Best suited for:

Software engineers
AI researchers
Enterprise AI teams
Security engineers
Scientific computing

GPT-5.6 Terra

GPT-5.6 Terra is designed as the balanced model within the GPT-5.6 family. It delivers strong reasoning while reducing inference cost and response time, making it an excellent default option for production deployments.

Unlike Sol, Terra focuses on delivering consistent performance across a wide range of business applications rather than maximizing reasoning depth.

Typical use cases include:

Enterprise copilots
Internal knowledge assistants
SaaS platforms
Workflow automation
Business intelligence
Document processing

For many production systems, Terra offers the best balance between capability, scalability, and cost.

GPT-5.6 Luna

GPT-5.6 Luna is optimized for speed and affordability. It is intended for applications that process large volumes of requests where response time and infrastructure cost are the primary considerations.

Although Luna doesn’t provide the same reasoning depth as Sol, it remains highly capable for everyday AI tasks.

Common workloads include:

Customer support
AI chatbots
FAQ systems
Email drafting
Content generation
Summarization
AI-powered search

Organizations serving millions of users can significantly reduce inference costs by deploying Luna for routine interactions while reserving Sol or Terra for more demanding tasks.

Understanding Pro Models

Every capability tier also includes a Pro variant. These are not entirely different base models; instead, they are optimized to dedicate additional compute to difficult problems.

Compared with the standard models, Pro variants spend more time:

Planning complex solutions
Exploring alternative approaches
Verifying intermediate steps
Reviewing generated code
Refining final outputs

This additional reasoning often results in better performance for coding, research, engineering, and enterprise analysis, but it generally comes with higher latency and compute costs.

Standard vs Pro

When should you use a Pro model?

Choose a Pro model when:

You’re solving complex engineering problems.
Code quality is more important than speed.
You need reliable multi-step reasoning.
You’re performing research or technical analysis.
The additional latency is acceptable.

For interactive chat applications, standard models are often sufficient.

Which GPT-5.6 Model Should You Choose?

Choosing the right model depends on the type of application you’re building rather than simply selecting the most powerful option.

Recommended Models by Use Case

| Use Case | Recommended Model |
| ---------------------------- | ------------------- |
| AI Coding Agent | ⭐ GPT-5.6 Sol |
| Full-Stack Development | ⭐ GPT-5.6 Sol |
| Scientific Research | ⭐ GPT-5.6 Sol Pro |
| Cybersecurity Analysis | ⭐ GPT-5.6 Sol |
| Enterprise Copilot | ⭐ GPT-5.6 Terra Pro |
| Internal Knowledge Assistant | ⭐ GPT-5.6 Terra |
| SaaS Product | ⭐ GPT-5.6 Terra |
| Customer Support | ⭐ GPT-5.6 Luna |
| AI Chatbot | ⭐ GPT-5.6 Luna |
| Marketing Content | ⭐ GPT-5.6 Luna |
| Productivity Assistant | ⭐ GPT-5.6 Luna Pro |
| Large-Scale Automation | ⭐ GPT-5.6 Luna Pro |

Conclusion

GPT-5.6 represents more than just another incremental AI model release. Instead of relying on a single flagship model, OpenAI has introduced a flexible model family that enables developers to choose the right balance of intelligence, performance, and cost for their specific workloads.

Throughout this guide, we’ve explored how the GPT-5.6 lineup is organized into three capability tiers — Sol , Terra , and Luna — along with their Pro variants. Each model is designed with a different goal in mind, whether it’s maximum reasoning for complex engineering tasks, balanced performance for production applications, or cost-efficient inference for high-volume deployments.

Rather than asking “Which GPT-5.6 model is the most powerful?”, the better question is “Which model is the best fit for my application?” For advanced coding, research, and AI agents, GPT-5.6 Sol is the strongest choice. If you’re deploying production workloads at scale, GPT-5.6 Terra offers an excellent balance of capability and efficiency. For chatbots, customer support, and automation, GPT-5.6 Luna provides fast responses while keeping operational costs low.

The introduction of Pro variants gives developers even more flexibility by providing deeper reasoning for demanding workloads without requiring an entirely different model family.

This modular approach makes GPT-5.6 one of OpenAI’s most versatile model releases to date, allowing teams to build AI systems that are both powerful and cost-effective.

Thank you so much for reading

Like | Follow | Subscribe to the newsletter.

Catch us on

LinkedIn: https://www.linkedin.com/in/techlatest-net/

Techlatest.net - GPU Supported DeepSeek & Llama powered All-in-One LLM

Reddit Community: https://www.reddit.com/user/techlatest_net/

Grok Build Tutorial: Install, Configure, and Master xAI’s Open-Source AI Coding Agent

TechLatest — Thu, 16 Jul 2026 08:25:00 +0000

AI coding assistants have evolved far beyond simple autocomplete tools. Today’s developer agents can understand entire repositories, edit files across multiple folders, execute terminal commands, browse documentation, search the web, and even automate complex development workflows.

One of the latest entrants into this space is Grok Build , the terminal-based AI coding agent developed by xAI. Unlike traditional chat interfaces, Grok Build operates directly inside your terminal through a modern full-screen Text User Interface (TUI), allowing developers to work with AI without leaving their coding environment.

Whether you’re debugging production issues, refactoring legacy code, generating documentation, or building entirely new applications, Grok Build combines repository awareness, shell execution, intelligent code editing, and automation into a single developer experience.

Even better, xAI has open-sourced the project, allowing developers to inspect the Rust codebase, build it from source, and understand how the agent works under the hood.

In this tutorial, you’ll learn:

What is Grok Build
How its architecture works
Installing it on macOS, Linux, and Windows
Authenticating and starting your first session
Building it from source
Understanding the repository layout
Practical coding examples
Advanced features like MCP, ACP, and headless mode
Real-world developer workflows

By the end of this guide, you’ll have everything you need to start using Grok Build effectively in your daily development workflow.

What is Grok Build?

AI coding assistants have rapidly evolved from simple code completion tools into intelligent software engineering agents capable of understanding entire projects, executing commands, and automating complex development tasks. Grok Build is xAI’s answer to this evolution.

Grok Build is an open-source terminal-based AI coding agent that runs directly inside your terminal through a full-screen Text User Interface (TUI). Instead of acting as a chatbot that only responds to prompts, it functions as an AI teammate capable of understanding your codebase, editing files, running shell commands, searching the web, analyzing repositories, and assisting with long-running development tasks.

Unlike browser-based AI assistants, Grok Build keeps developers in their preferred environment — the terminal. This allows you to interact with your project naturally without constantly switching between editors, browsers, and chat applications.

At its core, Grok Build combines several capabilities into a single developer experience:

Repository Awareness: Understands the structure of your entire project instead of just a single file.
Code Editing: Creates, modifies, and refactors source code across multiple files.
Terminal Execution: Runs shell commands, scripts, and build tools directly from the interface.
Web Search: Retrieves documentation, package information, and external resources when needed.
Task Automation : Handles long-running development workflows with minimal manual intervention.
Headless Mode: Runs non-interactively for automation, scripting, and CI/CD pipelines.
ACP Support: Integrates with editors and external tools through the Agent Client Protocol.
MCP Integration: Connects to external tools and services using the Model Context Protocol.

Because the project is written in Rust , Grok Build delivers a fast, responsive, and cross-platform experience while maintaining strong performance even on large repositories.

Today, developers can use Grok Build for tasks such as generating new features, fixing bugs, refactoring legacy applications, reviewing pull requests, writing documentation, debugging production issues, and automating repetitive engineering workflows — all without leaving the terminal.

What Makes Grok Build Different?

Many AI coding tools focus primarily on generating code snippets or answering programming questions. Grok Build goes a step further by acting as an AI software engineering agent rather than just an AI assistant.

Instead of simply suggesting code, it can:

Explore your project’s directory structure
Read and understand multiple files simultaneously
Execute terminal commands
Modify existing code safely
Search online documentation
Work with external tools using MCP
Automate development workflows in both interactive and headless environments

This makes Grok Build particularly useful for developers working on large, multi-file projects where understanding context is just as important as generating code.

Why Grok Build Matters

Software development has changed dramatically over the past few years. AI assistants are no longer limited to generating code snippets or answering programming questions — they are becoming capable software engineering agents that can understand entire repositories, execute terminal commands, automate repetitive tasks, and assist throughout the development lifecycle.

This shift has led to the rise of terminal-native AI coding agents , allowing developers to stay in their preferred environment instead of constantly switching between an IDE, browser, documentation, and chat applications.

Grok Build is xAI’s contribution to this new generation of developer tools. Rather than focusing solely on code generation, it combines repository awareness, intelligent file editing, shell execution, web search, and workflow automation into a single terminal-based experience.

One of the biggest reasons Grok Build has attracted attention is that xAI has open-sourced the project. Developers can inspect the Rust codebase, understand how the agent works internally, build it from source, and learn from its architecture. This transparency also allows the community to study modern AI agent design and evaluate how the tool interacts with repositories, files, and external systems.

As software projects continue to grow in complexity, developers need tools that understand context across multiple files instead of just the current editor window. Grok Build is designed with that broader perspective, helping developers work more efficiently on large codebases and long-running engineering tasks.

Why Developers Are Using AI Coding Agents

Modern AI coding agents can assist with far more than writing code. They help reduce repetitive work and speed up common development tasks, including:

Creating new features from natural language prompts
Refactoring large codebases
Debugging application errors
Running build and test commands
Explaining unfamiliar code
Generating documentation
Reviewing pull requests
Searching official documentation without leaving the terminal
Automating repetitive engineering workflows

Instead of acting as a replacement for developers, these tools function more like collaborative engineering assistants that can handle routine tasks while developers focus on architecture, design, and problem-solving.

Why Grok Build Stands Out

Several AI coding agents are available today, but Grok Build differentiates itself through its combination of terminal-first workflows, open-source availability, and deep integration with developer tooling.

Some of its notable strengths include:

A full-screen Text User Interface (TUI) designed for terminal workflows
Built with Rust for performance and reliability
Repository-aware code understanding
Interactive and headless execution modes
Support for shell commands, file editing, and web search
Integration with MCP servers for extending capabilities
Agent Client Protocol (ACP) support for editor integration
Cross-platform support for macOS, Linux, and Windows

These capabilities make Grok Build suitable for individual developers, open-source contributors, DevOps engineers, platform teams, and organizations looking to incorporate AI into their software development workflow.

Key Features of Grok Build

Grok Build is much more than an AI chatbot running inside a terminal. It combines intelligent code understanding, repository awareness, terminal automation, and developer tooling into a single workflow. Whether you’re building a new application, debugging production issues, or automating repetitive tasks, Grok Build is designed to assist throughout the software development lifecycle.

Let’s explore some of its most notable features.

1. Full-Screen Terminal User Interface (TUI)

One of Grok Build’s defining features is its modern Text User Interface (TUI). Instead of opening a browser or switching between multiple applications, developers can interact with the AI directly from the terminal.

The interface provides a clean workspace where you can:

Chat with the AI
Review generated code
View command outputs
Navigate conversations
Inspect file changes
Manage long-running tasks

Because everything happens inside the terminal, developers can remain focused without constantly changing contexts.

Why it matters: A terminal-first workflow reduces distractions and integrates naturally with existing development environments.

2. Repository-Aware Code Understanding

Unlike traditional AI assistants that only see the code you paste into a chat window, Grok Build understands your project’s overall structure.

It can analyze:

Multiple directories
Source files
Configuration files
Dependencies
Documentation
Project architecture

This broader understanding enables the AI to generate suggestions that are more accurate and contextually relevant.

For example, instead of modifying a single file in isolation, Grok Build can update related files, imports, configurations, and documentation as part of the same task.

3. Intelligent Code Editing

Grok Build can create new files, edit existing code, refactor functions, and apply changes across multiple parts of a project.

Common tasks include:

Creating new components
Refactoring legacy code
Fixing bugs
Updating APIs
Renaming variables
Improving code readability
Generating tests
Writing documentation

Because it understands repository context, the generated changes are generally more consistent across the project.

4. Built-in Shell Command Execution

Developers frequently switch between an editor and the terminal to run commands. Grok Build removes much of that friction by executing shell commands directly within the interface.

Examples include:

npm install
npm test
cargo build
git status
docker compose up
python manage.py migrate

This enables developers to ask the AI to perform development tasks without manually typing every command.

For example:

“Run the test suite and fix any failing tests.”

“Build the project and explain any compiler errors.”

The AI can execute commands, inspect the output, and suggest fixes based on the results.

5. Web Search Integration

Software development often requires consulting documentation, release notes, or framework guides.

Grok Build includes web search capabilities that allow it to retrieve relevant information without requiring developers to leave the terminal.

This is particularly useful for:

API documentation
Framework updates
Library installation guides
Error messages
Programming references
Package versions

Instead of opening multiple browser tabs, developers can keep their workflow centralized within the terminal.

6. Long-Running Task Management

Certain development workflows take several minutes — or even hours — to complete. Grok Build is designed to manage these longer processes efficiently.

Examples include:

Building large applications
Running extensive test suites
Dependency installation
Repository indexing
Code generation
Infrastructure provisioning

Rather than blocking the interface, Grok Build helps track these tasks while allowing developers to continue working.

7. Headless Mode for Automation

Not every workflow requires an interactive interface. Grok Build also supports headless mode , making it suitable for automation and scripting.

This enables developers to integrate AI into:

CI/CD pipelines
GitHub Actions
Build systems
Deployment scripts
Automated code reviews
Batch processing

Headless execution allows organizations to incorporate AI into existing engineering workflows without requiring manual interaction.

8. Agent Client Protocol (ACP) Support

Grok Build supports the Agent Client Protocol (ACP), allowing it to communicate with compatible development tools and editors.

This makes it possible to use Grok Build beyond the standalone terminal application, enabling integrations with external clients that understand the ACP standard.

For teams building AI-powered developer experiences, ACP provides a standardized way to connect coding agents with development environments.

9. Model Context Protocol (MCP) Integration

Modern AI agents become significantly more useful when they can access external tools and services.

Grok Build supports the Model Context Protocol (MCP), enabling connections to external resources such as:

Databases
Documentation systems
Version control platforms
Internal developer tools
APIs
Cloud services
Custom enterprise integrations

Instead of relying solely on local repository information, MCP allows Grok Build to retrieve additional context and perform more capable workflows.

10. Built with Rust

Performance is a key consideration for terminal applications, especially when working with large repositories.

Grok Build is written in Rust , providing several advantages:

High performance
Low memory usage
Cross-platform compatibility
Reliability
Strong safety guarantees

Rust’s focus on performance and memory safety makes it well suited for building responsive developer tools that can scale to complex projects.

11. Cross-Platform Support

Grok Build is available for all major desktop operating systems, making it accessible to a wide range of developers.

Supported platforms include:

macOS
Linux
Windows (best-effort support when building from source)

Prebuilt binaries are available for the primary operating systems, allowing developers to get started quickly without compiling the project manually.

Feature Summary

| Feature | Description |
| -------------------- | --------------------------------------------------- |
| Terminal UI (TUI) | Interactive full-screen coding experience |
| Repository Awareness | Understands the entire project structure |
| Intelligent Editing | Creates and modifies code across multiple files |
| Shell Execution | Runs terminal commands directly |
| Web Search | Retrieves documentation and programming resources |
| Long-Running Tasks | Manages builds, tests, and automation workflows |
| Headless Mode | Suitable for scripting and CI/CD pipelines |
| ACP Support | Integrates with compatible editors and clients |
| MCP Integration | Connects to external tools and services |
| Rust-Based | Fast, reliable, and memory-efficient implementation |
| Cross-Platform | Supports macOS, Linux, and Windows |

With its combination of repository awareness, intelligent code editing, terminal automation, and extensibility through ACP and MCP, Grok Build goes beyond traditional AI code assistants. It serves as a comprehensive development companion capable of assisting throughout the entire software engineering workflow.

How Grok Build Works

One of the biggest advantages of Grok Build is that it isn’t just an AI chatbot running inside a terminal. Instead, it follows a modular architecture where different components work together to understand your project, execute commands, interact with external services, and generate intelligent responses.

When you enter a prompt, Grok Build doesn’t simply send it to an AI model. It first determines what information is needed, what tools should be used, and which actions can be safely performed before generating a response.

The workflow looks something like this:

                    ┌──────────────────────┐
                    │ Developer │
                    │ (You) │
                    └──────────┬───────────┘
                               │
                               ▼
                    ┌──────────────────────┐
                    │ Grok Build TUI │
                    │ (Terminal Interface) │
                    └──────────┬───────────┘
                               │
                               ▼
                 ┌─────────────────────────────┐
                 │ Agent Runtime │
                 │ Prompt Planning & Reasoning │
                 └──────────┬──────────────────┘
                            │
          ┌─────────────────┼─────────────────┐
          ▼ ▼ ▼
 ┌────────────────┐ ┌────────────────┐ ┌────────────────┐
 │ Tool Layer │ │ Workspace │ │ AI Model │
 │ │ │ Layer │ │ │
 └───────┬────────┘ └──────┬─────────┘ └────────────────┘
          │ │
          │ │
   ┌──────┼──────────────┐ │
   ▼ ▼ ▼ ▼ ▼
Terminal Files Git Web Search
Commands Edit Documentation
          │
          ▼
     MCP Servers
(Custom Tools,
 APIs, Databases)

Step 1: Enter a Prompt

Every workflow begins with a natural language request inside the Grok Build interface.

For example:

Find why authentication tests are failing and fix the issue.

Create a REST API for user management using Rust.

Instead of immediately generating text, Grok Build first analyzes what actions are required to complete the request.

For simple questions, it may only need the AI model.

For more complex tasks, it may need to:

Read multiple files
Search the repository
Execute shell commands
Inspect Git history
Search online documentation
Connect to MCP tools

Step 2: The Terminal User Interface (TUI)

The TUI serves as the primary interface between the developer and the AI.

Here you can:

Ask questions
View responses
Inspect generated code
Watch command execution
Review file modifications
Navigate previous conversations
Monitor long-running tasks

Because everything happens inside the terminal, developers remain focused without constantly switching between applications.

Step 3: Agent Runtime

The Agent Runtime is the brain of Grok Build.

Rather than simply forwarding prompts to an AI model, it first determines:

What the user is asking
Which tools are required
Which files should be examined
Whether shell commands need to run
Whether external information is needed
How multiple steps should be coordinated

You can think of it as an intelligent task planner that breaks large requests into smaller executable actions.

For example, if you ask:

“Update all deprecated React lifecycle methods.”

The runtime may decide to:

Scan the repository.
Identify React components.
Search for deprecated APIs.
Modify affected files.
Run the build.
Execute tests.
Summarize the changes.

Step 4: Tool Layer

Once the runtime has planned the task, it invokes the appropriate tools.

The Tool Layer provides Grok Build with practical capabilities beyond text generation.

Some of the built-in tools include:

Terminal Execution — Run shell commands such as git, cargo, npm, or docker.
File Editing — Read, create, rename, and modify project files.
Repository Search — Locate classes, functions, or configuration files.
Web Search — Retrieve documentation, package references, and technical resources.
Git Operations — Inspect branches, commits, and project history.

Instead of answering purely from its training data, Grok Build combines live tool outputs with AI reasoning to produce more accurate and actionable results.

Step 5: Workspace Layer

The Workspace Layer manages interactions with your local development environment.

This includes access to:

Source code
Project folders
Configuration files
Version control
Build artifacts
Checkpoints
File system operations

Because the workspace understands the entire project structure, Grok Build can maintain consistency when making changes across multiple files.

For example, renaming a function might also update:

Imports
Documentation
Tests
Configuration files
Related modules

Instead of editing just a single file.

Step 6: AI Model

At the core of Grok Build is the AI model responsible for reasoning, code generation, explanation, and decision-making.

The model receives:

Your prompt
Repository context
Tool outputs
File contents
Terminal results
Web search results

With this additional context, the AI can generate responses that are significantly more accurate than relying solely on the original prompt.

Step 7: Web Search

Software development often requires current information that isn’t available in the local repository.

When necessary, Grok Build can search the web to retrieve:

Official documentation
Framework guides
Package references
API specifications
Library updates
Programming examples

This allows the AI to incorporate the latest technical information directly into its responses without requiring developers to leave the terminal.

Step 8: MCP Server Integration

One of Grok Build’s most powerful capabilities is its support for the Model Context Protocol (MCP).

Rather than limiting the AI to local project files, MCP enables secure communication with external tools and services.

For example, an MCP server can provide access to:

GitHub repositories
Cloud platforms
Internal company documentation
Databases
APIs
Issue trackers
Monitoring systems
Custom enterprise tools

This significantly expands what Grok Build can accomplish, allowing it to interact with real-world development environments beyond your local machine.

Step 9: Returning the Result

After gathering all the necessary information, Grok Build combines:

AI reasoning
Repository context
Tool outputs
Shell command results
Workspace information
External data (when available)

To produce a final response.

Depending on your request, the result may include:

Generated code
File modifications
Refactored components
Bug fixes
Documentation
Command outputs
Suggested improvements
Explanations of what changed and why

This end-to-end workflow enables Grok Build to function as an AI software engineering agent rather than a simple conversational assistant.

Why This Architecture Matters

Traditional AI coding assistants primarily generate text based on the prompt you provide. Grok Build extends this by combining reasoning with direct access to your development environment, making it capable of handling more complex, real-world engineering tasks.

By orchestrating repository awareness, terminal execution, file editing, web search, and external integrations through MCP, Grok Build can automate workflows that would otherwise require multiple tools and significant manual effort.

With an understanding of how Grok Build processes requests behind the scenes, you’re now ready to install it and start using it in your own development environment.

Installing Grok Build

Getting started with Grok Build is straightforward. xAI provides prebuilt binaries for macOS , Linux , and Windows , allowing you to install the CLI in just a few commands. If you prefer, you can also compile the project directly from its Rust source code.

In this section, we’ll walk through both approaches, verify the installation, and launch Grok Build for the first time.

System Requirements

Before installing Grok Build, ensure your system meets the following requirements.

| Requirement | Details |
| ------------------- | --------------------------------------------------------------------------- |
| Operating System | macOS, Linux, or Windows |
| Internet Connection | Required for installation and authentication |
| Terminal | Terminal, PowerShell, Windows Terminal, iTerm2, or another compatible shell |
| Browser | Required during the initial authentication process |

If you plan to build Grok Build from source , you’ll also need:

Rust (installed via rustup)
cargo
protoc (Protocol Buffers compiler)

Installing Grok Build on macOS

On macOS, Grok Build can be installed using the official installation script.

Run the following command:

curl -fsSL https://x.ai/cli/install.sh | bash

The installer downloads the latest Grok Build release and places the executable in your system.

Once the installation completes, verify it by checking the installed version.

grok --version

If everything was installed correctly, you’ll see output similar to:

grok 0.x.x

Installing Grok Build on Linux

Linux installation follows the same process as macOS.

Execute:

curl -fsSL https://x.ai/cli/install.sh | bash

After installation, verify the binary:

grok --version

If the command returns the installed version, Grok Build is ready to use.

Installing Grok Build on Windows

Windows users can install Grok Build directly from PowerShell.

Run:

irm https://x.ai/cli/install.ps1 | iex

After installation finishes, verify it:

grok --version

You should see the installed version displayed in the terminal.

First-Time Authentication

The first time you launch Grok Build, it will automatically open your default web browser and prompt you to sign in to your xAI account.

Start Grok Build by running:

grok

During the first launch:

Grok Build opens your default browser.
Sign in with your xAI account.
Grant the requested permissions.
Return to your terminal once authentication completes.

After authentication, your credentials are stored locally so you won’t need to repeat this process every time you use the tool.

Note: Authentication is only required during the initial setup unless your session expires or you explicitly sign out.

Launching Grok Build

Once authenticated, simply start Grok Build by running:

grok

You’ll be greeted with the full-screen terminal interface, where you can begin interacting with the AI using natural language prompts.

From here, you can:

Ask coding questions
Generate new code
Refactor existing projects
Execute terminal commands
Search your repository
Perform web searches
Manage long-running development tasks

Run Grok Build with Local Models

If you prefer local inference, TechLatest provides ready-to-use Ollama + Open WebUI environments with DeepSeek, Qwen, Llama, Gemma, and Mistral models that work seamlessly with AI coding agents.

Understanding the Welcome Screen

Let’s take a closer look at each option available on the home screen.

New Worktree

This option creates a new isolated Git worktree for your project.

A worktree allows you to work on a separate branch without affecting your primary working directory. It’s particularly useful when experimenting with features, testing ideas, or asking Grok Build to make large changes while keeping your main branch clean.

You can also use the keyboard shortcut:

Ctrl + W

Resume Session

Grok Build automatically saves previous conversations, allowing you to continue where you left off without losing context.

Choose Resume Session to reopen an earlier coding session rather than start from scratch.

Shortcut:

Ctrl + S

Changelog

The Changelog displays recent updates, improvements, bug fixes, and newly introduced features in Grok Build.

Checking the changelog regularly is a good way to stay informed about new capabilities and enhancements.

Quit

Exits the Grok Build interface and returns you to your terminal.

Shortcut:

Ctrl + Q

The Prompt Bar

At the bottom of the screen, you’ll notice the prompt input area.

This is where you’ll interact with Grok Build using natural language.

For example, you can ask:

Explain the structure of this repository.

Find unused functions in this project.

Create a Dockerfile for this application.

Generate unit tests for the authentication module.

Explain why this build is failing.

Unlike traditional command-line tools, you don’t need to memorize commands for most tasks. Simply describe what you want, and Grok Build determines the necessary steps to complete the request.

Model Indicator

In the bottom-right corner of the interface, Grok Build displays the currently active AI model.

In our example, the interface shows:

Grok 4.5 (Low)

This indicates the model currently being used to process requests. Depending on your subscription tier or configuration, different model variants may be available.

Status Indicator

The status label in the bottom-right corner indicates the current release channel.

For example:

[stable]

This confirms you’re running the stable release of Grok Build.

Future versions may also include preview, beta, or experimental channels as new features are introduced.

Extending Grok Build with Hooks, Plugins, Skills, and MCP Servers

Beyond acting as an AI coding assistant, Grok Build is designed to be highly extensible. It includes a built-in extensions panel where you can manage automation hooks, install plugins, add reusable skills, and connect external tools through the Model Context Protocol (MCP).

You can open this panel using the appropriate keyboard shortcut (depending on your platform or configuration) and navigate between the available tabs.

As shown above, the extensions panel is divided into several sections.

Hooks

The Hooks tab allows you to configure automation that runs before or after specific events inside Grok Build.

Hooks are useful when you want repetitive actions to happen automatically.

For example, a hook can:

Format code after edits
Run tests before completing a task
Check for linting errors
Execute security scans
Trigger custom shell scripts
Send notifications

In the screenshot, Grok Build lists both:

Custom Hooks (~/.claude)
Global Hooks

This separation allows project-specific automation while still keeping reusable global hooks available across multiple repositories.

Plugins

The Plugins tab allows Grok Build to extend its native functionality.

Plugins can provide additional capabilities that are not built directly into the core application.

Depending on available plugins, developers may be able to:

Integrate third-party services
Add custom development tools
Connect deployment platforms
Extend AI workflows
Automate repetitive engineering tasks

This modular approach allows Grok Build to grow beyond its default feature set.

Marketplace

The Marketplace acts as a central location for discovering additional extensions.

Rather than manually configuring every integration, developers can browse and install supported components from one place.

Future marketplace offerings may include:

Community plugins
Productivity tools
Developer utilities
Workflow integrations
Custom AI extensions

Skills

Skills are reusable instruction sets that teach Grok Build how to perform specialized tasks consistently.

Instead of writing the same prompt repeatedly, a skill encapsulates a workflow that can be invoked whenever needed.

Examples include:

Code review
Security auditing
Documentation generation
API design
Performance optimization
Infrastructure analysis
Testing workflows

Skills help standardize common engineering tasks across teams and projects.

MCP Servers

One of Grok Build’s most powerful capabilities is its support for Model Context Protocol (MCP) Servers.

Rather than limiting the AI to your local repository, MCP allows Grok Build to securely connect with external tools and services.

Examples include:

GitHub
Databases
Cloud platforms
Internal documentation
REST APIs
Issue trackers
Monitoring systems
Enterprise knowledge bases

By connecting to MCP servers, Grok Build gains access to additional context, enabling it to perform more advanced development workflows beyond local code analysis.

Conclusion

AI coding assistants are evolving rapidly, and Grok Build represents the next step in that evolution. Rather than acting as a simple code generator, it combines repository awareness, intelligent code editing, terminal automation, web search, and extensibility into a single developer-focused experience. Throughout this guide, we’ve explored how Grok Build works under the hood, installed it on different operating systems, navigated its terminal interface, and examined advanced capabilities such as Hooks, Plugins, Skills, and MCP Servers.

What makes Grok Build particularly interesting is its terminal-first design and open-source foundation. By publishing the project, xAI has allowed developers to inspect the Rust codebase, understand the architecture of a modern AI coding agent, and learn how advanced developer tools are built. Whether you’re an individual developer, an open-source contributor, or part of an engineering team, Grok Build offers a flexible platform that can adapt to a wide range of development workflows.

While no AI coding assistant can replace engineering expertise, tools like Grok Build can significantly reduce repetitive work, speed up debugging, automate common development tasks, and help developers stay focused on solving complex problems instead of routine ones.

As the ecosystem around AI coding agents continues to mature — with standards like MCP and ACP enabling richer integrations — tools such as Grok Build are likely to become an increasingly important part of the modern software development toolkit.

If you haven’t tried it yet, install Grok Build, explore its features, experiment with real-world projects, and see how it fits into your daily workflow. The best way to understand its capabilities is to put it to work on your own codebase.

Thanks for reading! If you found this guide helpful, consider sharing it with your fellow developers and following our blog for more tutorials on AI development tools, open-source projects, cybersecurity, and emerging technologies.

Thank you so much for reading

Like | Follow | Subscribe to the newsletter.

Catch us on

LinkedIn: https://www.linkedin.com/in/techlatest-net/

Reddit Community: https://www.reddit.com/user/techlatest_net/

HackAgent Tutorial: Secure AI Agents Against Prompt Injection, Jailbreaks, and Tool Misuse

TechLatest — Mon, 13 Jul 2026 14:10:42 +0000

Large Language Models (LLMs) have rapidly evolved from simple chatbots into autonomous AI agents capable of browsing the web, executing code, interacting with APIs, accessing databases, and performing complex multi-step tasks. Modern AI frameworks such as OpenAI SDK, LangChain, Google ADK, LiteLLM, and Model Context Protocol (MCP) make it easier than ever to build intelligent applications that can reason, plan, and act on behalf of users.

However, as AI agents become more capable, they also introduce an entirely new class of security risks. Unlike traditional web applications, AI agents can be manipulated through natural language. A carefully crafted prompt may convince an agent to ignore its original instructions, reveal confidential information, misuse connected tools, or perform actions it was never intended to execute.

Some of the most common threats include:

Prompt Injection — Malicious prompts that override an agent’s intended behavior.
Jailbreak Attacks — Attempts to bypass built-in safety policies and content restrictions.
Goal Hijacking — Redirecting an AI agent away from its original objective.
Tool Misuse — Tricking an agent into abusing connected tools such as GitHub, Slack, Gmail, databases, or external APIs.
System Prompt Leakage — Extracting hidden instructions that define the agent’s behavior.

These vulnerabilities can have serious consequences, especially for production AI systems connected to sensitive data or external services.

This is where HackAgent comes in.

HackAgent is an open-source AI Agent Security Testing Toolkit designed to help developers, AI engineers, and security researchers evaluate the robustness of AI agents against real-world adversarial attacks. Instead of manually crafting hundreds of malicious prompts, HackAgent automates the entire security evaluation process using research-backed attack techniques such as AdvPrefix, AutoDAN-Turbo, PAIR, TAP, FlipAttack, Best-of-N, CipherChat, PAP, and more.

Whether you’re building a customer support chatbot, a coding assistant, a research agent, or an enterprise AI application, HackAgent helps identify vulnerabilities before they can be exploited in production.

In this tutorial, you’ll learn how to install HackAgent, explore its interactive Terminal User Interface (TUI), understand its security testing workflow, configure attacks, interpret results, and use the toolkit to strengthen the security of your AI agents.

By the end of this guide, you’ll have a solid understanding of how HackAgent works and how it can be integrated into your AI development and security testing workflow.

Installing HackAgent

HackAgent is distributed as a Python package and works on Linux, macOS, and Windows. The recommended approach is to install it inside a Python virtual environment to avoid dependency conflicts.

Prerequisites

Before installing HackAgent, ensure your system meets the following requirements:

Python 3.10 or later
pip
Terminal or Command Prompt
Internet connection for package installation

You can verify your Python installation by running:

python3 --version

python --version

If Python is not installed, download the latest version from the official Python website.

Step 1: Create a Virtual Environment

Create an isolated Python environment for HackAgent.

python3 -m venv .ve

This creates a new directory named .venv containing an isolated Python environment.

Step 2: Activate the Environment

macOS / Linux

source .venv/bin/activate

Windows (PowerShell)

.venv\Scripts\Activate.ps1

Windows (Command Prompt)

.venv\Scripts\activate

Once activated, your terminal should display something similar to:

(.venv)

indicating that the virtual environment is active.

Step 3: Install HackAgent

Install the latest release directly from PyPI.

pip install hackagent

The installer automatically downloads HackAgent along with all required dependencies.

Step 4: Verify the Installation

After installation, verify that everything is working correctly.

hackagent --help

hackagent --version

If the installation was successful, you’ll see the installed version along with the available CLI commands.

Your First HackAgent Run

Once HackAgent is installed, you can begin evaluating an AI agent for common security vulnerabilities.

A typical security assessment follows this workflow:

Create or connect an AI agent
        │
        ▼
Choose an attack technique
        │
        ▼
Generate adversarial prompts
        │
        ▼
Execute attacks
        │
        ▼
Evaluate responses
        │
        ▼
Generate security report

HackAgent automates this entire pipeline, allowing you to focus on identifying and fixing vulnerabilities rather than manually crafting attack prompts.

Getting Started with HackAgent CLI

Once HackAgent is installed successfully, you’re ready to explore its command-line interface (CLI). The CLI provides an easy way to launch security assessments, manage reports, configure settings, and interact with different attack techniques.

To display all available commands and options, run:

hackagent --help

You should see an output similar to this:

Usage: hackagent [OPTIONS] COMMAND [ARGS]...

Commands:
  attack Run a security attack
  report View reports
  dashboard Launch dashboard
  web Open HackAgent web interface
  config Configure HackAgent
  ...

Note: The available commands may vary slightly depending on the HackAgent version you’re using.

Launch the Interactive CLI

Once HackAgent is installed successfully, you’re ready to explore its interactive Terminal User Interface (TUI). Instead of relying on long command-line arguments, the TUI provides a visual interface for configuring target agents, selecting attack techniques, monitoring attack execution, viewing results, and managing configuration — all from your terminal.

To launch the interactive interface, simply run:

hackagent

Within a few seconds, HackAgent opens a full-screen terminal dashboard similar to the one shown below.

Understanding the HackAgent Interface

The HackAgent TUI is divided into four primary sections, each designed for a different stage of the AI security testing workflow.

Target Agents
Attacks
Results
Config

You can navigate between these tabs using your keyboard, making it easy to manage the entire testing process without leaving the terminal.

1. Target Agents

The Target Agents tab is your starting point. Before launching any security assessment, you need to define the AI agent you want to evaluate.

This page displays:

Total registered target agents
Active agents
Current system status
List of configured agents
Agent metadata

Initially, the list will be empty because no target agent has been configured.

Once you add an agent, it will appear in the table along with details such as:

Agent Name
Agent Type
Endpoint
Status
Creation Time

This allows you to manage multiple AI agents from a single interface.

Typical examples include:

Customer Support Chatbot
Travel Booking Agent
LangChain Agent
OpenAI SDK Agent
Google ADK Agent
LiteLLM Application

2. Attacks

The Attacks tab is where the actual security testing takes place.

This section contains the complete attack configuration panel.

Here you can configure:

Target Agent
Attack Technique
Generator Model
Judge Model
Dataset
Guardrails
Runtime Configuration

On the right side, HackAgent displays a real-time Attack Log Viewer.

During execution, this panel shows:

Attack progress
Generated adversarial prompts
Target responses
Evaluation logs
Warnings
Errors
Execution status

The live logs make it easy to monitor long-running security evaluations without switching to another terminal.

Attack Configuration

Before starting an attack, you’ll typically configure:

Target AI Agent
Attack Method
Evaluation Dataset
Optional Guardrails
Attack Parameters

Once everything is configured, HackAgent begins generating adversarial prompts automatically and evaluates how well your AI agent withstands various attacks.

3. Results

After an attack completes, all findings are stored under the Results tab.

This section provides a centralized location for reviewing previous security assessments.

Each completed run includes information such as:

Target Agent
Attack Technique
Success or Failure
Timestamp
Security Evaluation Results

Selecting a run displays detailed information in the right-hand panel, making it easy to inspect individual attack outcomes and understand how the AI agent responded.

The Results page also includes useful features like:

Refresh results
Export results as CSV
Filter previous runs
Limit displayed records

These capabilities make it easier to analyze trends across multiple security evaluations and share reports with your team.

4. Configuration

The Config tab lets you manage HackAgent’s global settings.

From this screen, you can:

View the configuration file location
Save configuration changes
Reset settings to their default values
Validate your configuration
View system information

The bottom section also displays useful environment details such as:

Python Version
Installed HackAgent CLI Version

For example:

Python Version: 3.13.13
CLI Version: 0.11.0

This information is particularly helpful when troubleshooting installation issues or reporting bugs.

Conclusion

As AI agents become more capable and autonomous, securing them is no longer optional — it’s an essential part of the development lifecycle. Modern AI applications don’t just generate text; they interact with external tools, access sensitive data, execute workflows, and make decisions on behalf of users. This expanded functionality also increases the potential attack surface, making AI-specific threats such as prompt injection, jailbreaks, goal hijacking, tool misuse, and system prompt leakage serious security concerns.

HackAgent provides an open-source, research-backed solution for evaluating these risks through automated AI security testing. With support for multiple AI frameworks, a powerful command-line interface, an interactive Terminal User Interface (TUI), real-time attack monitoring, comprehensive reporting, and a growing collection of adversarial attack techniques, HackAgent enables developers and security teams to identify vulnerabilities before they reach production.

In this guide, you learned how to install HackAgent, verify the installation, explore its CLI, launch the interactive TUI, and understand the purpose of each major component, including Target Agents , Attacks , Results , and Configuration. These fundamentals provide a solid starting point for incorporating AI security testing into your development workflow.

However, installation is only the beginning. The real value of HackAgent comes from testing real AI agents, experimenting with different attack techniques, analyzing generated reports, and continuously improving your application’s security posture. Whether you’re building a customer support chatbot, an AI coding assistant, an enterprise knowledge agent, or a multi-agent system, regular security evaluations should become a standard part of your release process.

As the AI ecosystem continues to evolve, new attack techniques and vulnerabilities will emerge. Tools like HackAgent help developers stay ahead by making AI red teaming more accessible, repeatable, and automated.

If you’re developing AI-powered applications, now is the perfect time to start integrating security testing into your workflow. Detect vulnerabilities early, strengthen your AI agents, and build systems that are not only intelligent but also resilient against real-world attacks.

Thank you so much for reading

Like | Follow | Subscribe to the newsletter.

Catch us on

LinkedIn: https://www.linkedin.com/in/techlatest-net/

How to Automatically Document Your Repository with OpenWiki

Reddit Community: https://www.reddit.com/user/techlatest_net/

TechLatest AI & Tech Weekly #24

TechLatest — Sat, 11 Jul 2026 13:49:45 +0000

Welcome to this week’s edition of TechLatest AI & Tech Weekly 👋

Here’s a curated roundup of our latest blogs, notable product launches, and the most interesting AI & ML updates from July 06–July 11, 2026.

AI/ML News Roundup: July 06–July 11, 2026

TL;DR

OpenAI, Meta, NVIDIA, and xAI introduced major AI releases, including GPT-5.6 , GPT-Live , GPT-Realtime 2.1 Mini , Muse Spark 1.1 , Grok 4.5 , and Audex Nemotron Labs , pushing the boundaries of reasoning, voice AI, coding, and multimodal intelligence.
Open-source AI continued to evolve rapidly with launches like LingBot-World Infinity , LingBot-VLA 2.0 , LingBot Vision-A 1B , and Liquid AI’s AntiDoom , advancing robotics, world models, and AI training techniques.
The AI ecosystem expanded beyond language models , with breakthroughs in robotics, autonomous agents, enterprise AI platforms, and world simulation models from companies including Mistral, Kyutai, Microsoft, and Databricks.
Investment and infrastructure momentum remained strong , driven by IPO activity, billion-dollar funding rounds, enterprise AI adoption, and continued investment in next-generation AI chips and hardware.
Global AI regulation accelerated , with new policies, safety audits, international governance discussions, and regulatory actions shaping the future deployment of advanced AI systems.
TechLatest published three hands-on tutorials , covering OpenWiki for automated repository documentation, Orca for multi-agent AI coding workflows, and the Zero AI Coding Agent with complete installation, local models, Ollama, OpenAI, MCP, plugins, and production-ready setup.

Open-Source AI, AI Agents, Voice AI & Developer Releases

Meet LingBot-World Infinity

LingBot-World Infinity (LingBot-World 2.0) is an open-source causal world model from Ant Group’s Robbyant that enables long-horizon interactive simulations with an agentic harness. It supports real-time 720p generation, multi-player interaction, and autonomous agents capable of planning actions while dynamically evolving virtual environments. Source

Liquid AI Introduces AntiDoom

Liquid AI unveiled AntiDoom , a new training approach that addresses “doom loops” in foundation model post-training through FTPO (Forward Trajectory Preference Optimization). The method aims to improve long-term stability, reasoning quality, and robustness during reinforcement learning. Source

LingBot-VLA 2.0 Released

Ant Group’s Robbyant unveiled LingBot-VLA 2.0 , an open-source 6B Vision-Language-Action (VLA) foundation model that enables robots to understand visual scenes, follow natural language instructions, and perform complex manipulation tasks across multiple robot platforms. Source

RobbyAnt Open-Sources LingBot Vision-A 1B

Ant Group introduced LingBot Vision-A 1B , an open-source vision foundation model designed for dense spatial perception. Built around boundary-centric visual understanding, it helps AI systems and robots achieve more accurate scene understanding for real-world applications. Source

OpenAI Launches GPT-Live

OpenAI announced GPT-Live and GPT-Live-1 Mini , a new generation of full-duplex voice models that enable natural, real-time conversations while delegating deeper reasoning tasks to GPT-5.5. Source

OpenAI Releases GPT-Realtime 2.1 Mini

OpenAI launched GPT-Realtime 2.1 Mini , bringing reasoning and tool use to its low-latency Realtime API while maintaining the same pricing as the previous Mini model. Source

SpaceXAI Releases Grok 4.5

SpaceXAI introduced Grok 4.5 , the latest version of its frontier language model with improved reasoning, coding, multimodal understanding, and enterprise capabilities. Source

Meta Introduces Muse Spark 1.1 & Meta Model API

Meta unveiled Muse Spark 1.1 , the latest flagship multimodal reasoning model from Meta Superintelligence Labs, alongside the Meta Model API in public preview. The release brings stronger agentic coding, multimodal reasoning, and a developer API with pay-as-you-go pricing. Source

OpenAI Releases GPT-5.6

OpenAI launched the GPT-5.6 family, introducing Sol , Terra , and Luna for different performance and pricing tiers. The models deliver stronger reasoning, coding, and tool-calling capabilities across ChatGPT, Codex, and the OpenAI API. Source

NVIDIA Releases Audex Nemotron Labs

NVIDIA introduced Audex Nemotron Labs 30B-A3B , a unified audio-text language model that combines speech understanding, speech generation, audio reasoning, and text intelligence without sacrificing LLM performance. Source

Hugging Face & Open-Source Ecosystem

Mistral released Robostral Navigate on July 9, 2026, its first entry into autonomous robot navigation, continuing Mistral’s commitment to open-weight models for specialized robotics tasks.
Kyutai and General Intuition released MIRA on July 7, 2026, an open-source AI world model that simulates a fully playable real-time multiplayer Rocket League game entirely inside a neural network.
MIRA is a 5-billion-parameter latent diffusion model trained on 10,000 hours of gameplay, generating every frame on the fly without a game engine or physics system.
Tufa Labs won the ARC-AGI-3’s $37.5K milestone contest on July 8, 2026 by wrapping a small open-source Qwen model in a coding agent harness, beating the field and demonstrating that smart agent design can outperform raw model size

Frontier Model Advancements & Agentic Capabilities

OpenAI launched the GPT-5.6 family (Sol, Terra, Luna) on July 9, 2026, with models now being integrated into Microsoft 365 Copilot products like Word and Excel.
GPT-5.6 is now being publicly released globally , ending government-requested limits, with the models integrated into Microsoft 365 Copilot products.
Anthropic released Claude Cowork on mobile and web on July 9, 2026, expanding access beyond desktop for AI-assisted admin reports and checklists.
Anthropic extended Claude Fable 5 free access for paid subscribers through July 12, 2026 (four more days before per-token billing starts on July 13).
Meta introduced Muse Image on July 9, 2026, its first in-house image generation model built inside Alexander Wang’s Superintelligence Labs, debuting at number two on Arena Leaderboards and already rolling out across Instagram, WhatsApp, and Meta AI.
Meta teased Muse Video on July 9, 2026, as the next move in its head-to-head competition with OpenAI on generative media.
Meta launched Muse Spark 1.1 on July 10, 2026, its first pay-to-use AI coding tool designed to challenge OpenAI and Anthropic through aggressive pricing and higher performance benchmarks.distillintelligence
xAI released Grok 4.5 on July 10, 2026, which ranked fourth on the Intelligence Index, had the best agentic tool use, but had a 54% hallucination rate on its first day.
Microsoft is quietly swapping OpenAI and Anthropic models for its own in-house MAI models inside flagship apps like Excel and Outlook, per Bloomberg reports on July 8, 2026.
DoorDash built DashBench to grade AI code reviewers, finding Kimi K2.6 paired with Claude Fable 5 caught 65% of real bugs, including 8 out of 10 critical issues at just $3.81 per code change.

Massive Funding Rounds Reshaping Valuations

Anthropic achieved a $30 billion revenue run-rate and appointed former Fed Chair Ben Bernanke to its trust board, per reports on July 9, 2026.
Anthropic and OpenAI have both reportedly filed for historic IPOs , marking a major shift in the AI industry’s financial landscape.
MiniMax is seeking $2.05 billion in capital as Chinese AI firms pursue massive expansion.
DeepSeek is developing its own in-house AI chips amid massive expansion efforts.
SK Hynix debuted on Nasdaq on July 10, 2026, in a $26.5 billion share sale, with shares rising 13% on debut ($168.01, $1.27T market cap, 7x oversubscribed) — the AI infrastructure IPO signal for Anthropic and others.
Did You Know Labs raised funding as AI startups continue to attract capital amid IPO momentum.

Practical Product Launches for Developers & Enterprises

Schneider Electric built its LLMOps foundations at enterprise scale with LangSmith on July 9, 2026, demonstrating enterprise-scale MLOps implementation.
Databricks launched Lakeflow on July 9, 2026, a new era of an agentic data engineering platform.
Cognition released SWE-1.7 on July 9, 2026, offering frontier intelligence at a fraction of the cost.
OpenAI unveiled ChatGPT Work on July 10, 2026, an agent in its popular chatbot designed to execute tasks across different applications and files, marking its latest push into workplace automation.
Microsoft announced the launch of Microsoft Frontier Company on July 7, 2026, a $2.5B AI initiative aimed at driving enterprise-scale AI adoption and measurable outcomes.

Governance, Ethics & Regulation

UN called for swift global regulation of AI on July 6, 2026, with the UN chief warning “AI is developing faster than rules can keep up” as 169 countries met in Geneva for the inaugural UN global dialogue on AI governance.
UN AI for Good Commission's first meeting in Geneva took place on July 8, 2026.
Illinois became the first US state to require annual third-party safety audits for major AI developers on July 7, 2026, with both Anthropic and OpenAI backing the bill.
Beijing is considering restricting overseas access to China’s top AI models, including open-weight releases from ByteDance, Alibaba, and Zhipu AI on July 8, 2026, mirroring the US export control playbook but in reverse.
ByteDance and Alibaba are pulling AI companion features from Doubao and Qwen ahead of Beijing’s July 15 deadline for new rules on AI emotional dependency.
President Trump cancelled a scheduled Oval Office signing ceremony for a new AI executive order on July 6, 2026, citing concern that signing would “undermine America’s lead over China”.
August 1 formal deadline for NSA and CISA to deliver classified frontier model benchmarks still stands regardless of whether a new executive order is signed.
UK designated cloud service providers Microsoft, Google, Amazon, and Oracle as critical third-party suppliers to its financial sector on July 10, 2026, bringing them under direct regulatory oversight.
EU charged Meta Platforms’ Instagram and Facebook on July 10, 2026, with breaching tech rules, targeting features designed to keep users hooked (autoplay and infinite scroll) or risk fines.

Infrastructure & Hardware

DeepSeek is developing its own in-house AI chips amid massive expansion efforts.
Taiwanese memory chipmaker Nanya plans capital spending of more than T$200 billion ($6.2 billion) in 2027, roughly four times this year’s figure, amid soaring demand for memory chips as it rides the AI boom.
OpenAI and Meta launched major new models as the industry pivots toward IPOs and autonomous agents amid intensifying global regulatory scrutiny.
SK Hynix’s US listing on July 10, 2026, served as a key test of investors’ belief in the durability of the AI boom, coming after a recent pullback in semiconductor stocks.

Blogs We Published This Week

How to Automatically Document Your Repository with OpenWiki

Learn how to use OpenWiki to automatically generate and maintain documentation for your codebase. This guide walks through installation, configuration, GitHub integration, and how AI agents can leverage always up-to-date project documentation for better coding workflows.

Orca Tutorial: Multi-Agent AI Coding Workspace from Scratch

A complete guide to setting up Orca , an open-source AI coding workspace that brings together Git, AI coding agents, terminals, and developer tools into a single interface for faster software development.

Orca Tutorial: Multi-Agent AI Coding Workspace from Scratch

Zero AI Coding Agent: The Complete Installation & Setup Guide

A comprehensive masterclass on Zero AI Coding Agent , covering installation, local and cloud model providers, Ollama, OpenAI, MCP integration, plugins, databases, and production-ready configuration for AI-powered software development.

Zero AI Coding Agent: The Complete Installation & Setup Guide (Local Models, OpenAI, Ollama, MCP…

Thank you so much for reading

Like | Follow | Subscribe to the newsletter.

Catch us on

LinkedIn: https://www.linkedin.com/in/techlatest-net/

Techlatest.net - GPU Supported DeepSeek & Llama powered All-in-One LLM

Reddit Community: https://www.reddit.com/user/techlatest_net/

Zero AI Coding Agent: The Complete Installation & Setup Guide (Local Models, OpenAI, Ollama, MCP…

TechLatest — Thu, 09 Jul 2026 13:37:21 +0000

Zero AI Coding Agent: The Complete Installation & Setup Guide (Local Models, OpenAI, Ollama, MCP, Plugins & More)

AI coding agents have transformed the way developers build software. Instead of simply generating snippets of code, modern AI agents can understand an entire codebase, edit files, execute terminal commands, run tests, search repositories, and even automate complex development workflows — all without leaving your terminal.

Zero is one of the newest open-source AI coding agents designed specifically for developers who prefer working from the command line. Unlike traditional AI assistants, Zero combines an interactive terminal interface with powerful automation capabilities, allowing you to inspect repositories, modify code, execute shell commands, manage long-running sessions, and integrate with external tools — all while keeping you in complete control through its built-in permissions and sandbox system.

One of Zero’s biggest strengths is its flexibility. It isn’t tied to a single AI provider. You can use cloud models from OpenAI, Anthropic, Google Gemini, Groq, OpenRouter, DeepSeek, xAI, Mistral, GitHub Models, and many others, or run everything locally with Ollama and LM Studio. This gives you the freedom to choose the model that best fits your budget, performance requirements, and privacy preferences.

In this comprehensive guide, you’ll learn everything you need to get started with Zero. We’ll walk through the installation process, configure your first AI provider, explore the interactive Terminal User Interface (TUI), send your first prompts, and understand how Zero’s safety model works. As the guide progresses, we’ll also cover advanced features such as zero exec, worktrees, session management, MCP servers, plugins, hooks, skills, specialist agents, repository analysis, sandboxing, and real-world development workflows.

Whether you’re a beginner looking for your first AI coding assistant or an experienced developer searching for a powerful terminal-native alternative to tools like Claude Code, Codex CLI, or Gemini CLI, this guide will help you become productive with Zero from the ground up.

What You’ll Learn

By the end of this guide, you’ll be able to:

Install Zero on Windows, macOS, and Linux.
Configure cloud or local AI providers.
Connect OpenAI, Anthropic, Gemini, OpenRouter, Ollama, LM Studio, and more.
Understand the Zero Terminal User Interface (TUI).
Use zero exec For automation and scripting.
Work with sessions, repository context, and worktrees.
Configure MCP servers, plugins, hooks, skills, and specialist agents.
Understand Zero’s permission model and sandbox system.
Build real-world AI-powered development workflows directly from your terminal.

Step 1: Install Zero AI Coding Agent

Before exploring Zero’s features, you need to install it on your system. Zero is available for Linux, macOS, and Windows and supports both x64 and ARM64 architectures.

The easiest installation method is through npm , which automatically downloads the correct native Zero binary for your operating system.

Install using npm

npm install -g @gitlawb/zero

If the installation completes successfully, verify it by checking the installed version:

zero --version

You should see the installed Zero version printed in your terminal.

Verify Your Installation

Zero also includes a built-in diagnostic command that checks whether everything is configured correctly.

zero doctor

This command verifies your installation, checks for any missing dependencies, detects available AI providers, and reports potential configuration issues before you start using the tool.

Note: Installing the npm package downloads the appropriate native Zero binary for your platform from GitHub Releases, so you don't need to build the project from source unless you plan to contribute to its development.

Step 2: Verify Your Installation with zero doctor

After installing Zero, the next step is to verify that everything is working correctly. Zero includes a built-in diagnostic tool called doctor That checks your installation and highlights anything that still needs to be configured.

Run the following command:

zero doctor

For a fresh installation, you’ll likely see an output similar to this:

Zero doctor report
Overall: fail

Don’t panic if the overall status says fail. This is completely normal on a fresh installation because Zero hasn’t been connected to an AI provider yet.

Runtime Check

[pass] runtime.go - Zero Go runtime is available (go).

This confirms that Zero is installed correctly and its Go runtime is working as expected. No action is required here.

Configuration Check

[warn] config.files - No explicit Zero config files were inspected.
[warn] config.validation - No Zero config files were available to validate.

These warnings simply mean that Zero hasn’t created any configuration files yet. Since this is your first time running the tool, there are no settings to validate.

Once you complete the setup wizard, Zero will automatically generate the required configuration files.

Provider Configuration

[fail] provider.config - No LLM provider is configured.

This is the most important message in the report and the primary reason why the overall health check fails.

Zero requires access to an AI model before it can perform tasks like:

Answering coding questions
Editing files
Generating code
Running agent workflows
Executing zero exec

Until you configure a provider such as OpenAI, Anthropic, OpenRouter, Ollama, Gemini, or another supported service, Zero has no model to communicate with.

You’ll configure this in the next step using the built-in setup wizard.

Provider Validation Skipped

[warn] provider.model - Model validity was skipped because provider config is unavailable.

[warn] provider.connectivity - Connectivity check was skipped because provider runtime did not resolve.

Since no AI provider has been configured, Zero can’t verify whether your selected model exists or whether it can successfully connect to the provider’s API.

These warnings will disappear once you finish the provider setup.

Sandbox Support

[pass] sandbox.backend - Native sandbox backend macos-seatbelt is available.

This indicates that Zero successfully detected macOS’s native sandboxing system.

The sandbox helps protect your system by controlling file access, shell commands, network requests, and other potentially destructive operations. Instead of allowing unrestricted access, Zero asks for permission before performing sensitive actions.

This is one of Zero’s key security features and helps prevent accidental or unintended changes to your machine.

Language Server Warning

[warn] lsp.servers - 3 language server(s) missing from PATH

Zero also checks whether Language Server Protocol (LSP) tools are installed for popular programming languages.

In this example, the following language servers are missing:

gopls for Go
pyright-langserver for Python
typescript-language-server for JavaScript and TypeScript

Without these language servers, Zero can still read, edit, and generate code. However, advanced IDE-like features — such as symbol navigation, intelligent refactoring, accurate code understanding, and language-aware edits — may be limited.

If you work with these languages regularly, you can install them using the recommended commands:

# Go
go install golang.org/x/tools/gopls@latest

# Python
npm install -g pyright

# JavaScript / TypeScript
npm install -g typescript typescript-language-server

Step 3: Configure Your First AI Provider

Now that Zero is installed and you’ve verified the installation using zero doctorThe next step is to configure an AI provider. Zero supports a wide range of cloud and local AI providers, allowing you to choose the model that best suits your workflow.

To launch the interactive setup wizard, run the following command:

zero setup

The setup wizard will walk you through the initial configuration process, including selecting your preferred AI provider, choosing a model, and saving the configuration for future use.

Note: If you’re using a cloud provider such as OpenAI, Anthropic, Gemini, or OpenRouter, make sure you have a valid API key. If you’re using local providers like Ollama or LM Studio, ensure the local server is running before starting the setup.

Here’s what running the setup command looks like in the terminal:

Once you execute the command, Zero will launch its interactive setup wizard, where you’ll configure your provider in just a few steps. In the next section, we’ll walk through each screen of the setup process and configure Zero using an AI provider.

Step 3.1: Launch the Zero Setup Wizard

After running the zero setup Command Zero launches its interactive onboarding wizard. This wizard guides you through the initial configuration process, making it easy to connect to an AI provider and start using the agent without manually editing configuration files.

When the wizard starts, you’ll see a welcome screen similar to the one below:

The welcome screen introduces Zero as a terminal AI coding agent capable of planning changes, editing code with approval, running verification checks, and resuming previous sessions.

At the bottom of the screen, you’ll notice “1/7” , indicating that the setup consists of seven guided steps. To begin the configuration process, simply press the Space key.

Tip: The setup wizard only needs to be completed once. After your provider and model are configured, Zero automatically saves your settings and uses them for future sessions.

In the next step, we’ll choose the AI provider that Zero will use for code generation, reasoning, and terminal assistance.

Step 3.2: Choose How You Want to Connect

After pressing Space , Zero asks how you would like to connect to an AI provider. This is where you’ll choose the authentication method that best fits your workflow.

You’ll see a screen similar to the following:

Zero provides two ways to connect:

1. Sign in with OAuth

This option lets you authenticate through your web browser without manually copying or pasting an API key. It’s a convenient choice if your preferred provider supports OAuth authentication.

2. Paste an API Key / Browse Providers

This option allows you to configure Zero using an API key or connect to one of the many supported AI providers. It also supports local AI runtimes such as Ollama and LM Studio , making it the most flexible option for developers.

Since we’ll be configuring Zero with our own AI provider, select Paste an API Key / Browse Providers using the ↑/↓ arrow keys , then press Enter to continue.

Note: Zero supports more than 20 AI providers, including OpenAI, Anthropic, Google Gemini, OpenRouter, Groq, DeepSeek, xAI, Mistral, GitHub Models, Ollama, LM Studio, and other OpenAI- or Anthropic-compatible endpoints.

Step 3.3: Configure Your Credentials

After selecting your AI provider, Zero will display a credentials screen based on the provider you’ve chosen. Since we’re using Ollama in this guide, Zero recognizes that it runs locally and doesn’t require an API key.

You’ll see a screen similar to the following:

Unlike cloud providers such as OpenAI, Anthropic, or Gemini, Ollama runs entirely on your local machine , so there’s no need to enter an API key or authenticate with an online service.

The setup wizard simply reminds you of one important requirement:

Start the Ollama server before sending prompts to Zero.

If Ollama isn’t already running, start it before continuing. You can verify that the server is available by running:

ollama list

If the command returns your installed models, the Ollama server is ready to use with Zero.

Once you’ve confirmed that Ollama is running, press Space to continue to the next step of the setup wizard, where you’ll select the model that Zero should use for your coding sessions.

Step 3.4: Select Your AI Model

After configuring your provider, Zero will detect the available models and ask you to choose which one you’d like to use as your default coding assistant.

In this example, Zero automatically detects the locally installed Ollama models.

Use the ↑/↓ arrow keys to navigate through the available models and press Enter to select one.

You can also use the search box at the top of the screen to quickly filter models if you have many installed.

In this guide, we’ll select qwen2.5:1.5b , but you can choose any model available in your Ollama installation.

Tip: If your preferred model doesn’t appear in the list, install it first using Ollama. For example:

ollama pull qwen2.5:7b

Then restart the setup wizard, and the newly installed model will be available for selection.

After selecting your model, press Enter to continue.

Step 3.5: Review Zero’s Safety Settings

The final step of the setup wizard introduces Zero’s safety model.

Unlike many autonomous AI coding agents, Zero is designed to keep you in control. By default, it asks for confirmation before performing actions that could modify your system or project.

This includes operations such as:

Running shell commands
Editing or creating files
Executing potentially risky operations
Performing actions outside your current workspace

As shown on the screen, the default behavior is:

Ask before risky work.

This means Zero will always request your approval before executing actions that could have side effects, helping prevent accidental changes to your codebase.

Simply press Space to continue and complete the setup wizard.

Step 3.6: Complete the Setup and Launch Zero

You’re now at the final step of the setup wizard. Before saving your configuration, Zero displays a summary of the settings you’ve selected.

This confirmation screen shows the configuration that Zero will use for future sessions. In our example, the selected settings are:

Provider: Ollama Local
Model: qwen2.5:1.5b
Credentials: Not required (because Ollama runs locally)
Configuration File: ~/.config/zero/config.json

Zero stores these settings in its configuration file, so you only need to complete the setup once. Every time you launch Zero in the future, it will automatically use this saved configuration unless you choose to change it later.

You’ll also notice a few helpful slash commands at the bottom of the screen:

/provider – Change your AI provider or model.
/doctor – Run a diagnostic check to verify your configuration and installation.
/help – Display available commands and usage information.

Once you’ve reviewed the configuration, press Enter to save your settings and launch Zero.

Congratulations! You’ve completed the initial setup process. In the next section, we’ll explore the Zero Terminal User Interface (TUI), learn how to navigate it, and send our first prompt to the AI coding agent.

Run Zero Completely Offline

If you prefer running AI models locally, TechLatest provides a ready-to-use Ollama + Open WebUI environment with DeepSeek, Qwen, Llama, Gemma, Mistral, and other open-source models that work seamlessly with Zero.

Looking for an OpenAI-compatible local endpoint? Deploy LocalAI with TechLatest and connect it directly to Zero without changing your workflow.

Techlatest.net - LocalAI: Self-Hosted Alternative to OpenAI & Anthropic

Step 4: Launch the Zero Terminal Interface

After pressing Enter on the final setup screen, Zero saves your configuration and launches its interactive Terminal User Interface (TUI). This is where you’ll spend most of your time interacting with the AI coding agent.

When Zero starts successfully, you’ll see a screen similar to the following:

The interface is clean and designed to keep you focused on coding. Let’s take a quick tour of what you’re seeing.

Current Workspace

In the top-left corner, Zero displays the directory you’re currently working in.

~/projects/agentscli

This tells you which project Zero has access to. Any files it reads or edits will be within this workspace unless you explicitly grant access to additional directories.

Active Provider and Model

The top-right corner shows the currently selected AI provider and model.

ollama/qwen2.5:1.5b

This makes it easy to confirm which model Zero is using for your current session. If you ever need to switch models or providers, you can do so without leaving the interface.

Helpful Starter Prompts

In the center of the screen, Zero displays several example prompts to help you get started, such as:

Explain this codebase
Fix the failing test
Add a --json flag

These examples demonstrate common development tasks that Zero can perform, making it easy for new users to begin experimenting with the agent.

Keyboard Shortcuts

Zero also highlights a few useful shortcuts near the bottom of the screen:

? — View all keyboard shortcuts
/ — Open the slash command menu
Ctrl + B — Toggle the sidebar
Ctrl + E — Copy the latest response

As you continue using Zero, these shortcuts can significantly speed up your workflow.

If you’re looking beyond AI coding into personal automation, OpenClaw extends AI workflows to Telegram, WhatsApp, scheduled tasks, and personal productivity.

Techlatest.net - OpenClaw: AI Agent Automation Stack

Step 5: Send Your First Prompt

With Zero fully configured, you’re ready to start interacting with the AI coding agent. The prompt box at the bottom of the screen is where you’ll type your requests, ask questions, or assign coding tasks.

Simply type your prompt and press Enter.

For example, we asked Zero two simple questions:

Hello, how are you?
How many R’s are there in the word “Strawberry”?

Zero responded immediately within the terminal.

Understanding the Response

Each interaction follows a simple conversation format:

Your prompt appears at the top of the conversation.
Zero generates a response directly below it.
At the end of each response, Zero includes a brief recap , summarizing what it just accomplished or answered.

This recap becomes especially useful during longer coding sessions, as it provides a quick summary of previous interactions without needing to reread the entire conversation.

Asking Coding Questions

While general questions work as expected, Zero is designed primarily as a coding assistant. Once you’re inside a project, you can ask it to perform development tasks such as:

Explain how a codebase works.
Find and fix bugs.
Generate new features.
Refactor existing code.
Write unit tests.
Improve documentation.
Review pull requests.
Optimize performance.
Debug failing tests.

For example, instead of asking a general question, you could type prompts like:

Explain this codebase.

Find any bugs in this project.

Add authentication to this application.

Write unit tests for the API.

Refactor this project using best practices.

Continuing the Conversation

Unlike a traditional command-line tool, Zero maintains the context of your current session. This means you can ask follow-up questions without repeating previous information.

For example:

Explain this codebase.
Which file handles authentication?
Can you improve that implementation?
Write tests for the updated code.

Zero understands the conversation history and uses it to provide more relevant responses, making it feel like collaborating with an experienced developer directly from your terminal.

Now that you’ve successfully sent your first prompt, the next step is to explore Zero’s powerful built-in commands, starting with the interactive slash commands that allow you to switch models, manage sessions, inspect permissions, and much more.

Conclusion

Congratulations! You’ve successfully installed and configured Zero AI Coding Agent on your machine.

In this guide, we covered everything you need to get started — from installing Zero and verifying the installation to configuring an AI provider, selecting a model, completing the setup wizard, launching the Terminal User Interface (TUI), and sending your first prompt.

At this point, your Zero environment is fully configured and ready to assist with real-world development tasks. Whether you’re using a cloud provider like OpenAI or Anthropic, or running local models with Ollama or LM Studio, you now have a powerful AI coding assistant directly in your terminal.

However, we’ve only scratched the surface of what Zero can do. Beyond basic conversations, Zero offers a rich set of developer-focused features, including zero exec for headless automation, session management, repository analysis, worktrees, permission controls, sandboxing, MCP server integration, plugins, hooks, skills, specialist agents, and much more.

In the next part of this series, we’ll dive deep into these advanced capabilities and explore how to use Zero effectively in real development workflows. We’ll cover the Terminal UI in detail, learn the most useful slash commands, understand the permission model, automate coding tasks, integrate external tools, and discover how to get the most out of Zero as your everyday AI coding companion.

Until then, explore the interface, experiment with different prompts, and start using Zero on your own projects. The more you interact with it, the more you’ll appreciate how powerful a terminal-native AI coding agent can be.

Thank you so much for reading

Like | Follow | Subscribe to the newsletter.

Catch us on

LinkedIn: https://www.linkedin.com/in/techlatest-net/

Reddit Community: https://www.reddit.com/user/techlatest_net/

Orca Tutorial: Multi-Agent AI Coding Workspace from Scratch

TechLatest — Wed, 08 Jul 2026 14:08:08 +0000

AI coding agents have completely changed the way we build software. Whether it’s Claude Code , Codex , OpenCode , Cursor , or another CLI-based assistant, it can write code, fix bugs, generate documentation, and even help review pull requests. But there’s one problem — most developers still use them one at a time.

You ask one agent a question, wait for the response, compare it manually with another model, switch Git branches, copy code between editors, and repeat the process. It works, but it isn’t the most efficient way to build modern software.

That’s where Orca comes in.

Orca is an open-source AI orchestration workspace that brings your repository, AI coding agents, Git worktrees, terminal, browser, and development tools together in a single application. Instead of choosing just one AI assistant, you can run multiple coding agents in parallel, compare their outputs, review the generated changes, and merge the best implementation into your project — all without leaving Orca.

One of the best things about Orca is that getting started doesn’t have to cost anything. In this guide, we’ll use OpenCode together with a free model from OpenRouter , so you can experience the complete workflow without paying for API credits. If you already have Claude Code, Codex, or another supported CLI agent installed, you can use those as well.

In this guide, we’ll start from scratch by installing Orca, completing the initial setup, connecting our first repository, creating worktrees, launching AI agents, and exploring the features that make Orca one of the most powerful workspaces for AI-assisted software development. Whether you’re an individual developer, an open-source contributor, or part of a large engineering team, this guide will help you get the most out of Orca.

Step 1: Download and Install Orca

The first step is to install Orca on your operating system. Orca is available for macOS, Windows, and Linux , making it easy to get started regardless of your development environment.

Visit the official Orca website and click the Download button. The website automatically detects your operating system and provides the appropriate installer. If you’re using a different platform, you can also choose from the available downloads for macOS (Apple Silicon & Intel), Windows, and Linux.

Note: In this guide, we’re using macOS (Apple Silicon).

After downloading the installer, complete the installation process just like any other desktop application. Once installed, launch Orca from your Applications folder (macOS) or Start Menu (Windows).

Tip: Orca is a desktop application, so no additional configuration is required before launching it for the first time.

Download Options

macOS (Apple Silicon)
macOS (Intel)
Windows (.exe)
Linux (AppImage)
Homebrew (macOS)
AUR (Arch Linux)

If you’re using Homebrew on macOS, you can install Orca directly from the terminal:

brew install --cask stablyai/orca/orca

Step 2: Complete the Getting Started Onboarding

After launching Orca for the first time, you’ll be presented with the Getting Started onboarding wizard. This setup walks you through the core features you’ll use while working with multiple AI coding agents. Completing these steps ensures Orca is configured correctly before you begin creating worktrees and running agents.

The onboarding consists of several setup tasks, and we’ll go through each one in detail.

Step 2.1: Enable Desktop Notifications

The first onboarding task is to turn on notifications.

Desktop notifications are useful because Orca can run AI agents for several minutes, especially when you’re working with large repositories or complex prompts. Instead of constantly checking the application, Orca notifies you whenever an agent:

Completes a task
Requires your attention
Gets blocked or encounters an error

This allows you to continue working on other tasks while Orca runs your agents in the background.

Enable Notifications on macOS

Click Open Mac Settings.
Navigate to Notifications.
Locate Orca in the application list.
Enable Allow Notifications.
(Optional) Choose your preferred notification style, such as banners or alerts.

Once enabled, return to Orca.

Step 2.2: Choose Your Default AI Agent

The next onboarding step is to choose your default agent. Orca automatically detects the AI coding agents installed on your system and lets you select which one should be used by default whenever you create a new worktree or start a new coding session.

This saves time, as you won’t need to manually select your preferred agent every time you begin working on a project.

In our setup, Orca detected the following AI agents already installed on the system:

Claude
OpenCode
Hermes
OpenClaw

Additionally, Orca supports many other CLI-based coding agents, including:

Codex
GitHub Copilot
Grok
OpenClaude
MiMo Code
Continue
Cline
Kiro
Qwen Code
Goose
Amp
Devin
Pi
and many more.

Select Your Preferred Agent

Simply click on the agent you want to use as your default. In this guide, we’ll use Claude as the default AI coding assistant, but you can choose any supported agent based on your workflow.

Once selected, Orca highlights the chosen agent, indicating that it will be used automatically for future tasks.

Step 2.3: Enable Orca CLI

The next onboarding step is to enable the Orca CLI. This installs the orca command on your system and sets up the built-in skills that allow Orca to orchestrate AI agents, interact with browsers, and control your desktop when needed.

Click Install CLI & Skills to begin the installation. Orca will automatically configure everything required in the background.

During the setup, Orca installs three core capabilities:

Agent Orchestration : Allows multiple AI agents to work together on the same project and coordinate multi-step tasks.
Agent Browser Use: Gives agents access to Orca’s built-in browser so they can open web pages, capture screenshots, inspect content, and interact with websites.
Computer Use: Enables agents to control your desktop by moving the mouse, clicking buttons, typing text, and interacting with applications when a workflow requires it.

On macOS, Orca may also request Full Disk Access. Granting this permission is recommended, especially if your projects are stored in protected folders such as Desktop , Documents , or Downloads. This ensures Orca can access and edit your repositories without permission issues.

Once the installation finishes, the setup will be marked as complete, and you’re ready to continue with the next onboarding step: Connect Integrations.

Tip: You can verify the installation at any time by opening a terminal and running:

orca --help

Step 3: Connect Your Integrations

With the initial onboarding complete, the next step is to connect the services you use every day. Orca integrates with tools like GitHub, Linear, and Jira , allowing you to manage your development workflow without constantly switching between applications.

If you’ve already connected your GitHub account, Orca can display the status of your pull requests and repositories directly within the application. This makes it easy to monitor ongoing work while your AI agents continue coding in the background.

For project management, Orca also supports:

Linear — Browse issues, start work directly from a task, and keep your AI-generated changes linked to your project.
Jira — Access Jira Cloud issues, create worktrees from tickets, and track development without leaving Orca.

To connect a service, simply click the corresponding Connect button and authorize your account. Once connected, the integration becomes available throughout Orca, making it easier to move from an issue or task to an AI-powered coding session in just a few clicks.

Note: Connecting GitHub is highly recommended if you’re working with Git repositories. Linear and Jira are optional and can be connected later from Settings if your team uses them.

After connecting the integrations you need, click Done to continue to the next step, Automate Workspace Setup.

Step 4: Automate Workspace Setup

The next step is to automate Workspace Setup. This feature lets Orca automatically run setup commands whenever it creates a new Git worktree. Instead of manually installing dependencies every time you start a new task, Orca can prepare the project for you.

For example, if your project uses pnpm , you can configure the setup command as:

pnpm install

Similarly, you can use commands such as:

npm install

yarn install

bun install

Or any custom setup script required by your project.

Once you’ve entered the command, click Save. From then on, every new worktree created for that repository will automatically execute the setup command, ensuring the environment is ready before your AI agents begin working.

Note: You’ll need to add a Git repository to Orca before configuring workspace automation. This setting is saved per repository, allowing different projects to use different setup commands.

This small automation can save a significant amount of time, especially when you’re working with multiple worktrees or frequently creating new AI coding sessions.

After saving your workspace setup, proceed to the next step: Start Work in Multiple Repositories.

Step 5: Add Your Git Repositories

The final setup step is to Start Work in Multiple Repositories. Instead of opening projects one at a time, Orca lets you add all of your frequently used Git repositories in one place. This makes it easy to switch between projects and start AI-assisted development without searching through folders.

To add a repository:

Click Add Project.
Browse to your local Git repository.
Select the project and import it into Orca.

Repeat the process for any additional repositories you work on regularly. Once added, they’ll appear in your Orca workspace, ready for creating worktrees, launching AI agents, and managing development tasks.

Tip: If you work across multiple client projects or open-source repositories, adding them all upfront makes it much easier to jump between projects without leaving Orca.

At this point, you’ve completed the initial setup. Orca is now configured with your preferred AI agent, CLI tools, integrations, and projects, so you’re ready to start building with AI-powered workflows.

Step 6: Try Multi-Tasking with Multiple Worktrees

Once the basic setup is complete, Orca introduces one of its most powerful features — Multi-tasking. This feature lets you work on multiple tasks simultaneously by creating separate Git worktrees for each one.

Each worktree is completely isolated, even if they belong to the same repository. This means you can develop different features, fix bugs, or experiment with new ideas in parallel without affecting one another.

To explore this feature, click Try it out. Orca will guide you through creating multiple worktrees, each with its own AI agent and dedicated workspace.

For example, you could have:

Worktree 1: Build a user authentication system using Claude.
Worktree 2: Create a new dashboard using Codex.

Both tasks run independently, allowing you to compare progress, review changes, and merge the best implementation when you’re ready.

Why it matters: Instead of waiting for one task to finish before starting another, Orca lets you run multiple AI coding sessions in parallel, helping you prototype, compare solutions, and ship features much faster.

After exploring multi-tasking, proceed to the final milestone: Use Orca’s Browser.

Step 7: Use Orca’s Built-in Browser

The final milestone in the onboarding process is to use Orca’s Browser. Orca includes a built-in Chromium-based browser that lets you inspect and interact with your web application without leaving the workspace.

One of its standout features is Design Mode. Instead of manually describing a UI issue to an AI agent, you can simply click on any element in your application. Orca automatically captures the selected element’s HTML, CSS, and a cropped screenshot , then sends that information directly to the AI agent as part of your prompt.

To enable this feature, click Install CLI & Skill if it hasn’t already been installed. Once enabled, your AI agents can use the browser to inspect pages, capture screenshots, and interact with web applications as part of their workflow.

This is especially useful for tasks such as:

Fixing UI bugs.
Improving layouts and styling.
Updating specific components.
Debugging frontend issues.
Generating design improvements directly from the live interface.

Why it matters: Instead of explaining a UI problem in words or taking screenshots manually, Orca provides your AI agent with the exact HTML, CSS, and visual context it needs, making frontend development much faster and more accurate.

With this step complete, you’ve finished the Getting Started guide. Your Orca workspace is now fully configured, and you’re ready to create your first project, launch AI agents, and start building with parallel worktrees.

Step 8: Verify the Orca CLI Installation

Although we installed the Orca CLI during the onboarding process, it’s a good idea to verify that everything has been configured correctly before moving on.

Open a new terminal and run:

orca --help

If the installation was successful, Orca will display the list of available commands and options instead of showing a command not found error.

You can also check the installed version by running:

orca --version

Seeing the version number confirms that the CLI is installed correctly and is available from your terminal.

From this point onward, you’ll be able to use the orca command to create worktrees, automate workflows, interact with browsers, and perform other tasks directly from the command line.

Step 9: Clone Your First Repository in Orca

Now that the onboarding is complete, it’s time to add your first project to Orca. Instead of cloning the repository from the terminal, Orca can clone it directly from a Git URL, making it quick to import a project and start working with AI agents.

Click Add Project , then choose Clone from URL. A dialog box will appear where you need to provide the repository details.

Fill in the Repository Details

Enter the following information:

Git URL: Paste the HTTPS or SSH URL of the Git repository you want to clone.
Parent Folder: Select the local directory where Orca should clone the repository.

For this guide, we’ll clone the official Orca repository:

https://github.com/stablyai/orca

Choose a destination folder on your machine — for example:

/Users/abcd/orca

After verifying both fields, click Clone.

Orca will download the repository, register it as a project, and prepare it for creating worktrees and launching AI coding agents.

Tip: You can clone any Git repository hosted on GitHub, GitLab, Bitbucket, or any Git server, provided you have the necessary access permissions.

Once the cloning process is complete, the repository will appear in your Orca workspace, and you’ll be ready to create your first worktree and start coding with AI agents in the next step.

Step 10: Explore the Orca Workspace

Once the repository has been cloned successfully, Orca opens it in its main workspace. This is where you’ll spend most of your time managing projects, launching AI agents, reviewing code, and working with multiple Git worktrees.

Let’s take a quick tour of the interface.

Projects Panel

On the left side, you’ll find the Projects panel. Every repository you add to Orca appears here, making it easy to switch between projects without leaving the application.

In our workspace, you can see two projects:

agentic-ai-ecosystem
orca

Each project displays its active Git branch, helping you quickly identify the repository you’re currently working on.

Integrated Terminal

The center of the workspace contains Orca’s built-in terminal. This behaves like a regular terminal, allowing you to run Git commands, install dependencies, start development servers, or execute any command required by your project — all without switching to another terminal application.

For example, you can run commands such as:

git status

pnpm install

pnpm dev

Or any other project-specific commands directly from the integrated terminal.

File Explorer

On the right side is the File Explorer , where you can browse your repository’s folders and files.

You’ll see the complete project structure, including directories like:

docs
src
mobile
native
tests
resources

You can expand folders, search for files, and open them directly inside Orca without needing a separate code editor.

Why This Workspace Matters

Orca combines your Git repositories , terminal , and project files into a single interface. As you continue through this guide, this workspace will also be used to create AI worktrees, launch coding agents, compare implementations, and review generated code.

With your repository now imported and the workspace ready, you’re all set to create your first AI worktree and begin building with Orca in the next step.

Step 11: Create Your First AI Worktree

This is where Orca starts to shine.

Click the + button or Create Worktree
Choose the Orca repository
Give the worktree a name (for example, documentation-update)
Select your default agent (Claude, Codex, OpenCode, etc.)
Enter a prompt
Create the worktree

This is the first real AI workflow.

Step 12: Launch Your First AI Coding Agent

With the worktree created, it’s time to start your first AI coding session. Orca supports multiple CLI-based coding agents, and for this guide we’ll use OpenCode.

When creating the worktree, we selected OpenCode as our AI coding agent. Because of that, Orca opens an OpenCode session inside the integrated terminal for this worktree, allowing us to immediately start chatting with the AI and assign coding tasks.

In this guide, we’re using the Poolside Laguna XS 2.1 (Free) model through OpenRouter. OpenRouter offers a variety of free AI models that you can use by simply adding your OpenRouter API key to OpenCode. At the time of writing, the model shown in our setup is poolside/laguna-xs-2.1:free , which is available free of charge for coding tasks.

You can also explore many other free models available on OpenRouter, including coding, reasoning, and general-purpose LLMs, and switch between them depending on your use case.

Why Use OpenRouter?

Using OpenRouter gives you several advantages:

Access to multiple AI models with a single API key.
Easily switch between free and paid models.
Compare different coding models without changing your workflow.
Experiment with the latest open-source models as they become available.

Start Your First Prompt

Now that OpenCode is running, simply type your prompt into the chat box. For example:

Analyze this repository and explain its architecture.

Review this codebase and suggest improvements for performance and maintainability.

Find potential bugs and recommend fixes.

Once you submit the prompt, OpenCode begins analyzing your repository and generates code, explanations, or suggestions directly within the worktree. From here, you can continue the conversation, refine the output, or compare the results with other AI agents by creating additional worktrees.

Step 15: Let the Agent Modify the Project

Now ask something like:

Improve the README.

Add installation instructions.

Create a CONTRIBUTING.md file.

Then demonstrate:

AI editing files.
Git diff.
Changed files.

Step 16: Review and Accept the Changes

Show:

Changed files.
Diff viewer.
Git status.
Commit changes.

Step 17: Compare Another Agent

This is where Orca becomes unique.

Create another worktree.

Choose Claude , Codex , or another supported agent.

Give the same prompt.

Compare:

Speed
Code quality
Explanation
Files changed

This demonstrates Orca’s biggest advantage: parallel AI development.

Conclusion

Orca is more than just another AI coding tool — it’s a complete workspace designed for modern AI-assisted software development. By bringing together Git worktrees, multiple AI coding agents, an integrated terminal, browser automation, and powerful collaboration features, Orca makes it easy to experiment with different approaches, compare results, and ship better code faster.

In this guide, we covered everything from installing Orca and completing the initial setup to creating worktrees, launching AI agents, and working with free models through OpenRouter. Whether you’re building solo projects, contributing to open source, or collaborating with a team, Orca provides a flexible workflow that keeps everything in one place.

Now it’s your turn. Install Orca, connect your favorite AI coding agent, create your first worktree, and experience how parallel AI development can streamline your workflow. As Orca continues to evolve with new features and integrations, it’s quickly becoming one of the most capable platforms for developers building with AI.

Thank you so much for reading

Like | Follow | Subscribe to the newsletter.

Catch us on

LinkedIn: https://www.linkedin.com/in/techlatest-net/

Reddit Community: https://www.reddit.com/user/techlatest_net/

How to Automatically Document Your Repository with OpenWiki

TechLatest — Tue, 07 Jul 2026 11:37:18 +0000

OpenWiki is a CLI that writes and maintains agent documentation for your codebase and can keep it fresh by opening PRs from CI.

Reference: langchain-ai/openwiki

What you’ll have at the end

OpenWiki installed and verified
A generated openwiki/ folder in a sample repository
A local update workflow: openwiki --update
A CI path to keep docs updated automatically (PR-based)

Part 1 — Install OpenWiki

Prerequisites

Node.js 18+: OpenWiki is a Node CLI

Git: Docs generation is repo-aware

An LLM provider key: Stored locally by OpenWiki (see below)

Install (global)

npm install -g openwiki

Verify

openwiki --help

Expected output (v0.0.1):

  _____ ___ _ _ 
 / _ \ _ _____ _ __ \ \ / (_) | _(_)
| | | | '_ \ / _ \ '_ \ \ \ /\ / /| | |/ / |
| |_| | |_) | __/ | | | \ V V / | | <| |
 \ ___/| .__ / \___|_| |_| \_/\_/ |_|_|\_\_|
      |_|

╭─────────────────────────────────────────────────────────────────────────────╮
│ >_ OpenWiki v0.0.1 agent docs for codebases │
│ provider: OpenRouter │
│ model: z-ai/glm-5.2 │
│ directory: …/agentic-ai-ecosystem/guides/openwiki │
╰─────────────────────────────────────────────────────────────────────────────╯

# Usage
   openwiki [--modelId <model>]
   openwiki [--modelId <model>] [message]
   openwiki --init [message]
   openwiki --update [message]

# Options
    --init Generate initial OpenWiki documentation.
    --update Update existing OpenWiki documentation.
    -p, --print Run once and print the final assistant output.
    --modelId <id> Use a model ID for this run.

Your provider and model come from ~/.openwiki/.env (configured on first interactive run).

Part 2 — Understand the core commands

OpenWiki usage patterns from upstream README:

Interactive : openwiki
Start with a request : openwiki "Please generate documentation for this repository"
One-shot print : openwiki -p "Summarize what you can do"
Initialize : openwiki --init
Update existing docs : openwiki --update

Part 3 — Configure provider & credentials

OpenWiki reads provider settings from ~/.openwiki/.env. For non-interactive commands (-p, --init, --update), Credentials must also be exported in your shell — OpenWiki will not prompt you.

This guide uses local Ollama as the primary path ($0, no rate limits). OpenRouter (cloud) is documented as an alternative.

Option A — Local Ollama with qwen2.5:1.5b

OpenWiki v0.0.1 does not yet ship the openai-compatible Provider from the upstream README. Use the built-in openai provider and point it at Ollama’s OpenAI-compatible API on localhost:11434.

Step 3.1 — Verify Ollama is running

ollama list

Expected output:

NAME ID SIZE MODIFIED
qwen2.5:1.5b 65ec06548149 986 MB …

If Ollama is not installed, see Ollama Small Models.

Pull the model if missing:

ollama pull qwen2.5:1.5b

Step 3.2 — Write ~/.openwiki/.env

Important: remove any OPENROUTER_API_KEY line from this file. If it’s present, OpenWiki v0.0.1 keeps routing to OpenRouter even when you set another provider.

mkdir -p ~/.openwiki

cat > ~/.openwiki/.env <<'EOF'
OPENWIKI_PROVIDER=openai
OPENAI_API_KEY=ollama
OPENWIKI_MODEL_ID=qwen2.5:1.5b
EOF

chmod 600 ~/.openwiki/.env

Step 3.3 — Export Ollama base URL (required every session)

OPENAI_BASE_URL is not loaded from ~/.openwiki/.env in v0.0.1 (it’s on OpenWiki’s deprecated key list). Export it in your shell:

export OPENAI_BASE_URL=http://localhost:11434/v1
set -a && source ~/.openwiki/.env && set +a

Step 3.4 — Test print mode

cd guides/openwiki
openwiki -p "Summarize what OpenWiki can do"

Example output (connection verified on qwen2.5:1.5b):

OpenWiki is designed to provide information based on structured data from various
online sources, including Wikipedia. It aims to retrieve specific facts and statistics
about different topics efficiently…

Quality note: A 1.5B model may hallucinate on OpenWiki’s large agent prompt (~46 KB + 9 tools). The test above proves Ollama → OpenWiki → response works. For --init doc generation, consider ollama pull llama3.2:3b if output quality is weak.

Option B — OpenRouter

Use OpenRouter if you prefer cloud models or don’t have Ollama installed.

Step 3.6 — Create OpenRouter API key

Sign up at openrouter.ai
Create a key at openrouter.ai/keys

Step 3.7 — Write ~/.openwiki/.env for OpenRouter

cat > ~/.openwiki/.env <<'EOF'
OPENWIKI_PROVIDER=openrouter
OPENROUTER_API_KEY=your-key-here
OPENWIKI_MODEL_ID=meta-llama/llama-3.2-3b-instruct:free
EOF

chmod 600 ~/.openwiki/.env

Step 3.8 — Export and test

set -a && source ~/.openwiki/.env && set +a
openwiki -p "Summarize what OpenWiki can do"

If you skip exporting credentials, you will see:

OPENROUTER_API_KEY is required for non-interactive runs. Run openwiki in an interactive terminal to save credentials.

Fix paths:

OpenRouter free models (no token cost)

Append :free to any model that offers a free tier:

List all free models:

curl -s https://openrouter.ai/api/v1/models \
  | python3 -c "
import json,sys
for m in json.load(sys.stdin)['data']:
    p=m.get('pricing') or {}
    if p.get('prompt')=='0' and p.get('completion')=='0':
        print(m['id'])
"

Per-run model override:

openwiki -p --modelId meta-llama/llama-3.2-3b-instruct:free "Summarize what OpenWiki can do"

Diagnose OpenRouter issues

source ~/.openwiki/.env

# Account limits
curl -s [https://openrouter.ai/api/v1/key](https://openrouter.ai/api/v1/key) \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" | python3 -m json.tool

# Tiny free-model test
curl -s [https://openrouter.ai/api/v1/chat/completions](https://openrouter.ai/api/v1/chat/completions) \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"meta-llama/llama-3.2-3b-instruct:free","messages":[{"role":"user","content":"hi"}]}' \
  | python3 -m json.tool

Provider comparison (this guide)

Part 4 — One-shot print mode (-p)

Print mode runs one request and exits — ideal for scripts, smoke tests, and CI logs.

After completing Part 3 (Ollama or OpenRouter), every non-interactive run needs:

# Ollama path — export base URL every session
export OPENAI_BASE_URL=http://localhost:11434/v1
set -a && source ~/.openwiki/.env && set +a

# OpenRouter path — source env only
# set -a && source ~/.openwiki/.env && set +a

Then:

cd guides/openwiki
openwiki -p "Summarize what OpenWiki can do"

Other useful print-mode prompts:

openwiki -p "Please generate documentation for this repository"
openwiki -p --modelId qwen2.5:1.5b "List the main folders in this repo"

Part 5 — Initialize a repo (--init)

Run this inside a repo you want to document. Export Ollama env first if using Part 3 → Option A :

export OPENAI_BASE_URL=http://localhost:11434/v1
set -a && source ~/.openwiki/.env && set +a

cd guides/openwiki
openwiki --init

Or with a starting message:

openwiki --init "Please generate documentation for this repository"

What --init does (from upstream README):

Creates initial docs under openwiki/ if no wiki exists
Configures provider + model + API key on first run (saved to ~/.openwiki/.env)
May append prompting to AGENTS.md and/or CLAUDE.md to help coding agents reference the docs

Part 6 — Generate docs for a repo

From the repo root:

openwiki "Please generate documentation for this repository"

If you want a one-shot output that exits (good for CI logs), use print mode:

openwiki -p "Please generate documentation for this repository"

Part 7 — Update docs after changes (--update)

After you change the code, rerun:

openwiki --update

Update — verified recording

Part 8 — CI: keep docs updated via PRs

OpenWiki’s recommended approach is to run updates in CI and open a PR when docs drift.

From upstream README:

GitHub Actions: copy openwiki-update.yml into .github/workflows/openwiki-update.yml
GitLab CI: copy openwiki-update.gitlab-ci.yml into your pipeline

In this repo, we’ll keep the CI snippet inside the guide and only add it to a real project when you’re ready.

Part 9 — Provider configuration (reference)

OpenWiki supports multiple providers out of the box (from upstream README):

OpenRouter
Fireworks
Baseten
OpenAI
OpenAI-compatible endpoint (e.g. a LiteLLM gateway)
Anthropic

OpenWiki saves provider configuration and secrets to ~/.openwiki/.env. For non-interactive commands (-p, --init, --update in CI), export them first:

set -a && source ~/.openwiki/.env && set +a

OpenRouter

OPENWIKI_PROVIDER=openrouter
OPENROUTER_API_KEY=your-key
OPENWIKI_MODEL_ID=meta-llama/llama-3.2-3b-instruct:free

List free models on your machine:

curl -s https://openrouter.ai/api/v1/models \
  | python3 -c "
import json,sys
for m in json.load(sys.stdin)['data']:
    p=m.get('pricing') or {}
    if p.get('prompt')=='0' and p.get('completion')=='0':
        print(m['id'])
"

Per-run override:

openwiki -p --modelId meta-llama/llama-3.2-3b-instruct:free "Summarize what OpenWiki can do"

Anthropic-compatible gateway

OPENWIKI_PROVIDER=anthropic
ANTHROPIC_API_KEY=your-key
ANTHROPIC_BASE_URL=https://your-gateway.example.com/anthropic

Local Ollama (qwen2.5:1.5b)

Full step-by-step setup is in Part 3 → Option A. Summary:

OPENWIKI_PROVIDER=openai
OPENAI_API_KEY=ollama
OPENWIKI_MODEL_ID=qwen2.5:1.5b
# + export OPENAI_BASE_URL=http://localhost:11434/v1 in shell

OpenAI-compatible gateway (future / upstream README)

The upstream README documents OPENWIKI_PROVIDER=openai-compatible — not in npm v0.0.1 yet. Use the Ollama + openai provider workaround in Part 3 until a newer release adds it.

Part 10 — Troubleshooting

Insufficient credits (402) on a :free model

Three common causes:

Negative account balance — OpenRouter blocks all requests (even free) if the balance < 0. Fix: openrouter.ai/settings/credits → add credits until the balance is positive.
Prompt too large for free tier — OpenWiki’s agent sends ~46 KB + 9 tools. Free accounts may reject this with a 402. Fix: use local Ollama (Part 3 → Option A) or add OpenRouter credits.
Paid model by mistake — e.g. z-ai/glm-5.2 without :free. Fix: OPENWIKI_MODEL_ID=meta-llama/llama-3.2-3b-instruct:free

Diagnose your key + free model (small request)

source ~/.openwiki/.env

# Account limits / balance
curl -s [https://openrouter.ai/api/v1/key](https://openrouter.ai/api/v1/key) \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" | python3 -m json.tool

# Tiny free-model test (should work if account is healthy)
curl -s [https://openrouter.ai/api/v1/chat/completions](https://openrouter.ai/api/v1/chat/completions) \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"meta-llama/llama-3.2-3b-instruct:free","messages":[{"role":"user","content":"hi"}]}' \
  | python3 -m json.tool

If the curl test works but openwiki -p fails , the issue is OpenWiki’s large tool payload — switch to Ollama.

Insufficient credits (402 Payment Required) — paid model

You picked a paid model (e.g. z-ai/glm-5.2). Switch to a free model:

# In ~/.openwiki/.env — small free model (3B)
OPENWIKI_MODEL_ID=meta-llama/llama-3.2-3b-instruct:free

Then re-export and retry:

set -a && source ~/.openwiki/.env && set +a
openwiki -p "Summarize what OpenWiki can do"

OPENROUTER_API_KEY is required for non-interactive runs

You ran openwiki -p … Without exporting credentials. Either:

Run openwiki interactively once to create ~/.openwiki/.env, then set -a && source ~/.openwiki/.env && set +a, or
Pass OPENROUTER_API_KEY=… Inline for that command.

command not found: openwiki

Re-run npm install -g openwiki
Confirm your npm global bin is on PATH

Provider/API key prompts keep reappearing

Ensure ~/.openwiki/.env exists and is writable
Confirm you’re running the same user account in the terminal

Docs look stale

Re-run openwiki --update
Ensure you’re in the repo root (OpenWiki is repo-context aware)

Conclusion

OpenWiki makes it easy to generate and maintain documentation that evolves alongside your codebase. Instead of spending hours writing architecture notes, onboarding guides, and repository documentation manually, you can let OpenWiki analyze your project, generate an initial knowledge base, and keep it up to date as your code changes.

In this guide, you learned how to install OpenWiki, configure it with either a local Ollama model or OpenRouter, generate documentation for a repository, update existing docs, and automate the entire workflow using CI. Whether you’re documenting an open-source project, an internal developer platform, or a production application, OpenWiki helps ensure your documentation stays accurate without becoming another maintenance burden.

For the best experience, local Ollama provides a cost-free solution with unlimited usage, while OpenRouter gives you access to a wide range of cloud models when you need higher-quality outputs. Once your setup is complete, a simple openwiki --update after major code changes—or an automated CI workflow—can keep your documentation synchronized with your repository.

As AI-powered development becomes more common, keeping documentation current is just as important as writing good code. OpenWiki brings that process into your development workflow, making high-quality, always-updated documentation something your team can rely on rather than postpone.

Thank you so much for reading

Like | Follow | Subscribe to the newsletter.

Catch us on

LinkedIn: https://www.linkedin.com/in/techlatest-net/

ZeroClaw Agent Masterclass — Full Tutorial

Reddit Community: https://www.reddit.com/user/techlatest_net/

TechLatest AI & Tech Weekly #23

TechLatest — Mon, 06 Jul 2026 09:33:55 +0000

Welcome to this week’s edition of TechLatest AI & Tech Weekly 👋

Here’s a curated roundup of our latest blogs, notable product launches, and the most interesting AI & ML updates from June 29–July 05, 2026.

AI/ML News Roundup: June 29–July 05, 2026

TL;DR

Anthropic launched Claude Sonnet 5 , bringing stronger agentic coding, reasoning, and enterprise AI capabilities.
Open-source AI continued to accelerate with releases like WebBrain , EverOS , OpenScience , Diffusion Gemma ASR , TabFM , Nemotron Labs TwoTower , and LlamaIndex legal-kb.
OpenAI announced major infrastructure breakthroughs , including over 50% lower inference costs and its first custom AI chip, Jalapeño.
Google expanded its AI ecosystem with new Gemini models, Android 17 AI features, Chrome 150, TabFM, and developer-focused tools.
AI investment remained strong , with billion-dollar funding rounds, large-scale enterprise deployments, and rapid infrastructure expansion across the industry.
Governments accelerated AI adoption and regulation , introducing new cybersecurity initiatives, AI policies, and large public-sector deployments.
TechLatest published four new Agent Masterclass tutorials covering ZeroClaw , OpenClaude , PicoClaw , and Google agents-cli , helping developers build and deploy modern AI agents.

Open-Source AI, AI Agents, Voice AI & Developer Releases

Meet WebBrain

WebBrain is an open-source, local-first browser agent that understands webpages and automates browser tasks directly inside Chrome and Firefox. By running locally, it keeps browsing data private while enabling intelligent web automation. Source

Diffusion Gemma ASR Small Released

Interfaze introduced Diffusion Gemma ASR Small , an open-source speech recognition model that uses a diffusion-based decoder for multilingual transcription across six languages. Source

Google Health API Gets a CLI

The new ghealth CLI brings command-line access to the Google Health API, making it easier for developers to work with Fitbit and other health-related datasets directly from the terminal. Source

Meet EverOS

EverOS is an open-source, Markdown-first memory runtime for AI agents featuring hybrid BM25 + vector retrieval and self-evolving skills to improve long-term agent memory. Source

Google AI Introduces TabFM

Google AI unveiled TabFM , a hybrid attention-based foundation model built specifically for tabular data, enabling zero-shot classification and regression without task-specific training. Source

NVIDIA Releases Nemotron Labs TwoTower

NVIDIA introduced Nemotron Labs TwoTower , a new retrieval model designed to improve embedding quality and large-scale information retrieval for modern AI applications. Source

LlamaIndex Launches legal-kb

LlamaIndex introduced legal-kb , a reference application demonstrating agentic retrieval with Index v2. It enables AI agents to autonomously search, read, and navigate large knowledge bases using four built-in retrieval tools. Source

Synthetic Sciences Releases OpenScience

OpenScience is a new open-source, model-agnostic AI workbench built for scientific research across machine learning, biology, chemistry, and physics. Licensed under Apache 2.0, it runs on your own infrastructure and supports reproducible research workflows with any foundation model, positioning itself as an open alternative to proprietary AI research platforms. Source

Hugging Face & Open-Source Ecosystem

Mistral released Leanstral 1.5 on June 30, 2026, an AI for automated theorem proving supporting Lean 4 proof work, continuing Mistral’s commitment to open-weight models for specialized tasks. Source
LongCat-2.0 , a Chinese-made AI model with 1.6 trillion parameters , emerged in late June, achieving performance comparable to Gemini 3.1 Pro without using an NVIDIA AI chip, demonstrating the growing viability of non-NVIDIA hardware for frontier training. Source
OpenRouter released Fusion on July 1, 2026, a tool that runs prompts across multiple models simultaneously (Gemini 3 Flash, Kimi K2.6, DeepSeek V4 Pro) and synthesizes outputs into a single response, with a budget panel scoring 64.7% on DRACO , within one percentage point of Fable 5’s 65.3%. Source
OpenAI engineers found a way to reduce AI inference costs by more than 50% , a breakthrough that could significantly change the economics of deploying frontier models at scale. Source

Frontier Model Advancements & Agentic Capabilities

Anthropic launched Claude Sonnet 5 on June 30, 2026, and released it as generally available on July 1, 2026, making it the default model for every Free and Pro user worldwide starting July 1. Source
Claude Sonnet 5 performs close to Opus 4.8 on many tasks at introductory pricing through August 31 of $2/$10 per million tokens (input/output), less than Sonnet 4.6’s cost. Source
Sonnet 5 benchmark results : 63.2% on agentic coding (SWE-bench Pro equivalent), 81.2% on OSWorld-Verified, 80.4% on Terminal-Bench 2.1, 57.4% on Humanity’s Last Exam with tools, and 84.7% on BrowseComp 25. Source
US government lifted restrictions on Claude Fable 5 and Claude Mythos 5 on July 1, 2026, after weeks of negotiations with the Trump administration, allowing the release of Sonnet 5 and signaling a shift in AI policy. Source
Fable 5 was greenlit to return after weeks of negotiations with the Trump administration and the conditional return of its export restrictions, with the hero model now available for enterprise and government use. Source
GPT-5.6 Sol is confirmed to deploy on Cerebras wafer-scale hardware in July 2026 for select customers, targeting up to 750 tokens per second (approximately 15x faster than the current 50 tokens/second baseline serving). Source
Claude Mythos discovered Squidbleed (CVE-2026–47729), a 29-year-old memory leak vulnerability in the Squid proxy server that survived 29 years of human code reviews, as part of Anthropic’s Project Glasswing defensive security research program.
Project Glasswing partners confirmed 23,019 vulnerabilities from Claude Mythos analysis across 1,000 open-source projects in the first month of the program, with a 90.6% confirmation rate on independent sampling.

Massive Funding Rounds Reshaping Valuations

Etched , an Nvidia competitor, secured $1 billion in sales at a $5 billion valuation due to high demand for AI chips by July 1, 2026. Source
Wayve launched an $85 million employee tender offer at an $8.5 billion valuation , demonstrating significant investment in autonomous driving technology. Source
Amazon established a $1 billion FDE organization focused on deploying purpose-built AI agents within companies. Source
Realta Fusion announced a successful fusion reaction breakthrough , potentially revolutionizing sustainable energy, though specific funding details remain undisclosed. Source
Alphabet (Google) lost $269B on an AI talent exodus, with a $280B stake lost in just one day, reflecting the market’s reaction to AI personnel shifts.

Practical Product Launches for Developers & Enterprises

Claude Science launched on July 1, 2026 , a dedicated AI application targeting scientific research workflows with an initial focus on drug discovery, protein structure analysis, genomics, and computational biology , building on the acquisition of Coefficient Bio (approximately $400 million all-stock in June 2026) and the hire of Nobel laureate John Jumper from Google DeepMind. Source
California signed a landmark Anthropic deal on June 29, 2026, the largest US state government AI deployment in history, giving every California state agency and participating local governments access to Claude at a 50% discount through the new Statewide Information Technology Shared Services portal, with free workforce training and technical assistance. Source
Google released two new image-generation models on June 30, 2026: Gemini 3.1 Flash Image at $0.50/$3.00 input/output per million tokens and Gemini 3 Pro Image at $2.00/$12.00, both available immediately through Google AI Studio and the Gemini API.
Google announced Nano Banana 2 Lite (faster and cheaper image generation model) and Gemini Omni Flash (video generation model) on July 1, 2026.
Grok 4.3 is now available on Amazon Bedrock as of July 1, 2026, priced at $1.25/$2.50 per million tokens (input/output), making it the most affordable major-lab model on Bedrock with a 131K context window.
Anthropic announced Claude’s general availability on Microsoft Azure AI Foundry with GB300 Blackwell Ultra GPUs, marking the first deployment of Claude on NVIDIA GB300 Blackwell Ultra GPUs with Quantum-X800 InfiniBand networking.
Google released Android 17 with Gemini Omni integrated at the OS level, alongside Lyria 3 (music generation model) and AudioLM translation capabilities, framing it as groundwork for “GemINI Intelligence,” the company’s broader agentic OS initiative.
OpenAI added Record and Replay to ChatGPT Business for the Codex macOS app , letting eligible Business users demonstrate a workflow once and convert it into a reusable skill.
Google released the stable version of Google Chrome 150 on July 1, 2026, enabling features like adjusting font sizes to fit frames and creating gradient borders using only CSS.
NotebookLM introduced TikTok-style clips on July 1, 2026, adding a new social content creation capability.

Governance, Ethics & Regulation

The Five Eyes intelligence alliance issued a rare joint statement titled “The AI Shift in Cyber Risk: Why Leaders Must Act Now” on June 22, 2026, signed by representatives of Australia’s ASD, Canada’s CSE, New Zealand’s GCSB, UK’s GCHQ, and US’s NSA and CISA, stating: “Frontier AI models are anticipated to exceed current industry expectations… The timeline is not years, it is months”.
The Economist reported that an Anthropic AI agent was able to penetrate nearly all classified systems managed by the NSA and US Cyber Command within hours in an undisclosed assessment, the clearest public indication of what Five Eyes agencies have tested.
CISA added CVE-2026–42271 to its Known Exploited Vulnerabilities (KEV) catalog on June 27, 2026, an unauthenticated remote code execution chain in LiteLLM’s AI Gateway that exploits MCP endpoints to gain full access to server environments, including all configured OpenAI and Anthropic API keys.
A coalition of 42 state attorneys general launched a sweeping investigation into OpenAI on June 29–July 1, 2026, with New York’s AG already serving subpoenas ahead of OpenAI’s anticipated IPO, covering advertising claims, the company’s documented sycophancy problem, data handling practices, health data management, and treatment of minors and seniors.
CISA cut the mandatory federal patch deadline to 3 days, citing AI threats directly, as recommended in the Five Eyes statement.
The US Pentagon added Alibaba to its list of Chinese military companies (a designation the company is contesting in court), which includes BYD, Baidu, Unitree, and 188 other entities described as directly controlled by the Chinese military.
US government lifted restrictions on Claude Fable 5 and Claude Mythos 5 on July 1, 2026, after weeks of negotiations with the Trump administration, marking a policy shift.

Infrastructure & Hardware

OpenAI and Broadcom unveiled Jalapeño on July 1, 2026, OpenAI’s first custom-designed AI chip, with engineering samples delivered on June 24, 2026, designed for LLM inference (not training) and manufactured by TSMC.
Jalapeño delivers approximately 50% lower inference cost per token than current-generation Nvidia GPUs , with performance matching Nvidia Blackwell and Google TPUs.
Broadcom expects a small prototype data center deployment by the end of 2026 , with production ramp in 2027 and full scale in the first half of 2028.
OpenAI and Broadcom committed to deploying OpenAI-designed accelerators at a 10-gigawatt scale with Microsoft and other partners through 2029.
GPT-5.6 Sol deployments on Cerebras wafer-scale hardware target up to 750 tokens per second, approximately 15x faster than current GPU-based serving at ~50 tokens/second.
xAI’s Grok 5 is still in training on Colossus 2 (expanded to 1.5 GW), with Polymarket closed June 30 contracts for Grok 5 at approximately 3% probability of release in Q3 2026.
Anthropic is paying SpaceX $1.25 billion per month for access to over 220,000 Nvidia processors at the Colossus 1 facility in Memphis, with the contract running through May 2029.
California’s 300,000 state government workers represent a large-scale real-world test of whether Claude can deliver measurable productivity gains in government workflows, with Poppy (AI assistant built by state workers) piloted with 2,800 employees across 67 departments and on track for full statewide rollout in July 2026.

Blogs We Published This Week

ZeroClaw Agent Masterclass — Full Tutorial

A complete beginner-to-advanced guide to ZeroClaw , covering installation, configuration, architecture, gateway setup, tool integrations, memory, providers, and real-world automation workflows. Perfect for developers looking for a lightweight, self-hosted AI agent.

OpenClaude Agent Masterclass — Full Tutorial

A comprehensive guide to OpenClaude , showing how to install, configure, customize, and extend the open-source AI coding agent for everyday development tasks.

OpenClaude Agent Masterclass — Full Tutorial

PicoClaw Agent Masterclass — Full Tutorial

An end-to-end tutorial covering PicoClaw , the lightweight AI agent designed for low-resource environments, edge devices, and fast deployments. Learn installation, configuration, and practical use cases.

PicoClaw Agent Masterclass — Full Tutorial

Google agents-cli Agent Masterclass — Full Tutorial

A complete walkthrough of Google agents-cli , covering installation, commands, skills, Google Cloud integration, and how to build production-ready AI agents on Google’s enterprise agent platform.

Google agents-cli Agent Masterclass — Full Tutorial

Thank you so much for reading

Like | Follow | Subscribe to the newsletter.

Catch us on

LinkedIn: https://www.linkedin.com/in/techlatest-net/

Reddit Community: https://www.reddit.com/user/techlatest_net/

Google agents-cli Agent Masterclass — Full Tutorial

TechLatest — Fri, 03 Jul 2026 16:20:24 +0000

Everything you need to install, run, and build extraordinary agents with Google agents-cli — the CLI and skills that turn your coding assistant into an ADK + Google Cloud expert.

Official: github.com/google/agents-cli · Docs: google.github.io/agents-cli · Quickstart: Build Your First Agent

What you’ll have at the end

agents-cli v1.0+ installed and verified
Skills loaded into your coding agent (Cursor, Claude Code, Codex, Antigravity)
A scaffolded ADK agent project with eval boilerplate
Understanding of scaffold → build → eval → deploy → observe lifecycle
Ideas for extraordinary multi-tool, multi-agent, and RAG projects

Introduction — agents-cli is not another chatbot

agents-cli is Google’s Agent Development Lifecycle toolchain for the Gemini Enterprise Agent Platform. It wraps the Agent Development Kit (ADK) with:

CLI commands — scaffold, run, eval, deploy, publish
7 agent skills — workflow, ADK code, scaffold, eval, deploy, publish, observability
Coding-agent integration — works with Claude Code, Codex, Antigravity — not instead of them

Official Google Cloud agent stack architecture

Source: google/agents-cli architecture

Part 1 — Prerequisites

uv: docs.astral.sh/uv

API access (local): AI Studio API key or agents-cli login for GCP

You do not need Google Cloud for local prototype work — an AI Studio key is enough for run and eval.

Part 2 — Install agents-cli

Full setup (CLI + skills)

uvx google-agents-cli setup

This installs the CLI and pushes skills to detected coding agents.

Skills only

npx skills add google/agents-cli

Your coding agent reads skills and invokes agents-cli Commands on your behalf.

Verify

uvx google-agents-cli --version # agents-cli, version 1.0.0
uvx google-agents-cli --help

Part 3 — Authenticate

uvx google-agents-cli login --status
uvx google-agents-cli login -i # interactive: GCP or AI Studio

For local dev , set it in your project .env:

GOOGLE_GENAI_USE_VERTEXAI=FALSE
GOOGLE_API_KEY=your-aistudio-key

uvx google-agents-cli info

Shows: project name, deployment target, agent directory, region, A2A support.

Part 4 — The 7 agent skills

Prompt pattern: “Use agents-cli to build …” activates the right skills automatically.

Part 5 — Scaffold your first agent

Prototype mode (no cloud deploy)

uvx google-agents-cli create caveman-agent --prototype --yes
cd caveman-agent
uvx google-agents-cli install

Creates:

caveman-agent/
├── app/agent.py # ADK root agent
├── agents-cli-manifest.yaml
├── tests/eval/ # eval datasets + config
├── pyproject.toml
├── Dockerfile
└── GEMINI.md # agent dev instructions

Check project config

uvx google-agents-cli info

Shows: project name, deployment target, agent directory, region, A2A support.

Part 6 — Build the caveman compressor (official tutorial)

Google’s quickstart tutorial walks through a caveman compressor — verbose text → terse grunts.

Tell your coding agent:

Use agents-cli to build a caveman-style agent that compresses verbose text into terse, technical grunts

Or edit app/agent.py directly — see examples/caveman-agent.py:

Save spec first: examples/agents-cli-spec.caveman.md → .agents-cli-spec.md

from google.adk.agents import Agent
from google.adk.apps import App
from google.adk.models import Gemini
from google.genai import types

root_agent = Agent(
    name="caveman_agent",
    model=Gemini(
        model="gemini-flash-latest",
        retry_options=types.HttpRetryOptions(attempts=3),
    ),
    instruction="""You caveman compressor. Human give long words, you make short.
Rules:
- No articles. No filler. No fluff.
- Short grunts. Simple words.
- Keep technical terms but grunt around them.
- Funny but meaning stays.

Example input: "I would like to deploy the application to production"
Example output: "Me deploy. Production. Now."
""",
)

app = App(root_agent=root_agent, name="app")

Part 7 — Run locally

uvx google-agents-cli run "Please help me understand deployment options for my project"

Starts a local server (default port 18080 ), runs one turn, stops.

uvx google-agents-cli playground # web UI for manual chat
uvx google-agents-cli run --start-server # keep server warm for repeated prompts

Expected caveman output:

Deploy options: Agent Runtime, Cloud Run, GKE. Pick one. Ship.

Part 8 — Evaluate (the most important phase)

agents-cli ships 17+ built-in metrics :

uvx google-agents-cli eval metric list

Includes: FINAL_RESPONSE_QUALITY, INSTRUCTION_FOLLOWING, TOOL_USE_QUALITY, SAFETY, HALLUCINATION, multi-turn variants.

Run evals

uvx google-agents-cli eval generate # run agent on dataset → traces
uvx google-agents-cli eval grade # LLM-as-judge scoring
# Or chained:
uvx google-agents-cli eval run

Critical rule: Never assert LLM output in pytest — use eval, not unit tests, for behavioral quality.

Iterate 5–10+ times until thresholds are passed. Tell your coding agent:

The greeting test is too polite. Make it more caveman. Re-run eval.

Advanced: eval dataset synthesize, eval compare, eval analyze, eval optimize

Part 9 — Deploy to Google Cloud

After eval passes and you explicitly approve :

uvx google-agents-cli scaffold enhance . --deployment-target cloud_run
uvx google-agents-cli deploy

Cloud Trace is enabled by default after deployment.

Part 10 — Publish & observe

uvx google-agents-cli publish gemini-enterprise
uvx google-agents-cli infra single-project # observability infra

Open Cloud Trace Explorer — see spans per LLM call and tool execution.

Part 11 — CLI command reference

Full list: agents-cli README

Part 12 — Mind-blowing project ideas

Use agents-cli skills + ADK to build these — each uses a different superpower:

1. Incident Gruntifier (caveman++)

On-call Slack bot that turns 500-word postmortem drafts into 3-line caveman summaries and opens a Jira ticket via a tool. Multi-tool agent with evals for brevity + accuracy.

2. Meeting → Action Agent

Ingests transcript → outputs ADK tool calls: calendar events, email drafts, Linear tasks. Eval on TOOL_USE_QUALITY and MULTI_TURN_TASK_SUCCESS.

3. RAG Doc Oracle

Clone rag-vector-search Sample from agents-cli catalog. Agent answers from your PDFs with grounding eval (GROUNDING, HALLUCINATION metrics).

4. A2A Agent Mesh

Two agents: Researcher (search tool) + Writer (compression). A2A protocol built into ADK scaffold — agents talk to each other.

5. Self-Optimizing Persona

Use eval optimize to auto-tune instructions until caveman tone scores 95%+ on INSTRUCTION_FOLLOWING — Watch prompts evolve across eval iterations.

6. Deploy-in-60-Seconds Demo

Prototype locally → scaffold enhance --deployment-target cloud_run → deploy → live public URL. Record the VHS GIF of the deploy output for your portfolio.

Prompt to start any of these:

Use agents-cli workflow skill. Read .agents-cli-spec.md.
Scaffold prototype, implement ADK tools, write 3 eval cases,
run eval generate + grade, show me failures before fixing.

Part 13 — Work with Cursor / Claude Code

After uvx google-agents-cli setupSkills appear in your agent's skill directory.

Example prompts:

Pair with our MCP Visual Guide to expose deployed agents as MCP servers.

Part 14 — agents-cli vs raw ADK

Part 15 — Hands-on checklist

# 1. Install
uvx google-agents-cli setup

# 2. Auth
uvx google-agents-cli login -i # or AI Studio key in .env

# 3. Scaffold
uvx google-agents-cli create my-agent --prototype --yes
cd my-agent && uvx google-agents-cli install

# 4. Run
uvx google-agents-cli run "Hello from ADK"

# 5. Eval
uvx google-agents-cli eval metric list
uvx google-agents-cli eval run

# 6. (Optional) Deploy — with human approval
uvx google-agents-cli scaffold enhance . --deployment-target cloud_run
uvx google-agents-cli deploy

Summary

agents-cli turns your existing coding assistant into a Google Cloud agent factory. Install with uvx google-agents-cli setup, scaffold with create, smoke-test with run, prove quality with eval, ship with deploy. The skills handle ADK patterns, so you focus on what the agent does — caveman compressors, RAG oracles, or multi-agent meshes.

Every GIF in this guide was recorded from a real terminal. Clone the tapes, re-run them, and verify them.

Thank you so much for reading

Like | Follow | Subscribe to the newsletter.

Catch us on

LinkedIn: https://www.linkedin.com/in/techlatest-net/