Ogcode

The open-source, self-hostable Grok Bot for software work.

Ogcode is an AI agent that can understand a codebase, use tools, research the web, remember decisions, plan complex work, and execute changes from a browser. It is designed as an open-source alternative to autonomous AI workspaces: your computer, your models, your data, and your rules.

Today: Ogcode is a production-ready agentic coding workbench.

Our vision: Ogcode becomes an open-source Grok Bot — a general-purpose digital teammate that can operate across your software, browser, development tools, and business workflows with your approval.

Ogcode is an independent open-source project inspired by the emerging AI-agent category. It is not affiliated with, endorsed by, or produced by xAI, Grok, or X.

Quick Start · What It Can Do · The Grok Bot Vision · Architecture · Contributing

What is Ogcode?

Most AI assistants answer questions. Ogcode is built to take responsibility for multi-step work.

You give it a goal such as:

“Add GitHub OAuth, write the tests, update the documentation, and open a pull request.”

Ogcode can inspect the repository, form a plan, ask for permission when an action is sensitive, edit files, run commands, validate the result, remember the important decisions, and organize the work into isolated branches and pull requests.

It runs as a single Go binary with an embedded web interface. You can use it from any browser and keep using your preferred editor — Vim, Emacs, VS Code, JetBrains, or no editor at all. Use a hosted model, a local model, or switch providers without changing your workflow.

The short version

• Open source and self-hostable — run Ogcode on your laptop, workstation, server, or private network.
• Agentic, not autocomplete-only — it reads, reasons, searches, edits, executes, tests, and iterates.
• Browser-native — a full workbench without locking you into a particular IDE.
• Model-agnostic — use Anthropic, OpenAI, OpenRouter, Ollama, or compatible endpoints.
• Built for long-running work — persistent memory, context curation, compaction, and resumable sessions.
• Git-native — plan features, split work into tasks, isolate changes in worktrees, and raise pull requests.
• Permission-aware — read-only exploration can be automatic; file writes, edits, and shell commands can require approval.
• Designed to grow into a general computer agent — coding is the first deeply implemented domain, not the final destination.

What Ogcode can do today

Understand projects instead of guessing

Ogcode has tools for discovering and understanding real repositories:

• Semantic codebase_map indexing for project-wide navigation.
• file_map outlines that show declarations and exact line ranges before a file is read.
• Tree-sitter parsing for Go, TypeScript/JavaScript, TSX, PHP, Python, Rust, Swift, Java, C#, and Dart.
• Targeted read, glob, and grep operations that keep irrelevant code out of the model context.
• Immediate syntax checking after supported file mutations.
• PDF and DOCX indexing for project documentation.

This is the foundation of a useful autonomous agent: it must know where to look before it starts changing things.

Build and modify software

In Build Mode, Ogcode can:

• Explain an unfamiliar codebase and trace how a feature works.
• Implement features and bug fixes across multiple files.
• Create and edit source code, documentation, configuration, and tests.
• Run shell commands, builds, tests, formatters, and project-specific workflows.
• Investigate failures, read the relevant source, and try a different fix instead of blindly retrying.
• Ask a batched set of clarifying questions when the answer is yours to give and a wrong guess would waste work.
• Produce a concise summary of what changed and how it was verified.

Sensitive tools can be configured to allow, deny, or ask for approval. Ogcode is powerful enough to modify your machine, so review permissions and deployment boundaries carefully.

Plan and execute complete features

Plan Mode turns a broad objective into an executable delivery plan:

1. Describe the outcome you want.
2. Let the planning agent inspect the repository and refine the approach with you.
3. Lock the plan.
4. Review the generated Kanban board, task descriptions, estimates, and dependencies.
5. Execute independent tasks in parallel in isolated git worktrees.
6. Commit, push, and open pull requests when configured.
7. Retry failed tasks from a clean state.

The breakdown agent is instructed to keep parallel tasks from touching the same files. Dependent tasks share a branch and execute in order, which helps produce reviewable, conflict-resistant changes rather than a pile of competing patches.

Remember the work

Agentic Session Memory stores useful facts from long-running sessions and retrieves only what is relevant to the current turn. Instead of replaying thousands of old messages, Ogcode can recall:

• Architectural decisions and rejected approaches.
• Configuration values and project conventions.
• Where an implementation lives.
• What was tried, what failed, and what remains.
• Important facts from prior sessions.

This keeps prompts smaller and more focused. In internal long-session testing, the memory loop reduced token use by more than 70% compared with naive full-transcript replay. The exact savings depend on the model, task, and session.

Research and use external knowledge

Web search is built into the binary and can search, fetch, and synthesize research for the agent. It can use multiple search engines, an optional SearxNG instance, and a macOS Safari fallback for pages that require a real browser. Research results can be used alongside your local codebase and documents.

Reusable SKILL.md instructions let teams teach Ogcode repeatable workflows such as releases, migrations, deployment, incident response, or documentation generation. Skills can declare required environment variables and can be allowed, denied, or approval-gated.

Create rich results

Ogcode can render more than plain text in the chat:

• Mermaid architecture, flow, sequence, and entity-relationship diagrams.
• LaTeX mathematics and complete LaTeX documents, including PDF generation.
• Plotly charts.
• Rough-style diagrams.
• Sandboxed HTML, CSS, and JavaScript experiences.
• Generated files placed in the workspace public/ folder for browser download or preview.

Work locally or remotely

Run Ogcode directly on your computer, in Docker, on a private server, or behind a reverse proxy. The browser UI works over HTTP, while sessions, project data, and memory remain on the host you choose. For teams, the control plane supports authenticated access, per-user workspace scoping, and remote worker sessions.

The open-source Grok Bot vision

The long-term goal is simple:

Give everyone a capable, transparent, local-first AI teammate that can turn intent into completed work across the digital world.

Ogcode is starting with software because codebases provide a clear, high-value environment for agent reliability: files are inspectable, changes are diffable, tests provide feedback, and git provides a safe history. The same agent loop can grow beyond the repository.

1. A conversational digital teammate

You should be able to tell Ogcode what outcome you want in natural language, without translating it into a checklist of commands.

It should:

• Ask the minimum necessary clarifying questions.
• Understand goals, constraints, preferences, deadlines, and definitions of done.
• Break ambiguous work into observable steps.
• Show what it plans to do before risky actions.
• Keep you informed without narrating every trivial operation.
• Pause for decisions and continue when you approve.
• Learn stable preferences without silently inventing them.

2. A computer-use agent with a browser and tools

The vision includes controlled interaction with the tools people already use:

• Open websites and navigate authenticated web applications.
• Fill forms, upload and download files, and extract information.
• Operate developer dashboards, issue trackers, project-management tools, and documentation systems.
• Use terminals, APIs, local files, git, containers, and automation scripts.
• Move information between systems while preserving an audit trail.
• Run repeatable routines on a schedule or in response to an event.

This is a planned direction, not a claim that every browser or desktop action is already implemented in the current release. Ogcode will add these capabilities incrementally, with explicit permissions and strong isolation rather than unrestricted computer control by default.

3. Software delivery from idea to production

The complete software-agent experience should cover the entire lifecycle:

• Discover and understand a product or codebase.
• Convert an idea, issue, or conversation into a technical plan.
• Delegate independent work to parallel agents.
• Implement code, tests, migrations, UI, documentation, and infrastructure.
• Run tests, static analysis, previews, and security checks.
• Review diffs and explain tradeoffs