THEGITAI
Capabilities available in the public preview

From investigation to a verified change.

Parallel research, repository-aware editing, background processes, real project verification, documents, images, web context, model choice, and reversible changes—inside one terminal session.

Start building free Explore every capability
No API keys to manage Every agent edit is reversible macOS, Linux, and Windows
representative TheGitAI session
❯Upgrade signup validation, test it, and update the docs.
◷ Working · 18s
Parallel research4 calls · one round
✓ read signup handler
✓ inspect validation tests
✓ find auth symbols
✓ read contributor rules
✓ Edited 3 files
✓ Tests passed · 42 tests
● Background bg_1 · dev server ready
Task progress
3 / 4
✓Map the auth flow
✓Implement validation
✓Run focused tests
●Update the docs
↳ Queued next
“Then review the final diff.”
↑ edit · esc cancel
Verified fixes

Trace the cause, implement the fix, and prove the result against the real project.

Repository-wide changes

Keep source, tests, configuration, and documentation moving together.

Live project awareness

Keep servers, watchers, builds, and local APIs available while the agent works.

Precise recovery

Ask the agent to reverse an edit, file, turn, or checkpoint without discarding unrelated work.

One agent, the whole loop

From “where is this?” to “the tests pass.”

TheGitAI is built for work that crosses files, tools, and stages. Give it the outcome and let it gather the evidence needed to get there.

Understand

Build a map before making a move

TheGitAI searches the repository, finds relevant code, and reads the surrounding conventions before it changes anything.

  • Exact, regex, and natural-language code search
  • Fresh reads after files change
Change

Make coherent changes across files

Ask for the feature, migration, refactor, or fix. The agent can create, patch, replace, and delete files while keeping the larger task in view.

  • Targeted replacements, patches, and full-file writes
  • Multi-file implementation and refactoring
  • Fresh-read guards against stale overwrites
Verify

Debug with the actual project

It can reproduce failures, inspect diagnostics, run focused scripts, and use your own tests, builds, linters, and typecheckers as evidence.

  • Project-aware diagnostics after edits
  • Shell commands and private scratch scripts
  • Test, lint, build, and typecheck loops
Ship

Finish the engineering loop

TheGitAI works with Git when the task calls for it, reviews the resulting diff, and can carry work from investigation through a verified change.

  • Git status, diff, branch, commit, and PR workflows
  • PR-style code review and regression checks
  • Clear handoff of changes and validation
Structure-aware in 15 languages

A repository map, not a bag of files

Tree-sitter-backed mapping extracts useful structure for the languages below. Other project files remain available through normal reading, listing, and search tools.

JavaScriptTypeScriptTSXPythonGoRustPHPJavaCC++C#Objective-CHTMLCSS / SCSSRuby
Momentum built in

It can keep several threads of work moving.

Long tasks should not feel like watching one command finish at a time. TheGitAI parallelizes safe research, manages persistent processes, shows visible task progress, and accepts your next instruction before the current turn ends.

Parallel tool calling

Research six independent paths at once

Reads, searches, listings, symbol queries, and web lookups can execute concurrently while edits and other mutations stay serial.

A task list you can actually see

Multi-step work stays legible with pending, active, and completed steps. The current list remains in view and the finished snapshot stays in the transcript.

Queue what comes next

Type one follow-up while the agent is busy. It submits automatically when the turn finishes, or you can recall, edit, replace, or cancel it.

Background jobs that belong to the session

Run up to eight dev servers, watchers, builds, or local APIs without blocking the conversation. Follow live output, inspect the captured log, stop a job by id, and let the session clean up what remains.

Background jobs guide
● bg_1 running · 4m12s
$ npm run dev
ready on http://localhost:3000
/jobs output bg_1
/jobs kill bg_1
More context than source code

Bring the spec, the screenshot, or the live web.

Real engineering work arrives in many formats. TheGitAI can bring those inputs into the same task instead of making you translate everything into a prompt first.

Documents

Work beyond plain text files

Read PDF, XLSX, and DOCX files as structured task context. Replace visible text in Word documents, including table content, and save the edited result.

  • Bounded PDF pages and DOCX paragraph ranges
  • Spreadsheet sheets rendered for analysis
  • Validated, reviewable DOCX text replacements
Images

Show it what you are seeing

Paste a screenshot or type an image path into the prompt. Vision-capable models can inspect UI states, diagrams, error screens, and visual references.

  • PNG, JPEG, GIF, and WebP input
  • Clipboard paste and automatic path attachment
  • Up to two 10 MB images in one message
The web

Research without leaving the task

Search the public web and fetch specific pages as clean Markdown, with coverage and continuation metadata when the source is too large for one read.

  • Search for current technical information
  • Fetch public URLs and follow relevant results
  • Deduplicated lookups and bounded page extraction
Power with a way back

An AI coding agent should come with a way back.

Choose the operating mode, review sensitive actions, and recover assistant changes without reaching for a destructive repository reset.

Approvals

You choose how much autonomy to give

Default mode asks before edits and commands. Auto-Accept removes repeated prompts for work you already trust. Plan mode stays read-only.

  • Approve once, approve the session, or deny
  • Local, masked sudo password entry
  • Repository containment and sensitive-path guards
Recovery

Undo the agent, not your own work

Every assistant edit is journaled. The agent can preview an undo, reverse one edit or a whole turn, and restore complete or selected files from a checkpoint.

  • Conflict-aware edit undo
  • Full and selective checkpoint restore
  • Binary-safe recovery for edited DOCX files
Local state

Resume from the repository you were in

Recent sessions are saved on your machine and scoped to each repository, alongside a compact global prompt history for requests you reuse.

  • Five recent sessions kept per repository
  • Fifteen-entry prompt-only history
  • Source-visible client and server-held provider keys

Local repository tools run on your machine. Relevant task context is sent to the server-backed model so it can respond and decide which tools to use. Provider credentials and private orchestration remain server-side. We don't store your source files, your prompts, or your conversations on our servers — saved sessions keep metadata only. See the privacy policy.

A frontier shortlist, not a catalog

Leading coding model families. No filler.

The picker spans complementary frontier families for speed, depth, and cost. Every entry is selected for serious coding work, and switching models does not clear the session you have already built.

Try the frontier shortlistSee free access

No separate provider accounts or API keys required.

GPT-5.6 Luna (OpenAI)
GPT-5.6 Terra (OpenAI)
GPT-5.6 Sol (OpenAI)
Claude Sonnet 4.6 (Anthropic)
Claude Opus 4.6 (Anthropic)
GLM 5.3 (Z.ai)
DeepSeek V4 Pro 0813 (DeepSeek)
Gemini 3.7 Flash (Google)
Gemini 3.8 Flash (Google)
Claude Sonnet 5 (Anthropic)
Claude Opus 5 (Anthropic)
Kimi K3 (Moonshot AI)
GLM 5.3 Flash (Z.ai)
Capability index

The complete working set.

The practical features available in TheGitAI today, grouped by the job they help you finish.

Repository intelligence

  • Fast whole-repository search
  • Structure-aware repository map
  • Exact and natural-language search
  • Definitions and references
  • Project diagnostics

Engineering actions

  • Create and rewrite files
  • Targeted replacements and patches
  • Delete files safely
  • Run shell commands
  • Run scratch Node scripts
  • Use Git and project tooling

Long-running work

  • Parallel read-only tool batches
  • Managed background processes
  • Live and captured job output
  • Visible task progress
  • Queued follow-up messages
  • Automatic job cleanup

Research and media

  • Public web search
  • Web pages converted to Markdown
  • PDF, XLSX, and DOCX reading
  • DOCX text editing
  • Image and screenshot understanding
  • Clipboard and path-based attachments

Safety and recovery

  • Per-action approval prompts
  • Default, Auto-Accept, and Plan modes
  • Assistant edit journal
  • Atomic checkpoint restore
  • Stale-overwrite protection
  • Secret-redacted command output

Terminal experience

  • Native responsive terminal UI
  • Markdown, tables, and diffs
  • Mouse selection and clickable links
  • Model and session pickers
  • Repo-scoped saved sessions
  • Browser and headless sign-in

Want the operating details rather than the tour?

Read the capability guide
Real autonomy, still under your control

Put the next real engineering task in motion.

Hand it a real repository and a real task. Assistant edits stay reviewable, undoable, and recoverable by checkpoint while TheGitAI carries the work to a verified change.

Start building free Explore all capabilities
No credit cardNo provider keysmacOS, Linux, and Windows